Université Mohammed V -

ENSAM- RABAT

Deep Learning MNIST dataset

Génie biomédical

Réalisé par : Encadré par :

AMANY Othman Pr.EL HACHEM ELYOUSSFI

EL ATTAOUI Fatima Zahra
ERRAFAQ Nadir

Année Universitaire : 2021/2022

 Table des matières
I. Introduction : ................................................................................................................................... 1
II. Objectif : .......................................................................................................................................... 1
III. Les Bibliothèques du travail : ...................................................................................................... 1
IV. Simulation du programme : ......................................................................................................... 2
1. Prétraitement de la base des images : .......................................................................................... 2
2. Configuration du modèle de prédiction : ..................................................................................... 4
3. Evaluation du modèle puis prédiction sur de nouvelles données : .............................................. 5
4. Prédiction sur de nouvelles données : ......................................................................................... 6
V. Conclusion :..................................................................................................................................... 7

Table des figures :

Figure 1: Processus.................................................................................................................................. 1
Figure 2:Importation des bibliothèques ................................................................................................... 2
Figure 3: chargement de data et mise à echelle ....................................................................................... 3
Figure 4: modification dimension d'image .............................................................................................. 3
Figure 5:encodage chaud et résultat ....................................................................................................... 3
Figure 6:boucle pour afficher 4 images aléatoires ................................................................................. 3
Figure 7:Visualisation .............................................................................................................................. 4
Figure 8:description du model ................................................................................................................ 5
Figure 9:l’architecture en code du CNN .................................................................................................. 5
Figure 10:Paramètre d’entrainement ..................................................................................................... 5
Figure 11:Evaluation du model ............................................................................................................... 6
Figure 12: visualisation de l'évaluation ................................................................................................... 6
Figure 13: liste des labels détectés lors de la prédiction des images de test ......................................... 6
Figure 15 :le résultat avec x_test[9] ....................................................................................................... 7
Figure 14:le résultat avec y_pred[9] ....................................................................................................... 7
I. Introduction :
L'exemple le plus élémentaire de Deep Learning en intelligence artificielle est l'identification
de chiffres manuscrits.Il s'agit d'un problème de classification multi-catégorie dans lequel
l'objectif est de reconnaître/prédire le bon chiffre manuscrit, c'est-à-dire les chiffres de 0 à 9.

II. Objectif :
Ce TP est consacré à la reconnaissance des chiffres manuscrite de 0 à 9, soit dix catégories de
prédiction. C’est un problème de classification multi-classes (> 2).On souhaite avoir un modèle
qui prendra en entrée une image représentant un chiffre manuscrite et nous fournira en sortie le
chiffre présenté par cette image, on peut schématiser le processus comme suit :

Figure 1: Processus

III. Les Bibliothèques du travail :

Nous allons essentiellement utiliser la notion d’environnement virtuel, pour ce TP.
Un environnement virtuel est un espace de développement isolé, il a ses propres bibliothèques
et son propre interpréteur python. C’est-à-dire vous pouvez créer un environnement virtuel et
installer votre version de python souhaitée, et seulement les bibliothèques que vous aurez
besoin y compris :
 Keras : c’est une bibliothèque dédiée au Deep Learning, elle utilise tensorflow comme
API pour manipuler les tenseurs à grande échelle.
 Tensorflow : c’est une bibliothèque performante de bas niveau, elle utilise keras pour
 construire des modèles en Deep Learning.
 Matplotlib : utilisée pour lire des images, les affichées, tracer des courbes...etc
 Numpy : utilisée pour manipuler les tableaux ‘arrays’ de grande dimension.
 Pillow : utilisée pour traitement des images, lire, convertir en niveau de gris …etc
 Scikit-learn : une bibliothèque dédiée au Machine Learning, elle comporte des classes
utiles à la phase de prétraitement des données.

1
  Python : c’est le langage utilisé dans ce TP. C’est un langage de Scripting
interprétable.

 La gestion de cet environnement virtuel peut se faire à l’aide de « Google colab »

IV. Simulation du programme :

1. Prétraitement de la base des images :
 Importation des bibliothèques :

Figure 2:Importation des bibliothèques

 Prétraitement :

Nous utilisons la base de données MNIST qui comporte les descriptions de chiffres manuscrits
en format 28 × 28, soit 784 pixels, et les étiquettes associées. La base contient en tout 60 000
exemples, c’est-à-dire 6000 exemples de chaque chiffre. Nous chargeons d’abord la base, puis
nous examinons l’un des exemples qu’elle contient.
La base de données téléchargée est divisée sur 2 ensembles de donnée « sets » :
o Train (d’entrainement) : Va servir à l’entrainement de notre modèle.
o Test (de test) : Va constituer un témoigne avec lequel on évalue notre modèle.
Afin de manipuler les images téléchargées, nous devons mettre à l’échelle toutes ces images en
divisant par le niveau maximal de pixel au niveau de gris « 255 ».
On change la représentation de ces images au format Array de numpy, puis on chan ge la
dimension des images pour ajouter un axe supplémentaire. (Keras ne supporte qu’une entrée
avec 4 dimensions)
Pour y faire ces étapes sont suivis :
1. On définit une variable avec le nombre total de classe 10 (des chiffres de 0 à 9).
2. On définit une deuxième variable des images d’entrée.
3. On télécharge la base de donnée depuis les datasets prédifinies de keras
datasets.mnist.load_data() et on la répartie de façon à ce que les deux tuples (x_train, y_train)
et (x_test, y_test) aient respectivement des images d’entrainement et leurs étiquettes « labels »
et les images de test de l’algorithmes et leurs étiquettes.
4. Une mise à l’échelle des images d’entrainement et des images de test tout en changeant leurs
types avec la méthode de numpy astype() tout en modifiant la dimension de nos images pour
qu’elles puissent être accepter par keras .

2
 Figure 3: chargement de data et mise à echelle

Figure 4: modification dimension d'image

5. Encodage à chaud (one hot encoding), c’est une étape importante puisque la plupart des
algorithmes en Deep Learning voire même de Machine Learning n’acceptent que des étiquettes
(labels) en représentation vectorielle afin de faciliter la prédiction et le traitement des données.
Cette représentation consiste à mettre 1 l’état actif et les autres 0.
Pour ce faire, nous allons utilisé la méthode to_categorical de la classe utils de keras, ou bien nous
pouvons même écrire notre propre fonction qui fera cet encodage one-hot-encoding

Figure 5:encodage chaud et résultat

6. Visualiser les images d’entrée après avoir fait du prétraitement :

 Pour y faire on a utilisé la classe pyplot de la bibliothèque matplotlib, et on a codé une

simple boucle qui va itérer sur 4 images aléatoires de la base d’entrainement, et qui
affiche le label correspondant juste en-dessus de l’image.

Figure 6:boucle pour afficher 4 images aléatoires

3
 Figure 7:Visualisation

2. Configuration du modèle de prédiction :

Les étapes sont les suivantes :
Le modèle construit est un réseau neuronal convolutif, et se compose de 4 couches (layers) :

1. Une Couche d’entrée qui prend en dimension les images de taille 28x28x1, il est
indispensable pour keras d’avoir 3 dimensions. (Ligne x Colonne x Channel), dans ce cas
channel = 1 puisqu’on travaille sur des images de niveau de gris 2D.

2. Une Couche de convolution avec 32 filtres (kernel) avec 3x3 de taille et une fonction
d’activation nommée ReLu.
3. Une Couche de MaxPooling avec taille 2x2

4. Une Couche Flatten qui change le dimensionnement des tenseurs en vecteur à une seule
dimension pour faciliter la distribution finale des catégories.

5. Une couche Dropout de 50% qui permet de désactiver 50% de nœuds pour ne pas tomber sur
le sur-apprentissage. Cette couche peut être éliminée en premier coup et puis rajoutée pour
pallier au problème d’overfitting.
6. Une couche finale FC (Fully Connected) nommée dans Keras par Dense. Elle est utilisée
pour délivrer la sortie finale de notre modèle, en utilisant la fonction d’activation Softmax, la
sortie de cette couche aurait dix probabilités pour chaque catégorie. La catégorie qui présente
une probabilité maximale est bien le résultat de prédiction.

4
 Figure 9:l’architecture en code du CNN Figure 8:description du model

Voici une description/résumé de notre modèle obtenue en exécutant : model.summary()

- Model : cette première colonne présente les couches du modèle.
- Output Shape : cette colonne définit la dimension de sortie de chaque couche.
- Param : cette colonne présente le nombre de paramètre à entrainer.
Après avoir créé votre modèle, maintenant vient l’étape de compilation du modèle. Cette étape
sert à présenter certain paramètres nécessaire à l’entrainement du modèle tels que :
 Batch size : c’est la taille du lot des images entraînées à chaque itération dans la phase
d’apprentissage.
 Epochs : correspond à un cycle complet d’itération sur toute la base d’entrainement.
 Loss : c’est la fonction utilisé pour présenter la perte du modèle, là puisqu’il s’agit d’un
problème de classification multi-catégorie on a utilisé categorical_crossentropy.
 Optimizer : on définit une méthode d’optimisation du modèle.
 Metrics : on définit la méthode d’évaluation du modèle, dans ce cas l’accuracy a été
choisie.

Figure 10:Paramètre d’entrainement

3. Evaluation du modèle puis prédiction sur de nouvelles données :

Cette étape consiste à évaluer la précision de notre modèle à détecter la base de test, bien
sûr et évidemment qu’il ne faut pas entrainer avec cette base sinon les résultats seront biaisés,
et le modèle ne va pas généraliser sur des données non observées.

5
 Figure 11:Evaluation du model

Noter qu’on a toujours ce dilemme loss/accuracy, on a intérêt à ce que les pertes du modèle
soient minimes et son accuracy soit maximale. Là on arrive à détecter 99% des chiffres avec un
taux d’erreur de 2.56% donc presque la totalité des images ont été reconnaît, ceci est un bon
indice pour notre modèle. Pour observer l’état du modèle dans chacune de ses 15 étapes
d’entrainement (epochs), on se sert de la variable history pour tracer les différents attributs
associés :
- loss, accuracy : correspond aux données d’entrainement.
- val_accuracy, et val_loss : correspond aux données de validation (les 10%).

Figure 12: visualisation de l'évaluation

Le tracé de ces courbes pourrait vous donner une idée sur la performance de votre modèle,
et d’observer si il y a un overfitting (sur-apprentissage) ou underfitting (sous-apprentissage).
4. Prédiction sur de nouvelles données :
Pour cette étape, on utilise les images de test x_test:

Figure 13: liste des labels détectés lors de la prédiction des images de test

Prenant par exemple l’image d’indice 9 de la base de test : x_test[9] on dessine celle-ci pour
vérifier que le modèle à bien prédit qu’il s’agit du chiffre 9, on compare le résultat avec
y_pred[9]

6
 Figure 14 :le résultat avec x_test[9]
Figure 15:le résultat avec y_pred[9]

 l’image dessiné présente le même chiffre détecté en y_pred[9], donc le modèle a bien
détecté le chiffre.

V. Conclusion :
Dans ce Tp nous avons essayé de rapprocher les étapes de traitement et de
développement de modèles du Deep Learning. Nous avons utilisé 60 000 photos
d'entraînement divisées en 10 catégories (chiffres de 0 à 9) pour évaluer notre modèle, et nous
avons utilisé 10 000 images de test pour évaluer notre modèle. Nous avons mis en œuvre un
modèle de reconnaissance de chiffres manuscrits, nous avons obtenue un taux de précision de
99,11 % .