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

Update Rapport.ipynb

parent af153037
No related branches found
No related tags found
No related merge requests found
%% Cell type:markdown id: tags:
<h1>Classification d'Images</h1>
<p><a href="https://gitlab.ec-lyon.fr/edelland/mod_4_6-td1">Énoncé du TD</a>.</p>
<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>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>
<p>Nous importons les bibliothèques nécessaires pour charger et traiter les fichiers.</p>
%% Cell type:code id: tags:
``` python
import numpy as np
import pickle
import os
```
%% 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>
%% Cell type:code id: tags:
``` python
def read_cifar_batch(batch_path):
with open(batch_path, 'rb') as file:
batch_data = pickle.load(file, encoding='bytes')
data = np.array(batch_data[b'data'], dtype=np.float32)
labels = np.array(batch_data[b'labels'], dtype=np.int64)
return data, labels
```
%% Cell type:code id: tags:
``` python
def read_cifar(path_folder):
data = np.empty((0, 3072), dtype=np.float32)
labels = np.empty((0), dtype=np.int64)
for filename in os.listdir(path_folder):
if filename.startswith("data_batch") or filename == "test_batch":
batch_path = os.path.join(path_folder, filename)
d, l = read_cifar_batch(batch_path)
data = np.concatenate((data, d), axis=0)
labels = np.concatenate((labels, l), axis=None)
return(data,labels)
```
%% Cell type:code id: tags:
``` python
def split_dataset(data, labels, split_factor):
num_samples = len(data)
shuffled_indices = np.random.permutation(num_samples)
split_index = int(num_samples * split_factor)
data_train = data[shuffled_indices[:split_index],:]
labels_train = labels[shuffled_indices[:split_index]]
data_test = data[shuffled_indices[split_index:],:]
labels_test = labels[shuffled_indices[split_index:]]
return data_train, labels_train, data_test, labels_test
```
%% 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>
%% Cell type:code id: tags:
``` python
if __name__ == "__main__":
#read_cifar_batch("data/cifar-10-batches-py/data_batch_1")
d, l = read_cifar("data/cifar-10-batches-py")
print(l[0:10])
d_1, l_1, d_2, l_2 = split_dataset(d[:10,:], l[:10], 0.9)
print(l_1,l_2)
d_1, l_1, d_2, l_2 = split_dataset(d[:10,:], l[:10], 0.9)
print(l_1,l_2)
```
%% Output
[6 9 9 4 1 1 2 7 8 3]
[2 4 9 6 8 1 7 1 3] [9]
[4 1 1 3 2 6 7 8 9] [9]
%% 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>
%% Cell type:code id: tags:
``` python
import matplotlib.pyplot as plt
def affichage(d_train, l_train, d_test, l_test):
long, large = 5,2
with open("data/cifar-10-batches-py/batches.meta", 'rb') as file:
batch_data = pickle.load(file, encoding='bytes')
liste_names= np.array(batch_data[b'label_names'])
fig, axes = plt.subplots(large, long, figsize=(12, 5))
fig.subplots_adjust(hspace=0.5)
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.transpose(im, (1, 0, 2))
name=liste_names[l_train[i]]
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].axis('off')
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.transpose(im, (1, 0, 2))
j = i + len(l_train)
name=liste_names[l_test[i]]
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].axis('off')
plt.show()
if __name__ == "__main__":
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)
affichage(d_1, l_1, d_2, l_2)
```
%% Output
%% Cell type:markdown id: tags:
<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>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>
<table>
<thead>
<tr>
<th align="center"><b></b></th>
<th align="center"><b>Image entrainement 1</b></th>
<th align="center"><b>...</b></th>
<th align="center"><b>Image entrainement n</b></th>
<th align="center"><b>...</b></th>
<th align="center"><b>Image entrainement N</b></th>
</tr>
</thead>
<tbody>
<tr>
<th align="center"><b>Image test 1</b></th>
<td align="center">dist(im_e1,im_t1)</td>
<td align="center">...</td>
<td align="center">dist(im_en,im_t1)</td>
<td align="center">...</td>
<td align="center">dist(im_eN,im_t1)</td>
</tr>
<tr>
<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>
</tr>
<tr>
<th align="center"><b>Image test m</b></th>
<td align="center">dist(im_e1,im_tm)</td>
<td align="center">...</td>
<td align="center">dist(im_en,im_tm)</td>
<td align="center">...</td>
<td align="center">dist(im_eN,im_tm)</td>
</tr>
<tr>
<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>
</tr>
<tr>
<th align="center"><b>Image test M</b></th>
<td align="center">dist(im_e1,im_tM)</td>
<td align="center">...</td>
<td align="center">dist(im_en,im_tM)</td>
<td align="center">...</td>
<td align="center">dist(im_eN,im_tM)</td>
</tr>
</tbody>
</table>
%% Cell type:code id: tags:
``` python
def distance_matrix(data_train, data_test):
dist_mat=[]
for image_test in data_test:
dist_mat.append([])
for image_train in data_train:
dist_mat[-1].append(np.sum(np.square(image_train-image_test)))
return(np.array(dist_mat))
```
%% 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>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:
``` python
def knn_predict(dist, labels_train, k):
resultat=[]
for image_test in dist:
k_max = np.argpartition(image_test, k)[:k]
val, count = np.unique(labels_train[k_max], return_counts=True)
indexe = np.argmax(count)
resultat.append(val[indexe])
return (resultat)
```
%% 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>
%% Cell type:code id: tags:
``` python
def evaluate_knn(data_train, labels_train, data_test, labels_test, k):
dist_matrice = distance_matrix(data_train, data_test)
res = knn_predict(dist_matrice, labels_train, k)
return(np.sum(labels_test == res) / len(labels_test))
```
%% 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>
%% Cell type:code id: tags:
``` python
if __name__ == "__main__":
x = range(1, 20)
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)
dist_matrice = distance_matrix(d_train, d_test)
y = []
for knn in x:
stat = 0
res = knn_predict(dist_matrice, l_train, knn)
y.append(np.sum(l_test == res) / len(l_test))
plt.plot(x, y, label='Précision')
plt.xlabel('nombre de plus proche voisins concidérés')
plt.ylabel('taux de bonne calification')
plt.xticks(range(1, 20))
plt.yticks(np.arange(0, 1.1, 0.1))
plt.legend()
plt.show()
```
%% Output
%% 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>
%% Cell type:code id: tags:
``` python
%%script false
if __name__ == "__main__":
nbr_knn = 20
nbr_val = 10
x = range(1, nbr_knn)
d, l = read_cifar_batch("data/cifar-10-batches-py/data_batch_1")
for essai in range(nbr_val):
d_train, l_train, d_test, l_test = split_dataset(d, l, 0.9)
dist_matrice = distance_matrix(d_train, d_test)
y = []
for knn in x:
stat = 0
res = knn_predict(dist_matrice, l_train, knn)
y.append(np.sum(l_test == res) / len(l_test))
plt.plot(x, y, label=f'Précision knn mesure {essai}')
plt.xlabel('nombre de plus proche voisins concidérés')
plt.ylabel('taux de bonne calification')
plt.xticks(range(1, nbr_knn))
plt.yticks(np.arange(0, 1.1, 0.1))
plt.legend()
plt.show()
```
%% Output
Couldn't find program: 'false'
%% Cell type:code id: tags:
``` python
from IPython.display import display, Image
display(Image(filename="result/knn_1_20_valid_10test.png"))
```
%% Output
%% 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>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:
``` python
def knn_predict2(dist, labels_train, k):
resultat=[]
for im in dist:
dico={}
kmax=np.argpartition(im, k)[:k]
for indexe in kmax:
if labels_train[indexe] in dico:
dico[labels_train[indexe]][0]+=1
dico[labels_train[indexe]][1]+=im[indexe]
else:
dico[labels_train[indexe]]=[1,im[indexe]]
dico = sorted(dico.items(), key=lambda item: item[1][0], reverse=True)
max_value = dico[0][1][0]
dico = [item for item in dico if item[1][0] == max_value]
if len(dico) > 1:
dico = sorted(dico, key=lambda item: item[1][1])
resultat.append(dico[0][0])
return(resultat)
```
%% 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>
%% Cell type:code id: tags:
``` python
if __name__ == "__main__":
nbr_knn = 20
x = range(1, nbr_knn)
#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)
#dist_matrice = distance_matrix(d_train, d_test)
y1 = []
y2 = []
for knn in x:
stat = 0
res = knn_predict(dist_matrice, l_train, knn)
res2 = knn_predict2(dist_matrice, l_train, knn)
y1.append(np.sum(l_test == res) / 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, y2, label='Précision knn2')
plt.xlabel('nombre de plus proche voisins concidérés')
plt.ylabel('taux de bonne calification')
plt.xticks(range(1, nbr_knn))
plt.yticks(np.arange(0, 1.1, 0.1))
plt.legend()
plt.show()
```
%% Output
%% 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.
<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.
<h2>Réseaux de Neurones Artificiels</h2>
<p> </p>
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment