Compte-rendu TP Machine Learning :

Classification des chiffres MNIST

Hnainia Mohamed Amine GEA 3 B
28 Novembre 2025

1 Introduction
Ce TP présente la mise en œuvre d’un réseau de neurones convolutif pour
la classification des chiffres manuscrits du dataset MNIST. Le travail est divisé
en plusieurs étapes progressives.

2 Exploration des données

2.1 Code correspondant
1 import tensorflow as tf
2 import matplotlib . pyplot as plt
3
4 ( X_train , y_train ) , ( X_test , y_test ) = tf . keras . datasets . mnist .
load_data ()
5
6 plt . figure ( figsize =(10 , 5) )
7 for i in range (10) :
8 plt . subplot (2 , 5 , i +1)
9 plt . imshow ( X_train [ i ] , cmap = ’ gray ’)
10 plt . title ( f " Label : { y_train [ i ]} " )
11 plt . axis ( ’ off ’)
12 plt . show ()
13 print ( " Dimensions de X_train : " , X_train . shape )
14 print ( " Dimensions de y_train : " , y_train . shape )
15 print ( " Dimensions de X_test : " , X_test . shape )
16 print ( " Dimensions de y_test : " , y_test . shape )

Listing 1 – Chargement et visualisation des données

2.2 Discussion
Cette première étape permet de charger le dataset MNIST et de visualiser
les 10 premières images d’entraı̂nement avec leurs labels correspondants.

1
 3 Normalisation et redimensionnement
3.1 Code correspondant
1 X_train = X_train / 255.0
2 X_test = X_test / 255.0
3 X_train = X_train . reshape ( X_train . shape [0] , 28 , 28 , 1)
4 X_test = X_test . reshape ( X_test . shape [0] , 28 , 28 , 1)
5 print ( " Dimensions de X_train a p r s r e d i m e n s i o n n e m e n t : " , X_train .
shape )
6 print ( " Dimensions de X_test a p r s r e d i m e n s i o n n e m e n t : " , X_test .
shape )

Listing 2 – Prétraitement des données

3.2 Discussion
La normalisation des valeurs de pixels dans l’intervalle [0,1] améliore la
convergence de l’algorithme. Le redimensionnement ajoute une dimension de
canal pour les images en niveaux de gris.

4 Définition du modèle
4.1 Code correspondant
1 from tensorflow . keras import layers , models
2 model = models . Sequential ([
3 layers . Conv2D (32 , kernel_size =(3 , 3) , activation = ’ relu ’ ,
input_shape =(28 , 28 , 1) ) ,
4 layers . MaxPooling2D ( pool_size =(2 , 2) ) ,
5 layers . Conv2D (64 , kernel_size =(3 , 3) , activation = ’ relu ’) ,
6 layers . MaxPooling2D ( pool_size =(2 , 2) ) ,
7 layers . Flatten () ,
8 layers . Dense (128 , activation = ’ relu ’) ,
9 layers . Dense (10 , activation = ’ softmax ’)
10 ])
11
12 model . summary ()

Listing 3 – Architecture du modèle CNN

4.2 Discussion
Architecture CNN classique avec deux couches convolutionnelles suivies de
pooling, une couche d’aplatissement et deux couches denses. La fonction d’ac-
tivation softmax en sortie permet la classification multi-classes.

2
 5 Compilation et entraı̂nement du modèle
5.1 Code correspondant
1 model . compile ( optimizer = ’ adam ’ ,
2 loss = ’ s p a r s e _ c a t e g o r i c a l _ c r o s s e n t r o p y ’ ,
3 metrics =[ ’ accuracy ’ ])
4
5 history = model . fit ( X_train , y_train , epochs =5 , v a li da ti o n_ da ta =(
X_test , y_test ) )

Listing 4 – Compilation et entraı̂nement

5.2 Discussion
Utilisation de l’optimiseur Adam et de la loss sparse categorical crossentropy,
appropriée pour les labels entiers. L’entraı̂nement se fait sur 5 époques avec
validation sur les données de test.

6 Évaluation du modèle
6.1 Code correspondant
1 test_loss , test_acc = model . evaluate ( X_test , y_test , verbose =2)
2 print ( f " P r c i s i o n sur l ’ ensemble de test : { test_acc * 100:.2 f }% " )
3 import matplotlib . pyplot as plt
4
5 plt . plot ( history . history [ ’ accuracy ’] , label = ’ P r c i s i o n sur l \ ’
ensemble d \ ’ e n t r a n e m e n t ’)
6 plt . plot ( history . history [ ’ val_accuracy ’] , label = ’ P r c i s i o n sur l \ ’
ensemble de validation ’)
7 plt . xlabel ( ’ poques ’)
8 plt . ylabel ( ’ P r c i s i o n ’)
9 plt . legend ( loc = ’ lower right ’)
10 plt . title ( ’ P r c i s i o n d \ ’ e n t r a n e m e n t et de validation ’)
11 plt . show ()

Listing 5 – Évaluation et visualisation

6.2 Discussion
Évaluation de la performance du modèle sur l’ensemble de test et visua-
lisation des courbes d’apprentissage pour analyser la convergence et détecter
d’éventuels surapprentissages.

7 Prédiction et Visualisation
7.1 Code correspondant

3
1 import numpy as np
2 predictions = model . predict ( X_train )
3 plt . figure ( figsize =(10 , 5) )
4 for i in range (10) :
5 plt . subplot (2 , 5 , i +1)
6 plt . imshow ( X_test [ i ]. reshape (28 , 28) , cmap = ’ gray ’)
7 plt . title ( f " P r d i t : { np . argmax ( predictions [ i ]) } | Vrai : {
y_test [ i ]} " )
8 plt . axis ( ’ off ’)
9 plt . show ()

Listing 6 – Prédictions sur de nouvelles images

7.2 Discussion
Visualisation des prédictions du modèle sur 10 images de test, permettant
de vérifier qualitativement les performances.

8 Améliorations avancées
8.1 Augmentation des données
1 datagen = I m a g e D a t a G e n e r a t o r (
2 rot ation_r ange =10 , # Rotation jusqu ’ 10 d e g r s
3 zoom_range =0.1 , # Zoom jusqu ’ 10%
4 w i d t h _ s h i f t _ r a n g e =0.1 , # D p l a c e m e n t horizontal jusqu ’ 10%
5 h e i g h t _ s h i f t _ r a n g e =0.1 , # D p l a c e m e n t vertical jusqu ’ 10%
6 shear_range =0.1 # Cisaillement jusqu ’ 10%
7 )
8 tr ai n_ g en er at o r = datagen . flow ( X_train , y_train , batch_size =32)

Listing 7 – Data Augmentation

8.2 Modèle amélioré

1 def c r e a t e _ i m p r o v e d _ m o d e l () :
2 model = models . Sequential ([
3 layers . Conv2D (32 , (3 , 3) , activation = ’ relu ’ , input_shape
=(28 , 28 , 1) ) ,
4 layers . B a t c h N o r m a l i z a t i o n () ,
5 layers . Conv2D (32 , (3 , 3) , activation = ’ relu ’) ,
6 layers . MaxPooling2D ((2 , 2) ) ,
7 layers . Dropout (0.25) ,
8
9 layers . Conv2D (64 , (3 , 3) , activation = ’ relu ’) ,
10 layers . B a t c h N o r m a l i z a t i o n () ,
11 layers . Conv2D (64 , (3 , 3) , activation = ’ relu ’) ,
12 layers . MaxPooling2D ((2 , 2) ) ,
13 layers . Dropout (0.25) ,
14

4
15 layers . Conv2D (128 , (3 , 3) , activation = ’ relu ’) ,
16 layers . B a t c h N o r m a l i z a t i o n () ,
17 layers . Dropout (0.25) ,
18
19 layers . Flatten () ,
20 layers . Dense (256 , activation = ’ relu ’) ,
21 layers . B a t c h N o r m a l i z a t i o n () ,
22 layers . Dropout (0.5) ,
23 layers . Dense (128 , activation = ’ relu ’) ,
24 layers . Dropout (0.5) ,
25 layers . Dense (10 , activation = ’ softmax ’)
26 ])
27 return model

Listing 8 – Architecture avancée

8.3 Optimisation et callbacks

1 c u s t o m _ o p t i m i ze r = Adam ( learning_rate =0.001)
2
3 reduce_lr = R e d u c e L R O n P l a t e a u (
4 monitor = ’ val_loss ’ ,
5 factor =0.2 ,
6 patience =2 ,
7 min_lr =0.0001 ,
8 verbose =1
9 )
10
11 earl y_stopp ing = EarlyStopping (
12 monitor = ’ val_loss ’ ,
13 patience =5 ,
14 r e s t o r e _ b e s t _ w e i g h t s = True ,
15 verbose =1
16 )
17
18 impr oved_mo del . compile (
19 optimizer = custom_optimizer ,
20 loss = ’ s p a r s e _ c a t e g o r i c a l _ c r o s s e n t r o p y ’ ,
21 metrics =[ ’ accuracy ’]
22 )

Listing 9 – Techniques d’optimisation

8.4 Entraı̂nement amélioré

1 h i s t o r y _ i m p r o ve d = improv ed_mode l . fit (
2 datagen . flow ( X_train , y_train , batch_size =32) ,
3 epochs =10 ,
4 va li d at io n_ d at a =( X_test , y_test ) ,
5 callbacks =[ reduce_lr , ear ly_stop ping ] ,
6 verbose =1
7 )

Listing 10 – Entraı̂nement avec techniques avancées

5
 8.5 Analyse des résultats
1 test_loss_improved , t e s t _ a c c _ i m p r o v e d = improve d_model . evaluate (
X_test , y_test , verbose =2)
2 print ( f " P r c i s i o n du m o d l e a m l i o r sur l ’ ensemble de test : {
t e s t _ a c c _ i m p r o v e d * 100:.2 f }% " )
3
4 final_epoch = len ( h i s t o ry _ i m p r o v e d . history [ ’ accuracy ’ ])
5 print ( f " A r r t de l ’ e n t r a n e m e n t a p r s { final_epoch } poques " )
6 print ( f " P r c i s i o n finale - E n t r a n e m e n t : { h i s t o r y _ i mp r o v e d .
history [ ’ accuracy ’][ -1]:.4 f } " )
7 print ( f " P r c i s i o n finale - Validation : { h i st o r y _ i m p r o v e d . history [ ’
val_accuracy ’][ -1]:.4 f } " )

Listing 11 – Évaluation détaillée

9 Conclusion
Ce TP a permis de mettre en œuvre un pipeline complet de classification
d’images, depuis l’exploration des données jusqu’à l’optimisation avancée d’un
modèle CNN. Les techniques d’amélioration ont montré leur efficacité pour aug-
menter les performances et la robustesse du modèle.