Reconnaître les chiffres manuscrits du dataset MNIST avec les CNN

Le dataset MNIST de reconnaissance de chiffres manuscrits

Le dataset MNIST (Modified National Institute of Standards and Technology) est l’un des ensembles de données les plus célèbres en apprentissage automatique. Il contient 70 000 images de chiffres manuscrits (60 000 pour l’entraînement et 10 000 pour le test), chacune étant une image en niveaux de gris de 28×28 pixels représentant un chiffre entre 0 et 9.

Le dataset MNIST a été popularisé par Yann LeCun, pionnier du deep learning et titulaire du prix Turing 2018 (souvent considéré comme le "prix Nobel de l’informatique"), en reconnaissance de ses travaux fondateurs sur les réseaux de neurones convolutionnels (CNN).

MNIST est devenu un standard pédagogique car il est simple, rapide à manipuler et permet d’obtenir des performances très élevées avec des architectures relativement modestes.

On peut trouver le dataset MNIST :

• Sur le site officiel de Yann LeCun (l’un des créateurs du dataset): http://yann.lecun.com.
• Directement intégré dans TensorFlow/Keras via tf.keras.datasets.mnist, ce qui permet de le charger en une seule ligne de code.
  

Mise en place d'une architecture CNN pour la reconnaissance des chiffres manuscrits

Note objectif consiste à construire un réseau de neurones convolutionnel capable d’extraire automatiquement les caractéristiques visuelles des images du dataset MNIST. Chaque image (28×28 pixels en niveaux de gris) est d’abord normalisée puis transmise à des couches de convolution qui détectent des motifs simples (traits, courbes), suivies de couches de pooling qui réduisent la dimension tout en conservant l’essentiel de l’information. Ces représentations hiérarchiques sont ensuite aplaties et envoyées vers des couches entièrement connectées qui réalisent la classification finale en attribuant une probabilité à chacun des dix chiffres (0–9).

On commence par l'importation des modules nécessaires:
Ensuite, on charge le dataset MNIST:
La fonction load_data() renvoie deux ensembles distincts sous forme de tuples: le premier contient les données et les labels d’entraînement (60 000 exemples), et le second contient les données et les labels de test (10 000 exemples).

La prochaine opération consiste au reshape et à la normalisation des images:

• Reshape: les images, initialement stockées sous forme de matrices 2D (28×28), sont transformées en tenseurs 4D de la forme (nombre_d’images, hauteur, largeur, canaux). Ici, -1 laisse Python calculer automatiquement le nombre d’images et 1 indique qu’il s’agit d’images en niveaux de gris (un seul canal).
• Normalisation: la conversion en float32 puis la division par 255.0 ramènent les valeurs des pixels (initialement entre 0 et 255) dans l’intervalle [0,1]. Cela facilite l’apprentissage du réseau en évitant des valeurs trop grandes et en accélérant la convergence.

Ensuite, on réalise l’encodage one-hot des labels.
Dans MNIST, les labels sont des entiers allant de 0 à 9 (par exemple, 3 pour le chiffre "3"). Or, un réseau de neurones fonctionne mieux lorsque les classes sont représentées sous forme de vecteurs binaires où chaque position correspond à une classe possible. Par exemple: le chiffre 3 devient le vecteur [0, 0, 0, 1, 0, 0, 0, 0, 0, 0].

Donc, la méthode to_categorical transforme automatiquement les labels en vecteurs de taille 10, ce qui permet au modèle CNN de produire une sortie sous forme de probabilités pour chacune des 10 classes puis de choisir la plus élevée comme prédiction finale.

On affiche 5 images du dataset MNIST au début de l’exécution afin de donner un aperçu concret des données manipulées:
L'instruction plt.subplot(1, 5, i+1) indique à Matplotlib de créer une figure composée de 1 ligne et 5 colonnes de sous‑graphiques, puis de placer l’image courante dans la position i+1 (de la première à la cinquième case).

Quant à l'instruction plt.imshow(X_train[i].reshape(28,28), cmap="gray"), elle affiche l’image correspondante du dataset MNIST en la remodelant au format 28×28 pixels et en la représentant en niveaux de gris pour une meilleure lisibilité.

Le bloc de code précédent produit ce résultat:


Il est temps de construire notre architecture de CNN:

La premire couche Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)) applique 32 filtres (ou kernels) de taille 3x3 sur l’image d’entrée de dimension 28x28x1. Chaque filtre glisse sur l’image (convolution) et extrait des motifs locaux comme des bords ou des textures. Le résultat est un ensemble de cartes de caractéristiques (feature maps) qui traduisent la présence de ces motifs dans différentes zones de l’image. L’activation ReLU est ensuite appliquée pour introduire de la non-linéarité et éviter que le modèle ne se limite à des combinaisons linéaires des pixels.
La deuxième couche MaxPooling2D((2,2)) réalise une opération de pooling qui consiste à réduire la taille des cartes de caractéristiques produites par les filtres de convolution. Concrètement, elle parcourt l’image avec une fenêtre de 2x2 et conserve uniquement la valeur maximale de chaque bloc, ce qui permet de diminuer la dimension spatiale (par exemple de 28x28 à 14x14) tout en gardant les informations les plus représentatives. Cette étape rend le modèle plus efficace en réduisant le nombre de paramètres et en limitant le risque de surapprentissage tout en mettant en avant les motifs les plus saillants détectés par les kernels.
La couche Flatten() sert à transformer les cartes de caractéristiques multidimensionnelles issues des convolutions et du pooling en un vecteur unidimensionnel afin de les rendre compatibles avec les couches entièrement connectées (Dense) qui attendent des entrées sous forme de vecteurs.

La couche Dense(64, activation='relu') est une couche entièrement connectée qui prend le vecteur aplati en entrée et applique 64 neurones pour combiner les caractéristiques extraites, tandis que la couche Dense(10, activation='softmax') constitue la sortie du réseau avec 10 neurones correspondant aux classes possibles et utilise la fonction softmax pour transformer les scores en probabilités de classification.

L'étape suivante consiste à compiler notre modèle:
Ensuite on lance son entrainement:
Puis, on l'évalue:
La méthode model.evaluate() retourne la valeur de la fonction de perte calculée sur le jeu de données fourni, ainsi que toutes les métriques définies lors de la compilation du modèle.

On obtient ce résultat:
Le résultat indique que le modèle a évalué 313 lots (batches) du jeu de test en 3 secondes environ, avec un temps moyen de 10 ms par lot. Les résultats montrent une exéctitude (accuracy) de 98,99 % et une perte (loss) de 0,0289, ce qui signifie que le modèle classe correctement presque toutes les images du jeu de test.

Pour finir, on procède à quelques prédictions:
Ce code affiche 5 images du jeu de test et le modèle prédit la classe pour chacune d'entre elles. L’image est représentée en niveaux de gris, puis la prédiction est obtenue en prenant l’indice du score maximal avec np.argmax (comme on l'a vu dans la leçon consacrée à la classification multiclasses).

L'exécution du code précédent produit ce résultat: