grisel-davy/Fresque-SETI
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
Fresque-SETI/Apprentissage_initial_dataset.ipynb

596 lines
41 KiB
Text
Raw Normal View History

Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
{
"cells": [
{
"cell_type": "code",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
"execution_count": 5,
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
"metadata": {},
"outputs": [],
"source": [
"#Tous les codes sont basés sur l'environnement suivant\n",
"#python 3.7\n",
"#opencv 3.1.0\n",
"#pytorch 1.4.0\n",
"\n",
"import torch\n",
"from torch.autograd import Variable\n",
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"import cv2\n",
"import matplotlib.pyplot as plt\n",
"import numpy as np\n",
"import random\n",
"import math\n",
"import pickle\n",
"import random\n",
"from PIL import Image\n",
"import sys\n",
"from glob import glob\n",
"from IPython.display import clear_output\n",
"from datetime import datetime\n",
"from time import time"
]
},
{
"cell_type": "code",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
"execution_count": 6,
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
"metadata": {},
"outputs": [],
"source": [
"#Les fonctions dans ce bloc ne sont pas utilisées par le réseau, mais certaines fonctions d'outils\n",
"\n",
"\n",
"def tensor_imshow(im_tensor,cannel):\n",
" b,c,h,w=im_tensor.shape\n",
" if c==1:\n",
" plt.imshow(im_tensor.squeeze().detach().numpy())\n",
" else:\n",
" plt.imshow(im_tensor.squeeze().detach().numpy()[cannel,:])\n",
"\n",
"# Obtenez des données d'entraînement\n",
"# frag,vt=get_training_fragment(frag_size,image)\n",
"# frag est un patch carrée de taille (frag_size*frag_size) a partir du image(Son emplacement est aléatoire)\n",
"# vt est la vérité terrain de la forme Dirac.\n",
"def get_training_fragment(frag_size,im):\n",
" h,w,c=im.shape\n",
" n=random.randint(0,int(h/frag_size)-1)\n",
" m=random.randint(0,int(w/frag_size)-1) \n",
" shape=frag_size/4\n",
" vt_h=math.ceil((h+1)/shape)\n",
" vt_w=math.ceil((w+1)/shape)\n",
" vt=np.zeros([vt_h,vt_w])\n",
" vt_h_po=round((vt_h-1)*(n*frag_size/(h-1)+(n+1)*frag_size/(h-1))/2)\n",
" vt_w_po=round((vt_w-1)*(m*frag_size/(w-1)+(m+1)*frag_size/(w-1))/2)\n",
" vt[vt_h_po,vt_w_po]=1\n",
" vt = np.float32(vt)\n",
" vt=torch.from_numpy(vt.reshape(1,1,vt_h,vt_w))\n",
" \n",
" return im[n*frag_size:(n+1)*frag_size,m*frag_size:(m+1)*frag_size,:],vt\n",
"\n",
"def load_training_fragment(fragment_path,vt_path):\n",
" # Load fragment\n",
" frag = cv2.imread(fragment_path)\n",
" \n",
" # Load vt data\n",
" with open(vt_path,'r') as f:\n",
" data_vt_raw = f.readlines()\n",
" data_vt = [int(d.rstrip('\\r\\n')) for d in data_vt_raw]\n",
" \n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" #print(\"[load_training_fragment] vt: {}:{}\".format(data_vt[2],data_vt[3]))\n",
" \n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" # Construct vt\n",
" vt = np.zeros((int(data_vt[0]/4)+1,int(data_vt[1]/4)+1))\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" #print(\"[load_training_fragment] point 1 placé en : {}:{}\".format(data_vt[2]/4,data_vt[3]/4))\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" vt[int(data_vt[2]/4),int(data_vt[3]/4)] = 1\n",
" vt = np.float32(vt)\n",
" vt = torch.from_numpy(vt.reshape(1,1,int(data_vt[0]/4)+1,int(data_vt[1]/4)+1))\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" #print(\"[load_training_fragment] taille de la vt: HxW {}x{}\".format(vt.shape[2],vt.shape[3]))\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" \n",
" return(frag,vt)\n",
"\n",
"\n",
"# Cette fonction convertit l'image en variable de type Tensor.\n",
"# Toutes les données de calcul du réseau sont de type Tensor\n",
"# Img.shape=[Height,Width,Channel]\n",
"# Tensor.shape=[Batch,Channel,Height,Width]\n",
"def img2tensor(im):\n",
" im=np.array(im,dtype=\"float32\")\n",
" tensor_cv = torch.from_numpy(np.transpose(im, (2, 0, 1)))\n",
" im_tensor=tensor_cv.unsqueeze(0)\n",
" return im_tensor\n",
"\n",
"# Trouvez les coordonnées de la valeur maximale dans une carte de corrélation\n",
"# x,y=show_coordonnee(carte de corrélation)\n",
"def show_coordonnee(position_pred):\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" map_corre=position_pred.squeeze().detach().cpu().numpy()\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" h,w=map_corre.shape\n",
" max_value=map_corre.max()\n",
" coordonnee=np.where(map_corre==max_value)\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" return coordonnee[0].mean(),coordonnee[1].mean()\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
"\n",
"# Filtrer les patchs en fonction du nombre de pixels noirs dans le patch\n",
"# Si seuls les pixels non noirs sont plus grands qu'une certaine proportion(seuillage), revenez à True, sinon False\n",
"def test_fragment32_32(frag,seuillage):\n",
" a=frag[:,:,0]+frag[:,:,1]+frag[:,:,2]\n",
" mask = (a == 0)\n",
" arr_new = a[mask]\n",
" if arr_new.size/a.size<=(1-seuillage):\n",
" return True\n",
" else:\n",
" return False\n",
" \n",
"# Ces deux fonctions permettent de sauvegarder le réseau dans un fichier\n",
"# ou de load le réseau stocké à partir d'un fichier\n",
"def save_net(file_path,net):\n",
" pkl_file = open(file_path, 'wb')\n",
" pickle.dump(net,pkl_file)\n",
" pkl_file.close()\n",
"def load_net(file_path): \n",
" pkl_file = open(file_path, 'rb')\n",
" net= pickle.load(pkl_file)\n",
" pkl_file.close()\n",
" return net"
]
},
{
"cell_type": "code",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
"execution_count": 7,
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
"metadata": {},
"outputs": [],
"source": [
"# Créer un poids de type DeepMatch comme valeur initiale de Conv1 (non obligatoire)\n",
"def ini():\n",
" kernel=torch.zeros([8,3,3,3])\n",
" array_0=np.array([[1,2,1],[0,0,0],[-1,-2,-1]],dtype='float32')\n",
" array_1=np.array([[2,1,0],[1,0,-1],[0,-1,-2]],dtype='float32')\n",
" array_2=np.array([[1,0,-1],[2,0,-2],[1,0,-1]],dtype='float32')\n",
" array_3=np.array([[0,-1,-2],[1,0,-1],[2,1,0]],dtype='float32')\n",
" array_4=np.array([[-1,-2,-1],[0,0,0],[1,2,1]],dtype='float32')\n",
" array_5=np.array([[-2,-1,0],[-1,0,1],[0,1,2]],dtype='float32')\n",
" array_6=np.array([[-1,0,1],[-2,0,2],[-1,0,1]],dtype='float32')\n",
" array_7=np.array([[0,1,2],[-1,0,1],[-2,-1,0]],dtype='float32')\n",
" for i in range(3):\n",
" kernel[0,i,:]=torch.from_numpy(array_0)\n",
" kernel[1,i,:]=torch.from_numpy(array_1)\n",
" kernel[2,i,:]=torch.from_numpy(array_2)\n",
" kernel[3,i,:]=torch.from_numpy(array_3)\n",
" kernel[4,i,:]=torch.from_numpy(array_4)\n",
" kernel[5,i,:]=torch.from_numpy(array_5)\n",
" kernel[6,i,:]=torch.from_numpy(array_6)\n",
" kernel[7,i,:]=torch.from_numpy(array_7)\n",
" return torch.nn.Parameter(kernel,requires_grad=True) \n",
"\n",
"# Calculer le poids initial de la couche convolutive add\n",
"# n, m signifie qu'il y a n * m sous-patches dans le patch d'entrée\n",
"# Par exemple, le patch d'entrée est 16 * 16, pour les patchs 4 * 4 de la première couche, n = 4, m = 4\n",
"# pour les patchs 8 * 8 de la deuxième couche, n = 2, m = 2\n",
"def kernel_add_ini(n,m):\n",
" input_canal=int(n*m)\n",
" output_canal=int(n/2)*int(m/2)\n",
" for i in range(int(n/2)):\n",
" for j in range(int(m/2)):\n",
" kernel_add=np.zeros([1,input_canal],dtype='float32')\n",
" kernel_add[0,i*2*m+j*2]=1\n",
" kernel_add[0,i*2*m+j*2+1]=1\n",
" kernel_add[0,(i*2+1)*m+j*2]=1\n",
" kernel_add[0,(i*2+1)*m+j*2+1]=1\n",
" if i==0 and j==0:\n",
" add=torch.from_numpy(kernel_add.reshape(1,input_canal,1,1))\n",
" else:\n",
" add_=torch.from_numpy(kernel_add.reshape(1,input_canal,1,1))\n",
" add=torch.cat((add,add_),0)\n",
" return torch.nn.Parameter(add,requires_grad=False) \n",
"\n",
"# Calculer le poids initial de la couche convolutive shift\n",
"# shift+add Peut réaliser l'étape de l'agrégation\n",
"# Voir ci-dessus pour les paramètres n et m. \n",
"# Pour des étapes plus détaillées, veuillez consulter mon rapport de stage\n",
"def kernel_shift_ini(n,m):\n",
" input_canal=int(n*m)\n",
" output_canal=int(n*m)\n",
" \n",
" kernel_shift=torch.zeros([output_canal,input_canal,3,3])\n",
" \n",
" array_0=np.array([[1,0,0],[0,0,0],[0,0,0]],dtype='float32')\n",
" array_1=np.array([[0,0,1],[0,0,0],[0,0,0]],dtype='float32')\n",
" array_2=np.array([[0,0,0],[0,0,0],[1,0,0]],dtype='float32')\n",
" array_3=np.array([[0,0,0],[0,0,0],[0,0,1]],dtype='float32')\n",
" \n",
" kernel_shift_0=torch.from_numpy(array_0)\n",
" kernel_shift_1=torch.from_numpy(array_1)\n",
" kernel_shift_2=torch.from_numpy(array_2)\n",
" kernel_shift_3=torch.from_numpy(array_3)\n",
" \n",
" \n",
" for i in range(n):\n",
" for j in range(m):\n",
" if i==0 and j==0:\n",
" kernel_shift[0,0,:]=kernel_shift_0\n",
" else:\n",
" if i%2==0 and j%2==0:\n",
" kernel_shift[i*m+j,i*m+j,:]=kernel_shift_0\n",
" if i%2==0 and j%2==1:\n",
" kernel_shift[i*m+j,i*m+j,:]=kernel_shift_1\n",
" if i%2==1 and j%2==0:\n",
" kernel_shift[i*m+j,i*m+j,:]=kernel_shift_2\n",
" if i%2==1 and j%2==1:\n",
" kernel_shift[i*m+j,i*m+j,:]=kernel_shift_3\n",
" \n",
" return torch.nn.Parameter(kernel_shift,requires_grad=False) \n",
"\n",
"# Trouvez le petit patch(4 * 4) dans la n ème ligne et la m ème colonne du patch d'entrée\n",
"# Ceci est utilisé pour calculer la convolution et obtenir la carte de corrélation\n",
"def get_patch(fragment,psize,n,m):\n",
" return fragment[:,:,n*psize:(n+1)*psize,m*psize:(m+1)*psize]\n",
"###################################################################################################################\n",
"class Net(nn.Module):\n",
" def __init__(self,frag_size,psize):\n",
" super(Net, self).__init__()\n",
" \n",
" h_fr=frag_size\n",
" w_fr=frag_size\n",
" \n",
" n=int(h_fr/psize) # n*m patches dans le patch d'entrée\n",
" m=int(w_fr/psize)\n",
" \n",
" self.conv1 = nn.Conv2d(3,8,kernel_size=3,stride=1,padding=1)\n",
" # Si vous souhaitez initialiser Conv1 avec les poids de DeepMatch, exécutez la ligne suivante\n",
" #self.conv1.weight=ini()\n",
" self.Relu = nn.ReLU(inplace=True)\n",
" self.maxpooling=nn.MaxPool2d(3,stride=2, padding=1)\n",
" \n",
" self.shift1=nn.Conv2d(n*m,n*m,kernel_size=3,stride=1,padding=1)\n",
" self.shift1.weight=kernel_shift_ini(n,m)\n",
" self.add1 = nn.Conv2d(n*m,int(n/2)*int(m/2),kernel_size=1,stride=1,padding=0)\n",
" self.add1.weight=kernel_add_ini(n,m)\n",
" \n",
" n=int(n/2)\n",
" m=int(m/2)\n",
" if n>=2 and m>=2:# Si n=m=1，Notre réseau n'a plus besoin de plus de couches pour agréger les cartes de corrélation\n",
" self.shift2=nn.Conv2d(n*m,n*m,kernel_size=3,stride=1,padding=1)\n",
" self.shift2.weight=kernel_shift_ini(n,m)\n",
" self.add2 = nn.Conv2d(n*m,int(n/2)*int(m/2),kernel_size=1,stride=1,padding=0)\n",
" self.add2.weight=kernel_add_ini(n,m)\n",
" \n",
" n=int(n/2)\n",
" m=int(m/2)\n",
" if n>=2 and m>=2:\n",
" self.shift3=nn.Conv2d(n*m,n*m,kernel_size=3,stride=1,padding=1)\n",
" self.shift3.weight=kernel_shift_ini(n,m)\n",
" self.add3 = nn.Conv2d(n*m,int(n/2)*int(m/2),kernel_size=1,stride=1,padding=0)\n",
" self.add3.weight=kernel_add_ini(n,m)\n",
" \n",
" def get_descripteur(self,img,using_cuda):\n",
" # Utilisez Conv1 pour calculer le descripteur,\n",
" descripteur_img=self.Relu(self.conv1(img))\n",
" b,c,h,w=descripteur_img.shape\n",
" couche_constante=0.5*torch.ones([1,1,h,w])\n",
" if using_cuda:\n",
" couche_constante=couche_constante.cuda()\n",
" # Ajouter une couche constante pour éviter la division par 0 lors de la normalisation\n",
" descripteur_img=torch.cat((descripteur_img,couche_constante),1)\n",
" # la normalisation\n",
" descripteur_img_norm=descripteur_img/torch.norm(descripteur_img,dim=1)\n",
" return descripteur_img_norm\n",
" \n",
" def forward(self,img,frag,using_cuda):\n",
" psize=4\n",
" # Utilisez Conv1 pour calculer le descripteur,\n",
" descripteur_input1=self.get_descripteur(img,using_cuda)\n",
" descripteur_input2=self.get_descripteur(frag,using_cuda)\n",
" \n",
" b,c,h,w=frag.shape\n",
" n=int(h/psize)\n",
" m=int(w/psize)\n",
" \n",
" #######################################\n",
" # Calculer la carte de corrélation par convolution pour les n*m patchs plus petit.\n",
" for i in range(n):\n",
" for j in range(m):\n",
" if i==0 and j==0:\n",
" map_corre=F.conv2d(descripteur_input1,get_patch(descripteur_input2,psize,i,j),padding=2)\n",
" else:\n",
" a=F.conv2d(descripteur_input1,get_patch(descripteur_input2,psize,i,j),padding=2)\n",
" map_corre=torch.cat((map_corre,a),1)\n",
" ########################################\n",
" # Étape de polymérisation\n",
" map_corre=self.maxpooling(map_corre)\n",
" map_corre=self.shift1(map_corre)\n",
" map_corre=self.add1(map_corre)\n",
" \n",
" #########################################\n",
" # Répétez l'étape d'agrégation jusqu'à obtenir le graphique de corrélation du patch d'entrée\n",
" n=int(n/2)\n",
" m=int(m/2)\n",
" if n>=2 and m>=2:\n",
" map_corre=self.maxpooling(map_corre)\n",
" map_corre=self.shift2(map_corre)\n",
" map_corre=self.add2(map_corre)\n",
" \n",
" \n",
" n=int(n/2)\n",
" m=int(m/2)\n",
" if n>=2 and m>=2:\n",
" map_corre=self.maxpooling(map_corre)\n",
" map_corre=self.shift3(map_corre)\n",
" map_corre=self.add3(map_corre)\n",
" \n",
" \n",
" b,c,h,w=map_corre.shape\n",
" # Normalisation de la division par maximum\n",
" map_corre=map_corre/(map_corre.max())\n",
" # Normalisation SoftMax\n",
" #map_corre=(F.softmax(map_corre.reshape(1,1,h*w,1),dim=2)).reshape(b,c,h,w)\n",
" return map_corre"
]
},
{
"cell_type": "code",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
"execution_count": 8,
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
"metadata": {},
"outputs": [],
"source": [
"def run_net(net,img,frag,frag_size,using_cuda):\n",
" h,w,c=frag.shape\n",
" n=int(h/frag_size)\n",
" m=int(w/frag_size)\n",
" frag_list=[]\n",
" #####################################\n",
" # Obtenez des patchs carrés des fragments et mettez-les dans la frag_list\n",
" for i in range(n):\n",
" for j in range(m):\n",
" frag_32=frag[i*frag_size:(i+1)*frag_size,j*frag_size:(j+1)*frag_size]\n",
" if test_fragment32_32(frag_32,0.6):\n",
" frag_list.append(frag_32)\n",
" img_tensor=img2tensor(img)\n",
" ######################################\n",
" if using_cuda:\n",
" img_tensor=img_tensor.cuda()\n",
" \n",
" coordonnee_list=[]\n",
" #######################################\n",
" # Utilisez le réseau pour calculer les positions de tous les patchs dans frag_list[]\n",
" # Mettez le résultat du calcul dans coordonnee_list[]\n",
" for i in range(len(frag_list)):\n",
" frag_tensor=img2tensor(frag_list[i])\n",
" if using_cuda:\n",
" frag_tensor=frag_tensor.cuda()\n",
" res=net.forward(img_tensor,frag_tensor,using_cuda)\n",
" if using_cuda:\n",
" res=res.cpu()\n",
" po_h,po_w=show_coordonnee(res)\n",
" coordonnee_list.append([po_h,po_w])\n",
" h_img,w_img,c=img.shape\n",
" position=[]\n",
" for i in range(len(coordonnee_list)):\n",
" x=int(round(h_img*coordonnee_list[i][0]))\n",
" y=int(round(w_img*coordonnee_list[i][1]))\n",
" position.append([x,y])\n",
" return position"
]
},
{
"cell_type": "code",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
"execution_count": 9,
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
"Net sauvegardés dans ./trained_net/net_trainned_02-02_21-44_0002\n",
"Poids sauvegardés dans ./trained_net/save_weights_02-02_21-44_2\n"
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
]
}
],
"source": [
"if __name__=='__main__':\n",
" \n",
" # La taille du patch d'entrée est de 16*16\n",
" frag_size=16\n",
" # La taille du plus petit patch dans réseau est de 4 *4 fixée\n",
" psize=4\n",
" using_cuda=True\n",
" \n",
" # Variable des données\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" base_dir = './training_data_maybe-good/'\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" fresque_filename = base_dir+'fresque_small{}.ppm'\n",
" fresque_filename_wild = base_dir+'fresque_small*.ppm'\n",
" fragment_filename = base_dir+'fragments/fresque{}/frag_dev_{:05}.ppm'\n",
" fragments_filename_wild = base_dir+'fragments/fresque{}/frag_dev_*.ppm'\n",
" vt_filename = base_dir+'fragments/fresque{}/vt/frag_dev_{:05}_vt.txt'\n",
" fragment_id_offset = 200\n",
" \n",
" \n",
" net=Net(frag_size,psize)\n",
" \n",
" # Pour chaque fresque, le nombre d'itérations est de 1000\n",
" itera=1000\n",
" \n",
" if using_cuda:\n",
" net=net.cuda()\n",
" \n",
" # Choisissez l'optimiseur et la fonction de coût\n",
" optimizer = torch.optim.Adam(net.parameters())\n",
" loss_func = torch.nn.MSELoss()\n",
" \n",
" # Dans le processus d'apprentissage du réseau,le changement d'erreur est placé dans loss_value=[] \n",
" # et le changement de Conv1 poids est placé dans para_value[]\n",
" loss_value=[]\n",
" w_values=[]\n",
" ####################################################training_net\n",
" \n",
" # Detection des fresques\n",
" fresques_paths = glob(fresque_filename_wild) \n",
" N_fresque = len(fresques_paths)\n",
" \n",
" time_old = time()\n",
" \n",
" # Iteration sur les fresques trouvées\n",
" for fresque_id,fresque_path in enumerate(fresques_paths):\n",
" # Charge la fresque\n",
" fresque=cv2.imread(fresque_path)\n",
" h,w,c=fresque.shape\n",
" fresque_tensor=img2tensor(fresque)\n",
" \n",
" # Si GPU, conversion de la fresque\n",
" if using_cuda:\n",
" fresque_tensor=fresque_tensor.cuda()\n",
" \n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" # Recherche des fragments d'entrainement\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" fragments_paths = glob(fragments_filename_wild.format(fresque_id))\n",
" N_fragments = len(fragments_paths)\n",
" for fragment_id,fragment_path in enumerate(fragments_paths):\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" #clear_output(wait=True)\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" print(\"Fresque {}, fragment {}/{} ({:.3}%)\".format(fresque_id,fragment_id,N_fragments,(fragment_id/N_fragments)*100))\n",
" print(\"Temps par fragment: {:.3}\".format(time()-time_old))\n",
" time_old = time()\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" # De temps en temps, enregistrez les nouveau poids\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" if fragment_id%50==0:\n",
" w_values.append(net.conv1.weight.data.cpu().numpy())\n",
" \n",
" # Chargement du fragment et de la vt\n",
" frag,vt=load_training_fragment(fragment_path,vt_filename.format(fresque_id,fragment_id+fragment_id_offset))\n",
" \n",
" # si GPU, conversion des objects\n",
" frag_tensor=img2tensor(frag)\n",
" if using_cuda:\n",
" vt=vt.cuda()\n",
" frag_tensor=frag_tensor.cuda()\n",
" \n",
" frag_pred=net.forward(fresque_tensor,frag_tensor,using_cuda)\n",
" b,c,h,w=vt.shape\n",
" # Utilisez la fonction de coût pour calculer l'erreur\n",
" err_=loss_func(vt,frag_pred)\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" #print(\"[MAIN] position choisie dans la carte de correlation: {}\".format(show_coordonnee(frag_pred)))\n",
" #print(\"[MAIN] Valeur de la loss: {}\".format(err_.tolist()))\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" # Utilisez l'optimiseur pour ajuster le poids de Conv1\n",
" optimizer.zero_grad()\n",
" err_.backward(retain_graph=True)\n",
" optimizer.step()\n",
" \n",
" loss_value.append(err_.tolist())\n",
" \n",
" del frag_tensor,frag_pred,err_,vt\n",
" torch.cuda.empty_cache()\n",
" \n",
" # Sauvegarder le réseau\n",
" save_dir = './trained_net/'\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" expe_id = 2\n",
" net_filename = save_dir + \"net_trainned_{}_{:04}\".format(datetime.now().strftime(\"%m-%d_%H-%M\"),expe_id)\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" save_net(net_filename,net)\n",
" \n",
" # Sauvegarder les poids\n",
Ajout de code et modifications
2021-02-11 09:00:27 +01:00
" poids_filename = save_dir + \"save_weights_{}_{:04}\".format(datetime.now().strftime(\"%m-%d_%H-%M\"),expe_id)\n",
Outils entrainer et évaluer les modèles
2021-02-02 10:31:38 +01:00
" with open(poids_filename,'wb') as f:\n",
" pickle.dump(w_values,f)\n",
" \n",
" print(\"Net sauvegardés dans {}\".format(net_filename))\n",
" print(\"Poids sauvegardés dans {}\".format(poids_filename))\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Poids pickled.\n"
]
}
],
"source": [
"with open('./save_weights','wb') as f:\n",
" pickle.dump(w_values,f)\n",
"print(\"Poids pickled.\")"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(3, 3, 3)\n",
"(8, 3, 3, 3)\n"
]
}
],
"source": [
"w = w_values[0]\n",
"print(w.shape)\n",
"print(net.conv1.weight.data.cpu().numpy().shape)"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[<matplotlib.lines.Line2D at 0x7f9cc2acab50>]"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAD4CAYAAAD8Zh1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nO3dd5wTdfoH8M+zjaXXpZelwwrSlmIBUZSuWM92FjyP405PTz1+4CnoKXJYDhsox6l4eipy6iknVaQjZZeyCyy7bAWWBXZhK23r9/dHJtlJMkkmyUwmkzzv14sXm8lk5skkeeY73/kWEkKAMcaY+UUYHQBjjDFtcEJnjLEQwQmdMcZCBCd0xhgLEZzQGWMsREQZteM2bdqI+Ph4o3bPGGOmtG/fvnNCiDil5wxL6PHx8UhOTjZq94wxZkpEdNzVc1zlwhhjIYITOmOMhQhO6IwxFiI4oTPGWIjghM4YYyGCEzpjjIUITuiMMRYiTJfQM85UYNGGDJy7UGl0KIwxFlRMl9CzCi/gvU1ZKL5YZXQojDEWVEyX0Iks/9fxxByMMWbHdAk9QkronM8ZY8ye6RI6YMnoXEJnjDF7pkvoXEIPTgWll7E5vdDoMBgLa6ZL6CRVonNCDy6T3t2O6Z8mGR0GY2HNdAndVkIHZ/RgUna52ugQGAt7pkvo9a1cjI2DMcaCjQkTurXKhTM6Y4zJmS+hS/9zCZ0xxuyZLqFHWOtcuA6dMcbsmC6hcx06Y4wpM11Cj+Bmi4wxpsh0Cb2+Dp0zOmOMyZkvoXMJnTHGFJkwoVv+52aLjDFmz3QJ3VaHbnAcjDEWbEyX0Hk8dMYYU2a6hM6jLTLGmDLTJXQeD50xxpSZLqHXj7bIGGNMznQJnQfnYowxZaZL6FyHzhhjykyX0MlWh25wIIwxFmRUJXQimkhEGUSURURzFJ5vTkT/I6IUIjpCRNO1D9W6L8v/XOXCGGP2PCZ0IooEsATAJAAJAO4nogSH1Z4AkCaEGARgLIC/E1GMxrFK8Vj+5xI6Y4zZU1NCHwEgSwiRI4SoArACwDSHdQSApmS5Y9kEQDGAGk0jlfB46IwxpkxNQu8E4KTscb60TG4xgP4ACgAcAvC0EKLOcUNENIOIkokouaioyKeAuYTOGGPK1CR0UljmmE4nADgIoCOAwQAWE1EzpxcJsUwIkSiESIyLi/M6WIDHQ2eMMVfUJPR8AF1kjzvDUhKXmw7gO2GRBSAXQD9tQrTH46EzxpgyNQk9CUBvIuou3ei8D8Aqh3VOABgHAETUDkBfADlaBmpFPNoiY4wpivK0ghCihoieBLAeQCSAT4QQR4hopvT8UgCvAviUiA7BUoieLYQ4p0fA3GyRMcaUeUzoACCEWANgjcOypbK/CwCM1zY0ZVyHzhhjykzYU9SiqKLS0DgYYyzYmC6hZxZeAAC8tuaowZEwxlhwMV1Cr6l1at7OGGMMJkzojDHGlJkuobdp2gAAEBttutDDwrJt2UaHwFjYMl1WjG/dGAAwe6Iu/ZaYnxasSTc6BMbClukSurUdelSE0ogEjDEWvkyX0K24GTpjjNkzXULncjljjCkzXUJnjDGmzLQJnbv+M8aYPdMldCKudGGMMSWmS+hWPNoiY4zZM11C5/J58KusqTU6BBaG9uScx9MrDoR1Yc90Cd0qfD+y4Fd2udroEFgYeviTvfjhYAEqa8J3vCfTJXSuQmeMMWWmS+gs+L2zMdPoEBgLS6ZN6GFcTRb0vtxzwugQGAtLpkvoxLdFGWNMkekSuhUX0BljzJ75EnoYFtCPna3gpoCMMY/Ml9Al4dLW9PyFSox/exue/+6Q0aEwZgphkhoUmS6hh1uzxYuVlpJ5Ul6xwZEwFtzCLTcoMV1CDzdCultQWF5pcCSMsWBnuoQebifhgydLASCse78xxtQxXUIPN7V1YVwhyBjzimkTerjc+AiX98kY85/pEjqPh84YY8pMl9CtBHctYowpCOfcYLqEHkrl89JLVcgqrDA6DMZCAg8LYsKEbhUKdcu3Ld6Jmxdtc7uOWWuYSi9VGR0CY2HHdAndrAlOyYniS0aHoJvX16UbHQJjYcd0Cd0qBAroqpj1SiS78KLRITAWdkyX0LWqJ8sqrOA23oyFkHC+GWpluoSuhazCCty8aBve3XjM6FA84q8oY94J55ujqhI6EU0kogwiyiKiOS7WGUtEB4noCBFt1TZMZ/5URZyVxkVJPl6iUTSMsWARziX1KE8rEFEkgCUAbgGQDyCJiFYJIdJk67QA8AGAiUKIE0TUVq+APd0UfeLL/ai4UoPPHhvhcRt1JqigDt+yBmPeCeeSuZXHhA5gBIAsIUQOABDRCgDTAKTJ1nkAwHdCiBMAIIQo1DpQR67OwqtTT3t8bYSU0bkKXT8l3GyRsYBTU+XSCcBJ2eN8aZlcHwAtiWgLEe0jooeVNkREM4gomYiSi4qKfItY8sa6DFXrpeaX4mJljd0ya0IPl0kyjJBZeMHoEBjT3Y7Mc4ifsxqFFVeMDgWAuoSudB3jmAmjAAwDMAXABABziaiP04uEWCaESBRCJMbFxXkdrLeKL1bhtsU7ce3CTbZlv/rHLqxOLQDAIxkyxvyzfGcuACD1ZJnBkVioqXLJB9BF9rgzgAKFdc4JIS4CuEhE2wAMAqB5MxJvOhZ9s89yYVF2udq2bG9uMfbmWmb/MUM+N0GIjLEgoaaEngSgNxF1J6IYAPcBWOWwzg8ARhNRFBE1AjASwFFtQ/VOWkE5Fqxx31tRqcqlprYOO7PO6RJT3jnvO9vwbR7mj4935OLrpBNGh8ECxGNCF0LUAHgSwHpYkvRKIcQRIppJRDOldY4CWAcgFcBeAB8JIQ7rEbDaO9mT39tu91gIgUUb7OvdlUrob288hgc/2mMrxWtlU/pZjH1rC35Mdby4YUw/r/6YhtnfhtcE44G8NRZsV9BqqlwghFgDYI3DsqUOj98E8KZ2oWlr7eEzeG9Tlt0yebPFXdnnkXGm3NZl/fwF+zk8hRD4cGs27hveFa0ax3i9/6OnLaMqHikox9SrO3r9esaYe0aO8xQsY0ypSuih4A9f7HdaVieA/JJL+OFgAd5cbym9T7yqveLrk/JK8Ma6DBw4UYp/Ppyoa6yMMeYL0yV0rc+EY97YrOrmaHWtZZJmxyaQnhw7W4FZ36Tiup6tfQmPMcZUC8uxXORcJfPL1bVebaeyphbrDp9xWv762nSknCzF7pzzAMw7eiJjLPiZLqHrXVV1uMDSnvTZlSnYf6IEP6WdRY1UOnfnN58mY+a/99napTqyjh/zr1/yAAA/Hz2rTcCMMSYxXUJ354KX1SFK8ksu2/6+84Nf8NvPkrFkczYOnix1+7odUlPHlcn5is+fKrVs93J1LfLOXcRv/pXsd6zM4vCpMiTMWxc0vfUYM4oJ69Dry+iVNbVoEBVpezzhbffTufnqbY2H2b1Y5f+Jh9X7eEcuLlXVYkfmOdw5tLPR4TCDBbJWM9iGDzF1CX3plhwk59W3F7eWgoPJ/hOeh+hdsjnL5RcjuL4ujAWH6to6ZJ61n2DdyJaDwdJs0XQJXX7c3t54DHcv3YVd2ecNi8cdIQRKLlV7XO/N9Rl2VT2MMffm/5iGW97eFpSFOCOZLqErOX7et/krfblc8vSSo6fLkSt18V+2LceXsBhjHiTlWa58Sy7yMM1yIZHQ53znW9fm4+cvaRyJxY1vbQEAbM/0f0yYILmSYyzocfWkCRO6q7oqX1q4eNvWHAB25ZxHndR4/fF/JeOprw54vQ1Ppfyb3tqCN9a5H1iM1QvEjal1h89g8rvbbZ89C17hXAgyXUJ3pfyy57pqrfySfR5f7DmOjUfPYlVKAbKLvJvMYer7O9w+n3PuIj7Yku1PiGFJzxtTz3x9EGmny3GlxvtCAGOBYupmi3LnHAbT0tPSrdm2ducAUKrBdGuuCplcHmTMmbuTdzj/ZkKmhP7d/lMB29cOleOlh/Ps46EmnD7L7KILKDBh6xEjqlqC7VsRMgndSGUaVPfU6lQPXHGlOug6P5hZOMwsP+7vW+2mbWS
"text/plain": [
"<Figure size 432x288 with 1 Axes>"
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"plt.plot(loss_value)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"file_path=\"./net_trainned6000\"\n",
"save_net(file_path,net)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}
Reference in a new issue Copy permalink