Skip to content
Snippets Groups Projects
Commit e3c9c6c9 authored by Sucio's avatar Sucio
Browse files

Update Rapport.ipynb

parent 0ff7ac97
No related branches found
No related tags found
No related merge requests found
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<h1>Classification d'Images</h1> <h1>Classification d'Images</h1>
<p><a href="https://gitlab.ec-lyon.fr/edelland/mod_4_6-td1">Énoncé du TD</a>.</p> <p><a href="https://gitlab.ec-lyon.fr/edelland/mod_4_6-td1">Énoncé du TD</a>.</p>
<h2>Introduction</h2> <h2>Introduction</h2>
<p>Ce TD a pour objectif d'appliquer les méthodes de classification abordées en cours. Nous allons travailler sur la base de données <a href="https://www.cs.toronto.edu/~kriz/cifar.html">CIFAR-10</a>. Dans un premier temps, nous mettrons en œuvre la classification par les k-plus proches voisins en utilisant la distance euclidienne. Ensuite, nous explorerons la classification à l'aide de réseaux de neurones. Pour chaque méthode, nous évaluerons le taux de réussite.</p> <p>Ce TD a pour objectif d'appliquer les méthodes de classification abordées en cours. Nous allons travailler sur la base de données <a href="https://www.cs.toronto.edu/~kriz/cifar.html">CIFAR-10</a>. Dans un premier temps, nous mettrons en œuvre la classification par les k-plus proches voisins en utilisant la distance euclidienne. Ensuite, nous explorerons la classification à l'aide de réseaux de neurones. Pour chaque méthode, nous évaluerons le taux de réussite.</p>
<p>Afin que ce document puisse rester interactif, les fonctions longues à exécuter ont été désactivées et les résultats sont fournis manuellement.</p> <p>Afin que ce document puisse rester interactif, les fonctions longues à exécuter ont été désactivées et les résultats sont fournis manuellement.</p>
<h2>Importation des Données</h2> <h2>Importation des Données</h2>
<p>Nous importons les bibliothèques nécessaires pour charger et traiter les fichiers.</p> <p>Nous importons les bibliothèques nécessaires pour charger et traiter les fichiers.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
import numpy as np import numpy as np
import pickle import pickle
import os import os
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p>Nous extrayons ces données et développons des fonctions qui nous permettront de créer des listes d'images d'entraînement et de test à partir de ces données. De plus, nous récupérons les listes de libellés de classe associées à chaque image, ce qui nous permettra d'attribuer un libellé à une image de test et de la comparer ensuite au libellé réel de l'image.</p> <p>Nous extrayons ces données et développons des fonctions qui nous permettront de créer des listes d'images d'entraînement et de test à partir de ces données. De plus, nous récupérons les listes de libellés de classe associées à chaque image, ce qui nous permettra d'attribuer un libellé à une image de test et de la comparer ensuite au libellé réel de l'image.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def read_cifar_batch(batch_path): def read_cifar_batch(batch_path):
with open(batch_path, 'rb') as file: with open(batch_path, 'rb') as file:
batch_data = pickle.load(file, encoding='bytes') batch_data = pickle.load(file, encoding='bytes')
data = np.array(batch_data[b'data'], dtype=np.float32) data = np.array(batch_data[b'data'], dtype=np.float32)
labels = np.array(batch_data[b'labels'], dtype=np.int64) labels = np.array(batch_data[b'labels'], dtype=np.int64)
return data, labels return data, labels
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def read_cifar(path_folder): def read_cifar(path_folder):
data = np.empty((0, 3072), dtype=np.float32) data = np.empty((0, 3072), dtype=np.float32)
labels = np.empty((0), dtype=np.int64) labels = np.empty((0), dtype=np.int64)
for filename in os.listdir(path_folder): for filename in os.listdir(path_folder):
if filename.startswith("data_batch") or filename == "test_batch": if filename.startswith("data_batch") or filename == "test_batch":
batch_path = os.path.join(path_folder, filename) batch_path = os.path.join(path_folder, filename)
d, l = read_cifar_batch(batch_path) d, l = read_cifar_batch(batch_path)
data = np.concatenate((data, d), axis=0) data = np.concatenate((data, d), axis=0)
labels = np.concatenate((labels, l), axis=None) labels = np.concatenate((labels, l), axis=None)
return(data,labels) return(data,labels)
``` ```
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def split_dataset(data, labels, split_factor): def split_dataset(data, labels, split_factor):
num_samples = len(data) num_samples = len(data)
shuffled_indices = np.random.permutation(num_samples) shuffled_indices = np.random.permutation(num_samples)
split_index = int(num_samples * split_factor) split_index = int(num_samples * split_factor)
data_train = data[shuffled_indices[:split_index],:] data_train = data[shuffled_indices[:split_index],:]
labels_train = labels[shuffled_indices[:split_index]] labels_train = labels[shuffled_indices[:split_index]]
data_test = data[shuffled_indices[split_index:],:] data_test = data[shuffled_indices[split_index:],:]
labels_test = labels[shuffled_indices[split_index:]] labels_test = labels[shuffled_indices[split_index:]]
return data_train, labels_train, data_test, labels_test return data_train, labels_train, data_test, labels_test
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p>Afin de vérifier le bon fonctionnement de ces fonctions, nous les appliquons à une liste de 10 images. Nous vérifions que les images d'entraînement et de test sont correctement sélectionnées de manière aléatoire à partir de la base de données.</p> <p>Afin de vérifier le bon fonctionnement de ces fonctions, nous les appliquons à une liste de 10 images. Nous vérifions que les images d'entraînement et de test sont correctement sélectionnées de manière aléatoire à partir de la base de données.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
if __name__ == "__main__": if __name__ == "__main__":
#read_cifar_batch("data/cifar-10-batches-py/data_batch_1") #read_cifar_batch("data/cifar-10-batches-py/data_batch_1")
d, l = read_cifar("data/cifar-10-batches-py") d, l = read_cifar("data/cifar-10-batches-py")
print(l[0:10]) print(l[0:10])
d_1, l_1, d_2, l_2 = split_dataset(d[:10,:], l[:10], 0.9) d_1, l_1, d_2, l_2 = split_dataset(d[:10,:], l[:10], 0.9)
print(l_1,l_2) print(l_1,l_2)
d_1, l_1, d_2, l_2 = split_dataset(d[:10,:], l[:10], 0.9) d_1, l_1, d_2, l_2 = split_dataset(d[:10,:], l[:10], 0.9)
print(l_1,l_2) print(l_1,l_2)
``` ```
%% Output %% Output
[6 9 9 4 1 1 2 7 8 3] [6 9 9 4 1 1 2 7 8 3]
[2 4 9 6 8 1 7 1 3] [9] [2 4 9 6 8 1 7 1 3] [9]
[4 1 1 3 2 6 7 8 9] [9] [4 1 1 3 2 6 7 8 9] [9]
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p>Afin de vérifier l'association correcte entre les images et les libellés, l'algorithme suivant affiche les libellés et les images correspondantes, tout en indiquant si chaque image sera utilisée pour l'entraînement du modèle ou pour les tests.</p> <p>Afin de vérifier l'association correcte entre les images et les libellés, l'algorithme suivant affiche les libellés et les images correspondantes, tout en indiquant si chaque image sera utilisée pour l'entraînement du modèle ou pour les tests.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
import matplotlib.pyplot as plt import matplotlib.pyplot as plt
def affichage(d_train, l_train, d_test, l_test): def affichage(d_train, l_train, d_test, l_test):
long, large = 5,2 long, large = 5,2
with open("data/cifar-10-batches-py/batches.meta", 'rb') as file: with open("data/cifar-10-batches-py/batches.meta", 'rb') as file:
batch_data = pickle.load(file, encoding='bytes') batch_data = pickle.load(file, encoding='bytes')
liste_names= np.array(batch_data[b'label_names']) liste_names= np.array(batch_data[b'label_names'])
fig, axes = plt.subplots(large, long, figsize=(12, 5)) fig, axes = plt.subplots(large, long, figsize=(12, 5))
fig.subplots_adjust(hspace=0.5) fig.subplots_adjust(hspace=0.5)
for i in range(len(l_train)): for i in range(len(l_train)):
im = np.array(np.reshape(d_train[i, 0:3072], (32, 32, 3), order='F'), dtype=np.int64) im = np.array(np.reshape(d_train[i, 0:3072], (32, 32, 3), order='F'), dtype=np.int64)
im = np.transpose(im, (1, 0, 2)) im = np.transpose(im, (1, 0, 2))
name=liste_names[l_train[i]] name=liste_names[l_train[i]]
axes[i // long, i % long].imshow(im) axes[i // long, i % long].imshow(im)
axes[i // long, i % long].set_title(f"Train : {name.decode('utf-8')}") axes[i // long, i % long].set_title(f"Train : {name.decode('utf-8')}")
axes[i // long, i % long].axis('off') axes[i // long, i % long].axis('off')
for i in range(len(l_test)): for i in range(len(l_test)):
im = np.array(np.reshape(d_test[i, 0:3072], (32, 32, 3), order='F'), dtype=np.int64) im = np.array(np.reshape(d_test[i, 0:3072], (32, 32, 3), order='F'), dtype=np.int64)
im = np.transpose(im, (1, 0, 2)) im = np.transpose(im, (1, 0, 2))
j = i + len(l_train) j = i + len(l_train)
name=liste_names[l_test[i]] name=liste_names[l_test[i]]
axes[j // long, j % long].imshow(im) axes[j // long, j % long].imshow(im)
axes[j // long, j % long].set_title(f"Test : {name.decode('utf-8')}") axes[j // long, j % long].set_title(f"Test : {name.decode('utf-8')}")
axes[j // long, j % long].axis('off') axes[j // long, j % long].axis('off')
plt.show() plt.show()
if __name__ == "__main__": if __name__ == "__main__":
d, l = read_cifar("data/cifar-10-batches-py") d, l = read_cifar("data/cifar-10-batches-py")
d_1, l_1, d_2, l_2 = split_dataset(d[:10,:], l[:10], 0.5) d_1, l_1, d_2, l_2 = split_dataset(d[:10,:], l[:10], 0.5)
affichage(d_1, l_1, d_2, l_2) affichage(d_1, l_1, d_2, l_2)
``` ```
%% Output %% Output
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<h2>Classification par les k Plus Proches Voisins</h2> <h2>Classification par les k Plus Proches Voisins</h2>
<p>Dans cette section, nous allons développer un algorithme de classification en utilisant la méthode des k plus proches voisins, choisis en fonction d'une distance euclidienne.</p> <p>Dans cette section, nous allons développer un algorithme de classification en utilisant la méthode des k plus proches voisins, choisis en fonction d'une distance euclidienne.</p>
<p>Pour ce faire, nous commençons par écrire la fonction de calcul de distance. Cette fonction prend en entrée les images d'entraînement et de test, et pour chaque image de test, elle calcule sa distance par rapport à chaque image d'entraînement. En plaçant les résultats dans une matrice, nous obtenons une image de test associée à chaque ligne et une image d'entraînement associée à chaque colonne.</p> <p>Pour ce faire, nous commençons par écrire la fonction de calcul de distance. Cette fonction prend en entrée les images d'entraînement et de test, et pour chaque image de test, elle calcule sa distance par rapport à chaque image d'entraînement. En plaçant les résultats dans une matrice, nous obtenons une image de test associée à chaque ligne et une image d'entraînement associée à chaque colonne.</p>
<p>Pour une base de données composée de N images d'entraînement et M images de test, la matrice de distances en sortie est la suivante :</p> <p>Pour une base de données composée de N images d'entraînement et M images de test, la matrice de distances en sortie est la suivante :</p>
<table> <table>
<thead> <thead>
<tr> <tr>
<th align="center"><b></b></th> <th align="center"><b></b></th>
<th align="center"><b>Image entrainement 1</b></th> <th align="center"><b>Image entrainement 1</b></th>
<th align="center"><b>...</b></th> <th align="center"><b>...</b></th>
<th align="center"><b>Image entrainement n</b></th> <th align="center"><b>Image entrainement n</b></th>
<th align="center"><b>...</b></th> <th align="center"><b>...</b></th>
<th align="center"><b>Image entrainement N</b></th> <th align="center"><b>Image entrainement N</b></th>
</tr> </tr>
</thead> </thead>
<tbody> <tbody>
<tr> <tr>
<th align="center"><b>Image test 1</b></th> <th align="center"><b>Image test 1</b></th>
<td align="center">dist(im_e1,im_t1)</td> <td align="center">dist(im_e1,im_t1)</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">dist(im_en,im_t1)</td> <td align="center">dist(im_en,im_t1)</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">dist(im_eN,im_t1)</td> <td align="center">dist(im_eN,im_t1)</td>
</tr> </tr>
<tr> <tr>
<th align="center"><b>...</b></th> <th align="center"><b>...</b></th>
<td align="center">...</td> <td align="center">...</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">...</td> <td align="center">...</td>
</tr> </tr>
<tr> <tr>
<th align="center"><b>Image test m</b></th> <th align="center"><b>Image test m</b></th>
<td align="center">dist(im_e1,im_tm)</td> <td align="center">dist(im_e1,im_tm)</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">dist(im_en,im_tm)</td> <td align="center">dist(im_en,im_tm)</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">dist(im_eN,im_tm)</td> <td align="center">dist(im_eN,im_tm)</td>
</tr> </tr>
<tr> <tr>
<th align="center"><b>...</b></th> <th align="center"><b>...</b></th>
<td align="center">...</td> <td align="center">...</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">...</td> <td align="center">...</td>
</tr> </tr>
<tr> <tr>
<th align="center"><b>Image test M</b></th> <th align="center"><b>Image test M</b></th>
<td align="center">dist(im_e1,im_tM)</td> <td align="center">dist(im_e1,im_tM)</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">dist(im_en,im_tM)</td> <td align="center">dist(im_en,im_tM)</td>
<td align="center">...</td> <td align="center">...</td>
<td align="center">dist(im_eN,im_tM)</td> <td align="center">dist(im_eN,im_tM)</td>
</tr> </tr>
</tbody> </tbody>
</table> </table>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def distance_matrix(data_train, data_test): def distance_matrix(data_train, data_test):
dist_mat=[] dist_mat=[]
for image_test in data_test: for image_test in data_test:
dist_mat.append([]) dist_mat.append([])
for image_train in data_train: for image_train in data_train:
dist_mat[-1].append(np.sum(np.square(image_train-image_test))) dist_mat[-1].append(np.sum(np.square(image_train-image_test)))
return(np.array(dist_mat)) return(np.array(dist_mat))
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p>Avec cette matrice de distances, nous allons rechercher pour chaque ligne (image de test) les k plus petites valeurs de distance et récupérer les libellés des images d'entraînement associés à ces valeurs. Enfin, nous comptons les libellés les plus fréquents dans cette liste pour associer un libellé à l'image de test.</p> <p>Avec cette matrice de distances, nous allons rechercher pour chaque ligne (image de test) les k plus petites valeurs de distance et récupérer les libellés des images d'entraînement associés à ces valeurs. Enfin, nous comptons les libellés les plus fréquents dans cette liste pour associer un libellé à l'image de test.</p>
<p>La fonction <code>knn_predict</code> prend donc en entrée la matrice de distances, la liste des libellés des images d'entraînement et le nombre k de plus proches voisins considéré, et renvoie en sortie le libellé associé.</p> <p>La fonction <code>knn_predict</code> prend donc en entrée la matrice de distances, la liste des libellés des images d'entraînement et le nombre k de plus proches voisins considéré, et renvoie en sortie le libellé associé.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def knn_predict(dist, labels_train, k): def knn_predict(dist, labels_train, k):
resultat=[] resultat=[]
for image_test in dist: for image_test in dist:
k_max = np.argpartition(image_test, k)[:k] k_max = np.argpartition(image_test, k)[:k]
val, count = np.unique(labels_train[k_max], return_counts=True) val, count = np.unique(labels_train[k_max], return_counts=True)
indexe = np.argmax(count) indexe = np.argmax(count)
resultat.append(val[indexe]) resultat.append(val[indexe])
return (resultat) return (resultat)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p>Une dernière fonction va appeler les deux dernières fonctions et comparer les résultats du modèle avec les vrais libellés des images de test. En sortie, nous obtiendrons le taux de réussite du modèle, c'est-à-dire le rapport entre le nombre de classes correctement attribuées et le nombre total de classes testées.</p> <p>Une dernière fonction va appeler les deux dernières fonctions et comparer les résultats du modèle avec les vrais libellés des images de test. En sortie, nous obtiendrons le taux de réussite du modèle, c'est-à-dire le rapport entre le nombre de classes correctement attribuées et le nombre total de classes testées.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def evaluate_knn(data_train, labels_train, data_test, labels_test, k): def evaluate_knn(data_train, labels_train, data_test, labels_test, k):
dist_matrice = distance_matrix(data_train, data_test) dist_matrice = distance_matrix(data_train, data_test)
res = knn_predict(dist_matrice, labels_train, k) res = knn_predict(dist_matrice, labels_train, k)
return(np.sum(labels_test == res) / len(labels_test)) return(np.sum(labels_test == res) / len(labels_test))
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p>Pour visualiser ce modèle, nous traçons les taux de réussite en fonction du nombre de k voisins choisis.</p> <p>Pour visualiser ce modèle, nous traçons les taux de réussite en fonction du nombre de k voisins choisis.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
if __name__ == "__main__": if __name__ == "__main__":
x = range(1, 20) x = range(1, 20)
d, l = read_cifar_batch("data/cifar-10-batches-py/data_batch_1") d, l = read_cifar_batch("data/cifar-10-batches-py/data_batch_1")
d_train, l_train, d_test, l_test = split_dataset(d, l, 0.9) d_train, l_train, d_test, l_test = split_dataset(d, l, 0.9)
dist_matrice = distance_matrix(d_train, d_test) dist_matrice = distance_matrix(d_train, d_test)
y = [] y = []
for knn in x: for knn in x:
stat = 0 stat = 0
res = knn_predict(dist_matrice, l_train, knn) res = knn_predict(dist_matrice, l_train, knn)
y.append(np.sum(l_test == res) / len(l_test)) y.append(np.sum(l_test == res) / len(l_test))
plt.plot(x, y, label='Précision') plt.plot(x, y, label='Précision')
plt.xlabel('nombre de plus proche voisins concidérés') plt.xlabel('nombre de plus proche voisins concidérés')
plt.ylabel('taux de bonne calification') plt.ylabel('taux de bonne calification')
plt.xticks(range(1, 20)) plt.xticks(range(1, 20))
plt.yticks(np.arange(0, 1.1, 0.1)) plt.yticks(np.arange(0, 1.1, 0.1))
plt.legend() plt.legend()
plt.show() plt.show()
``` ```
%% Output %% Output
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p>Pour évaluer l'efficacité de cette méthode, j'ai effectué 10 itérations, chaque fois sur un nouvel ensemble de test et d'entraînement. J'ai tracé les 10 courbes sur le même graphe, ce qui a donné le résultat ci-dessous.</p> <p>Pour évaluer l'efficacité de cette méthode, j'ai effectué 10 itérations, chaque fois sur un nouvel ensemble de test et d'entraînement. J'ai tracé les 10 courbes sur le même graphe, ce qui a donné le résultat ci-dessous.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
%%script false %%script false
if __name__ == "__main__": if __name__ == "__main__":
nbr_knn = 20 nbr_knn = 20
nbr_val = 10 nbr_val = 10
x = range(1, nbr_knn) x = range(1, nbr_knn)
d, l = read_cifar_batch("data/cifar-10-batches-py/data_batch_1") d, l = read_cifar_batch("data/cifar-10-batches-py/data_batch_1")
for essai in range(nbr_val): for essai in range(nbr_val):
d_train, l_train, d_test, l_test = split_dataset(d, l, 0.9) d_train, l_train, d_test, l_test = split_dataset(d, l, 0.9)
dist_matrice = distance_matrix(d_train, d_test) dist_matrice = distance_matrix(d_train, d_test)
y = [] y = []
for knn in x: for knn in x:
stat = 0 stat = 0
res = knn_predict(dist_matrice, l_train, knn) res = knn_predict(dist_matrice, l_train, knn)
y.append(np.sum(l_test == res) / len(l_test)) y.append(np.sum(l_test == res) / len(l_test))
plt.plot(x, y, label=f'Précision knn mesure {essai}') plt.plot(x, y, label=f'Précision knn mesure {essai}')
plt.xlabel('nombre de plus proche voisins concidérés') plt.xlabel('nombre de plus proche voisins concidérés')
plt.ylabel('taux de bonne calification') plt.ylabel('taux de bonne calification')
plt.xticks(range(1, nbr_knn)) plt.xticks(range(1, nbr_knn))
plt.yticks(np.arange(0, 1.1, 0.1)) plt.yticks(np.arange(0, 1.1, 0.1))
plt.legend() plt.legend()
plt.show() plt.show()
``` ```
%% Output %% Output
Couldn't find program: 'false' Couldn't find program: 'false'
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
from IPython.display import display, Image from IPython.display import display, Image
display(Image(filename="result/knn_1_20_valid_10test.png")) display(Image(filename="result/knn_1_20_valid_10test.png"))
``` ```
%% Output %% Output
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p><img alt="Image" title="icon" src="result/knn_1_20_valid_10test.png" /></p>
<p>On remarque une chute à k=2, cette chute est due à l'introduction d'un nouveau label parmi les choix possibles. L'algorithme développé ne traite pas la situation où dans ses k plus proches voisins, deux labels apparaissent le même nombre de fois, et il choisit naturellement le plus petit des deux.</p> <p>On remarque une chute à k=2, cette chute est due à l'introduction d'un nouveau label parmi les choix possibles. L'algorithme développé ne traite pas la situation où dans ses k plus proches voisins, deux labels apparaissent le même nombre de fois, et il choisit naturellement le plus petit des deux.</p>
<p>Pour réduire les erreurs lorsque deux labels apparaissent le même nombre de fois parmi les k plus proches voisins, l'algorithme ci-dessous choisira celui des deux dont la somme des distances est la plus petite.</p> <p>Pour réduire les erreurs lorsque deux labels apparaissent le même nombre de fois parmi les k plus proches voisins, l'algorithme ci-dessous choisira celui des deux dont la somme des distances est la plus petite.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
def knn_predict2(dist, labels_train, k): def knn_predict2(dist, labels_train, k):
resultat=[] resultat=[]
for im in dist: for im in dist:
dico={} dico={}
kmax=np.argpartition(im, k)[:k] kmax=np.argpartition(im, k)[:k]
for indexe in kmax: for indexe in kmax:
if labels_train[indexe] in dico: if labels_train[indexe] in dico:
dico[labels_train[indexe]][0]+=1 dico[labels_train[indexe]][0]+=1
dico[labels_train[indexe]][1]+=im[indexe] dico[labels_train[indexe]][1]+=im[indexe]
else: else:
dico[labels_train[indexe]]=[1,im[indexe]] dico[labels_train[indexe]]=[1,im[indexe]]
dico = sorted(dico.items(), key=lambda item: item[1][0], reverse=True) dico = sorted(dico.items(), key=lambda item: item[1][0], reverse=True)
max_value = dico[0][1][0] max_value = dico[0][1][0]
dico = [item for item in dico if item[1][0] == max_value] dico = [item for item in dico if item[1][0] == max_value]
if len(dico) > 1: if len(dico) > 1:
dico = sorted(dico, key=lambda item: item[1][1]) dico = sorted(dico, key=lambda item: item[1][1])
resultat.append(dico[0][0]) resultat.append(dico[0][0])
return(resultat) return(resultat)
``` ```
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
<p>Pour comparer les deux méthodes, j'ai tracé les résultats des deux méthodes sur le même graphique en utilisant les mêmes ensembles d'entraînement et de test.</p> <p>Pour comparer les deux méthodes, j'ai tracé les résultats des deux méthodes sur le même graphique en utilisant les mêmes ensembles d'entraînement et de test.</p>
%% Cell type:code id: tags: %% Cell type:code id: tags:
``` python ``` python
if __name__ == "__main__": if __name__ == "__main__":
nbr_knn = 20 nbr_knn = 20
x = range(1, nbr_knn) x = range(1, nbr_knn)
#d, l = read_cifar_batch("data/cifar-10-batches-py/data_batch_1") #d, l = read_cifar_batch("data/cifar-10-batches-py/data_batch_1")
#d_train, l_train, d_test, l_test = split_dataset(d, l, 0.9) #d_train, l_train, d_test, l_test = split_dataset(d, l, 0.9)
#dist_matrice = distance_matrix(d_train, d_test) #dist_matrice = distance_matrix(d_train, d_test)
y1 = [] y1 = []
y2 = [] y2 = []
for knn in x: for knn in x:
stat = 0 stat = 0
res = knn_predict(dist_matrice, l_train, knn) res = knn_predict(dist_matrice, l_train, knn)
res2 = knn_predict2(dist_matrice, l_train, knn) res2 = knn_predict2(dist_matrice, l_train, knn)
y1.append(np.sum(l_test == res) / len(l_test)) y1.append(np.sum(l_test == res) / len(l_test))
y2.append(np.sum(l_test == res2) / len(l_test)) y2.append(np.sum(l_test == res2) / len(l_test))
plt.plot(x, y1, label=f'Précision knn') plt.plot(x, y1, label=f'Précision knn')
plt.plot(x, y2, label='Précision knn2') plt.plot(x, y2, label='Précision knn2')
plt.xlabel('nombre de plus proche voisins concidérés') plt.xlabel('nombre de plus proche voisins concidérés')
plt.ylabel('taux de bonne calification') plt.ylabel('taux de bonne calification')
plt.xticks(range(1, nbr_knn)) plt.xticks(range(1, nbr_knn))
plt.yticks(np.arange(0, 1.1, 0.1)) plt.yticks(np.arange(0, 1.1, 0.1))
plt.legend() plt.legend()
plt.show() plt.show()
``` ```
%% Output %% Output
%% Cell type:markdown id: tags: %% Cell type:markdown id: tags:
On remarque que la nouvelle méthode améliore sensiblement la précédente et ne présente pas de chute à k=2. On remarque que la nouvelle méthode améliore sensiblement la précédente et ne présente pas de chute à k=2.
<h3>Résultat</h3> <h3>Résultat</h3>
<p>Finalement, on constate que la méthode des k plus proches voisins a une efficacité d'environ 30% sur la base de données CIFAR-10, quel que soit le nombre de plus proches voisins choisis. Cela représente une amélioration par rapport à un choix aléatoire qui aurait un taux d'environ 10% compte tenu des 10 classes, mais reste relativement faible. <p>Finalement, on constate que la méthode des k plus proches voisins a une efficacité d'environ 30% sur la base de données CIFAR-10, quel que soit le nombre de plus proches voisins choisis. Cela représente une amélioration par rapport à un choix aléatoire qui aurait un taux d'environ 10% compte tenu des 10 classes, mais reste relativement faible.
<h2>Réseaux de Neurones Artificiels</h2> <h2>Réseaux de Neurones Artificiels</h2>
<p> </p> <p> </p>
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment