Entraîner un modèle CNN sur MNIST dans Google Colab.
Ce cours vous guide étape par étape pour entraîner un modèle CNN sur MNIST dans
Google Colab. Nous allons d'abord créer un dossier, ajouter les fichiers compressés, les
décompresser, puis exécuter un script Python pour entraîner un modèle de classification
des chiffres manuscrits. À la fin, nous allons afficher l'évolution de l'accuracy et de la loss,
puis imprimer les performances finales du modèle.
Étape 1 : Préparer l’environnement dans Google Colab
1️. Créer un dossier pour stocker les fichiers
Dans Colab, exécutez cette commande pour créer un dossier :
!mkdir -p /content/dataset
2️. Téléverser les fichiers compressés
Allez dans l’onglet Fichiers 📂 (à gauche dans Colab).
Faites un glisser-déposer des 4 fichiers .gz dans /content/dataset.
3️. Vérifier la présence des fichiers
Tapez cette commande pour voir si les fichiers sont bien là :
!ls -lh /content/dataset/
Si tout est bon, vous verrez vos fichiers affichés avec leur taille.
Étape 2 : Décompresser les fichiers
Dans Colab, exécutez cette commande :
!gunzip -f /content/dataset/*.gz
Puis, vérifiez que les fichiers sont bien extraits en relançant :
!ls -lh /content/dataset/
Les fichiers devraient maintenant être sans l’extension .gz.
Étape 3 : Charger les données en Python
Nous allons maintenant lire les fichiers en binaire et charger les images et labels :
import numpy as np
import struct
dataset_path = "/content/dataset/"
def load_mnist_images(filename):
with open(filename, 'rb') as f:
_, num, rows, cols = struct.unpack(">IIII", f.read(16))
images = np.frombuffer(f.read(),
dtype=np.uint8).reshape(num, rows, cols, 1)
return images / 255.0 # Normalisation entre 0 et 1
def load_mnist_labels(filename):
with open(filename, 'rb') as f:
_, num = struct.unpack(">II", f.read(8))
labels = np.frombuffer(f.read(), dtype=np.uint8)
return labels
X_train = load_mnist_images(dataset_path + "train-images-idx3-
ubyte")
y_train = load_mnist_labels(dataset_path + "train-labels-idx1-
ubyte")
X_test = load_mnist_images(dataset_path + "t10k-images-idx3-
ubyte")
y_test = load_mnist_labels(dataset_path + "t10k-labels-idx1-
ubyte")
print(f" Données chargées : {X_train.shape[0]} images
d'entraînement, {X_test.shape[0]} images de test")
Images chargées en tableaux NumPy, normalisées en valeurs entre 0 et 1.
Labels chargés et stockés en tableau.
Étape 4 : Construire le modèle CNN
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
model = keras.Sequential([
layers.Conv2D(32, (3,3), activation='relu',
input_shape=(28, 28, 1)),
layers.MaxPooling2D(2,2),
layers.Conv2D(64, (3,3), activation='relu'),
layers.MaxPooling2D(2,2),
layers.Flatten(),
layers.Dense(128, activation='relu'),
layers.Dense(10, activation='softmax') # 10 classes (0-9)
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy', metrics=['accuracy'])
print(" Modèle créé et compilé avec succès !")
2 couches de convolution (Conv2D) détectent les motifs.
2 couches de max-pooling (MaxPooling2D) réduisent la taille des images.
Flatten transforme en vecteur, suivi de Dense(128) + Dense(10 softmax) pour
classifier.
Étape 5 : Entraîner le modèle
epochs = 10
history = model.fit(X_train, y_train, validation_data=(X_test,
y_test), epochs=epochs)
Entraînement sur 10 époques.
Utilisation d’Adam comme optimiseur.
Affichage de la précision (accuracy) et de la perte (loss).
Étape 6 : Afficher les performances
import matplotlib.pyplot as plt
plt.figure(figsize=(12, 5))
# Accuracy
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Test
Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.title("Évolution de l'Accuracy")
# Loss
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Test Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title("Évolution de la Loss")
plt.show()
# Affichage des scores finaux
final_acc = history.history['val_accuracy'][-1] * 100
final_loss = history.history['val_loss'][-1]
print(f"Accuracy finale : {final_acc:.2f}%")
print(f"Loss finale : {final_loss:.4f}")
On trace l’évolution de l’accuracy et de la loss.
On affiche la précision et la perte finales sur les données de test.
Résultat final attendu :
Accuracy finale : ~98.00%
Loss finale : ~0.05
Code complet :
import numpy as np
import struct
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow import keras
from tensorflow.keras import layers
# Chemin vers les fichiers
dataset_path = "/content/dataset/"
# Fonction pour charger les images et labels
def load_mnist_images(filename):
with open(filename, 'rb') as f:
_, num, rows, cols = struct.unpack(">IIII", f.read(16))
images = np.frombuffer(f.read(),
dtype=np.uint8).reshape(num, rows, cols, 1)
return images / 255.0 # Normalisation [0,1]
def load_mnist_labels(filename):
with open(filename, 'rb') as f:
_, num = struct.unpack(">II", f.read(8))
labels = np.frombuffer(f.read(), dtype=np.uint8)
return labels
# Chargement des données
X_train = load_mnist_images(dataset_path + "train-images-idx3-
ubyte")
y_train = load_mnist_labels(dataset_path + "train-labels-idx1-
ubyte")
X_test = load_mnist_images(dataset_path + "t10k-images-idx3-
ubyte")
y_test = load_mnist_labels(dataset_path + "t10k-labels-idx1-
ubyte")
# Création du modèle CNN
model = keras.Sequential([
layers.Conv2D(32, (3,3), activation='relu',
input_shape=(28, 28, 1)),
layers.MaxPooling2D(2,2),
layers.Conv2D(64, (3,3), activation='relu'),
layers.MaxPooling2D(2,2),
layers.Flatten(),
layers.Dense(128, activation='relu'),
layers.Dense(10, activation='softmax') # 10 classes (0-9)
])
# Compilation du modèle
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy', metrics=['accuracy'])
# Entraînement du modèle
epochs = 10
history = model.fit(X_train, y_train, validation_data=(X_test,
y_test), epochs=epochs)
# Affichage de l'évolution de l'accuracy et de la loss
plt.figure(figsize=(12, 5))
# Accuracy
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Train Accuracy')
plt.plot(history.history['val_accuracy'], label='Test
Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.title("Évolution de l'Accuracy")
# Loss
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Train Loss')
plt.plot(history.history['val_loss'], label='Test Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.title("Évolution de la Loss")
plt.show()
# Affichage des performances finales
final_acc = history.history['val_accuracy'][-1] * 100
final_loss = history.history['val_loss'][-1]
print(f"Accuracy finale : {final_acc:.2f}%")
print(f"Loss finale : {final_loss:.4f}")
Résultats :
Exercices
Exercice 1 : Classification des chiffres manuscrits avec prétraitement avancé
Objectif : L’objectif de cet exercice est de développer un modèle de classification d’images
utilisant un réseau de neurones convolutifs (CNN) tout en appliquant des techniques de
prétraitement avancées sur les images du dataset MNIST. Le modèle devra être entraîné à
reconnaître des chiffres manuscrits de 0 à 9 à partir d’images de 28x28 pixels. Avant
d’entraîner le modèle, vous devrez appliquer plusieurs étapes de prétraitement pour améliorer
les performances du modèle. Le prétraitement inclut la redéfinition des images, la
normalisation des pixels, et l'augmentation des données pour aider le modèle à mieux
généraliser.
1. Chargement des données : Téléchargez les fichiers MNIST depuis le répertoire de
données, puis chargez les images et labels de l'ensemble d'entraînement et de test.
Utilisez la méthode de chargement appropriée pour extraire les données en matrices de
numpy.
2. Redimensionnement des images : Redimensionnez les images à une taille uniforme
(par exemple, 32x32 pixels) pour que le modèle puisse mieux les traiter, en s’assurant
que toutes les images ont la même forme.
3. Normalisation des pixels : Les valeurs des pixels doivent être normalisées dans la
plage [0, 1] en divisant chaque pixel par 255. Cela permettra au modèle d'apprendre
plus efficacement.
4. Augmentation des données : Appliquez des transformations telles que la rotation, le
retournement horizontal, et la translation d'images. Cela augmente la variété des
données et permet au modèle de mieux se généraliser en évitant le surapprentissage.
5. Construction du modèle CNN : Développez un modèle CNN avec plusieurs couches
convolutionnelles suivies de couches de pooling. Utilisez une couche dense finale
avec activation softmax pour la classification en 10 classes.
6. Entraînement du modèle : Entraînez le modèle sur les données prétraitées en
utilisant la fonction de perte adéquate et optimisez les hyperparamètres pour améliorer
les résultats.
7. Évaluation du modèle : Une fois l’entraînement terminé, évaluez le modèle sur
l'ensemble de test et analysez les résultats. Affichez l’évolution de la précision et de la
perte au cours de l’entraînement pour vérifier l'efficacité du prétraitement.
Résultats attendus : Le modèle final doit être capable de prédire les
chiffres manuscrits avec une précision significativement améliorée grâce
aux étapes de prétraitement. Vous devez observer un meilleur taux de
précision et de généralisation par rapport à un modèle de base sans
prétraitement.
Exercice 2 : Reconnaissance des chiffres manuscrits avec un réseau neuronal
dense (MLP)
Objectif : L’objectif de cet exercice est de développer un modèle de classification d'images à
l’aide d’un réseau neuronal entièrement connecté (MLP) sur les données du dataset MNIST.
Le modèle sera basé sur une architecture dense et nécessitera un prétraitement minutieux des
images avant d'être adapté à la structure du réseau de neurones. Ce projet vise à tester les
effets du prétraitement, y compris la normalisation et la conversion en tenseurs, sur la
performance du modèle.
1. Chargement des données : Comme pour le premier exercice, commencez par charger
les images et les labels des fichiers MNIST. Utilisez des bibliothèques comme numpy
et struct pour extraire les données de manière appropriée.
2. Redimensionnement des images : Bien que les images du dataset MNIST soient déjà
de taille 28x28, il est conseillé de redimensionner toutes les images en une taille
uniforme (par exemple, 32x32 pixels) pour préparer les données à être traitées par le
modèle MLP.
3. Normalisation des pixels : Appliquez une normalisation sur les images pour que les
valeurs des pixels soient dans la plage [0,1]. Cette étape améliore la stabilité du
processus d'entraînement en réduisant l’échelle des données.
4. Conversion en tenseurs : Convertissez les images normalisées en tenseurs, qui sont
des structures de données utilisées dans TensorFlow pour faciliter les calculs
matriciels. Chaque image sera transformée en un vecteur plat de taille 1024 (32x32
pixels).
5. Construction du modèle MLP : Créez un modèle de réseau de neurones dense. Ce
modèle devrait comporter une ou plusieurs couches entièrement connectées (Dense)
avec une activation ReLU et une couche de sortie avec activation softmax pour
effectuer la classification des 10 chiffres.
6. Entraînement du modèle : Entraînez le modèle avec l'ensemble d'entraînement et
validez-le avec l'ensemble de test. Utilisez une fonction de perte appropriée pour la
classification multi-classe (comme sparse_categorical_crossentropy) et un
optimiseur tel que Adam.
7. Évaluation du modèle : Après l’entraînement, évaluez la performance du modèle en
termes de précision et de perte. Affichez l'évolution de la précision et de la perte
pendant l'entraînement pour observer l'impact du prétraitement sur les performances.
Résultats attendus : À la fin de cet exercice, vous devriez obtenir
un modèle MLP capable de classer les chiffres manuscrits du
dataset MNIST avec une bonne précision, tout en ayant observé
les effets du prétraitement sur la performance du modèle. Le
modèle final doit afficher un taux de précision satisfaisant sur
l’ensemble de test.
