Apprentissage avec Python et Scikit-Learn - K Nearest Neighbors (K-NN)

valeur de 0 à 255. Cette plage de valeurs représente le niveau de gris Grayscale. En d’autres terme,

chaque représentation d’une image est une matrice de dimension 8*8.Le jeu de données MNIST

présent par défaut dans la librairie Scikit Learn, comporte un sous-ensemble de la “vraie” base de

données MNIST. Le sous-ensemble comporte 1797 chiffres que nous diviserons par la suite en

deux sous ensembles : d’entrainement et de test.

Utilisation de K-NN sur MNIST

Dans cette section, nous allons charger le jeu de données ainsi que le classifieur K-NN de Scikit

Learn. Finalement on utilisera ce dernier pour effectuer une prédiction.

Chargement des bibliothèques :

Scikit-Learn vient avec un ensemble de jeux de données prêt à l’emploi pour des fins

d’expérimentations. Ces dataset sont regroupés dans le package sklearn.datasets.

On charge le package datasets pour retrouver le jeu de données MNIST. Par la suite, on charge la

librairie Pandas : un utilitaire facilitant la manipulation des données en format tabulaire.

from sklearn.datasets import *

import pandas as pd

%matplotlib inline

Chargement du jeu de données et une première vue sur ces dernières :

digit = load_digits()

dig = pd.DataFrame(digit['data'][0:1700])

dig.head()

La fonction load_digits charge le jeu de données MNIST. Par la suite, on crée un DataFrame de la

librairie Pandas qu’on nomme “dig” alimenté par le jeu de données qu’on vient de charger.

Finalement, on utilise l’instruction dig.head() pour afficher les cinq premières lignes de notre

DataFrame (histoire de voir ce qu’on manipule comme données ).

2

Note : On remarque que notre DataFrame contient 64 colonnes (de 0 à 63). Ce qui représente

l’ensemble des valeurs de la matrice de taille 8*8 encodant un chiffre du jeu MNIST sous sa forme

image.

Vérification de jeu de données :

digit.keys()

Dans notre cas, nous sommes intéressés par les colonnes : data et target. La variable “data” est la

représentation en GrayScale d’un chiffre, et le target, représente son étiquette.

Fonction d’affichage :

Comme on l’a déjà mentionné, le jeu de données MNIST représente des images de chiffres

manuscrits. On peut s’amuser avec la librairie matplotlib pour créer une fonction de visualisation

d’une image.

import matplotlib.pyplot as plt

def displayImage(i):

plt.imshow(digit['images'][i], cmap='Greys_r')

plt.show()

Note : Cette fonction est tout à fait optionnelle et nous pouvons s’en passer. Je l’ai intégré dans

l’article juste pour des fins pédagogiques.

Affichage des données

En guise d’exemple, visualisant le premier chiffre de notre jeu de données MNIST. Il s’agit d’un

zéro. Pour se faire, on utilise la fonction displayImage qu’on vient de déclarer un peu plus haut :

#Affichage du premier élément du jeu de données

displayImage(0)

3

Découpage du jeu de données

Lors de l’entrainement d’un algorithme de Machine Learning, la bonne pratique veut qu’on

découpe notre jeu de données en jeu d’entrainement (Training Set) et jeu de test (Testing Set).

Ainsi, nous pourrons tester les performances du modèle obtenu suite à l’entrainement de

l’algorithme. Le test de performance se fait sur le testing Set qu’il n’a pas encore “vu”.

Pour notre cas, on divisera notre jeu de données comme suit :

 75% de Training Set

 25% de Testing Set

Pour y parvenir, on utilise la fonction train_test_split ().

from sklearn.model_selection import train_test_split

train_x = digit.data # les input variables

train_y = digit.target # les étiquettes (output variable)

#découpage du jeu de données

x_train,x_test,y_train,y_test=train_test_split(train_x,train_y,test_size=0.25)

Application de l’algorithme K-Nearst Neighbors

Tous les ingrédients sont là. Il nous reste plus qu’à entraîner un K-NN. Pour ce faire, la

librairie Sickit Learn propose la classe KNeighborsClassifier qui implémente un algorithme K-

NN.

Pour notre exemple, on va définir un classifieur à 7 voisins. Ainsi on obtient un 7-NN (car K = 7).

from sklearn.neighbors import KNeighborsClassifier

KNN = KNeighborsClassifier(7)

KNN.fit(x_train, y_train)

La fonction fit permet d’entraîner K-NN, le premier argument étant les input features qui

correspond à l’encodage des chiffres en format matriciel. Le deuxième arguement indique pour

chaque observation son étiquette (s’il s’agit du chiffre 5 ou 8 etc..).

voisins, il faut le confronter à un jeu de

Pour mesurer la performance de notre classifieur à

données qu’il n’a pas encore “vu”. C’est pour cela qu’on utilise les 25% des observations du jeu

MNIST qu’on a gardé lors du découpage de ce dataset.

print(KNN.score(x_test,y_test))

Le score obtenu sur l’exactitude des prédictions sur le testing set est 0.986666 soit environ 98%

de précision.

4

Prédictions et résultats

En prenant au hasard une observation du jeu de données MNIST. On regarde sa représentation

graphique pour mettre en évidence la valeur du chiffre concerné.

import numpy as np

test = np.array(digit['data'][1726])

test1 = test.reshape(1,-1)

displayImage(1726)

Ça a l’air d’un chiffre 3 !

Regardant maintenant ce que prédira notre classifieur 7-NN pour cette même observation.

KNN.predict(test1)

Ce qui nous renvoie :

Et voilà ! c’est bien un 3.

Travail demandé :

1. Essayer un nombre de voisins différents pour K-NN pour obtenir différents classifieurs.

2. Comparer leurs performances par rapport à 7-NN.

5