Défi : Construction d'un CNN

Les réseaux de neurones convolutifs (CNN) sont largement utilisés pour la classification d’images en raison de leur capacité à extraire des caractéristiques hiérarchiques. Dans cette tâche, implémentation et entraînement d’un CNN de type VGG à l’aide de TensorFlow et Keras sur le jeu de données CIFAR-10. Ce jeu de données comprend 60 000 images (32×32×3) appartenant à 10 classes différentes, telles que avions, voitures, oiseaux, chats, et d’autres.

Ce projet guide à travers le chargement du jeu de données, la prétraitement des images, la définition du modèle CNN, son entraînement et l’évaluation de ses performances.

1. Prétraitement des données pour les CNN

Avant d’entraîner un CNN, le prétraitement des données est une étape essentielle pour garantir de meilleures performances et une convergence plus rapide. Les méthodes de prétraitement courantes incluent :

• Normalisation : cette méthode consiste à ramener les valeurs de pixels des images d’une plage comprise entre 0 et 255 à une plage comprise entre 0 et 1. Elle est souvent réalisée via x_train / 255.0, x_test / 255.0 ;

• Encodage one-hot : les étiquettes sont souvent converties en vecteurs one-hot encodés pour les tâches de classification. Cela se fait généralement avec la fonction keras.utils.to_categorical, qui transforme les étiquettes entières (par exemple, 0, 1, 2, etc.) en un vecteur one-hot encodé, tel que [1, 0, 0, 0] pour un problème de classification à 4 classes.

2. Construction de l'architecture CNN

Une architecture CNN est composée de plusieurs couches qui effectuent différentes tâches pour extraire des caractéristiques et réaliser des prédictions. Possibilité d’implémenter les principales couches CNN en utilisant :

Couche de convolution (Conv2D)

keras.layers.Conv2D(filters, kernel_size, activation='relu', padding='same', input_shape=(height, width, channels))

Couche de pooling (MaxPooling2D)

keras.layers.MaxPooling2D(pool_size=(2, 2))

Couche Flatten

keras.layers.Flatten()

Couche Dense

layers.Dense(units=512, activation='relu')
layers.Dense(10, activation='softmax')

3. Compilation du modèle

Après avoir défini l'architecture, le modèle doit être compilé. Cette étape consiste à spécifier la fonction de perte, l'optimiseur et les métriques qui guideront le modèle pendant l'entraînement. Les méthodes suivantes sont couramment utilisées dans les CNN :

Optimiseur (Adam)

L'optimiseur ajuste les poids du modèle afin de minimiser la fonction de perte. L'optimiseur Adam est populaire en raison de son efficacité et de sa capacité à adapter le taux d'apprentissage pendant l'entraînement.

keras.optimizers.Adam()

Fonction de perte (Categorical Crossentropy)

Pour la classification multi-classes, la fonction de perte généralement utilisée est la categorical crossentropy. Elle peut être implémentée ainsi :

keras.losses.CategoricalCrossentropy()

Métriques

La performance du modèle est suivie à l'aide de métriques pour les tâches de classification, telles que l'exactitude, la précision, le rappel, etc. Elles peuvent être définies comme suit :

metrics = [
    keras.metrics.Accuracy(), 
    keras.metrics.Precision(), 
    keras.metrics.Recall()
]

Compiler

model.compile(optimizer='adam', 
              loss='categorical_crossentropy', # Or keras.losses.CategoricalCrossentropy()
              metrics=metrics)

4. Entraînement du modèle

L'entraînement d'un CNN consiste à fournir les données d'entrée au réseau, à calculer la perte et à mettre à jour les poids à l'aide de la rétropropagation. Le processus d'entraînement est contrôlé par les méthodes clés suivantes :

• Ajustement du modèle : la méthode fit() est utilisée pour entraîner le modèle. Cette méthode prend en entrée les données d'entraînement, le nombre d'époques et la taille du lot. Elle inclut également une option de validation pour évaluer les performances du modèle sur des données non vues pendant l'entraînement :

history = model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)

• Taille du lot et époques : la taille du lot détermine le nombre d'échantillons traités avant la mise à jour des poids du modèle, et le nombre d'époques correspond à combien de fois l'ensemble du jeu de données est parcouru par le modèle.

5. Évaluation

Rapport de classification

sklearn.metrics.classification_report() compare les valeurs réelles et prédites issues du jeu de test. Il inclut la précision, le rappel et le score F1 pour chaque classe. Cependant, les méthodes nécessitent uniquement les étiquettes de classe, donc n'oubliez pas de les reconvertir à partir des vecteurs ([0,0,1,0] -> 2) :

y_pred = model.predict(x_test)
y_pred_classes = np.argmax(y_pred,axis = 1)
y_test_classes = np.argmax(y_test, axis = 1)

report = classification_report(y_test_classes, y_pred_classes, target_names=class_names)
print(report)

Évaluer

Une fois le modèle entraîné, il est évalué sur le jeu de test afin d'estimer sa capacité de généralisation. L'évaluation fournit des métriques, mentionnées dans la méthode .compile(). L'évaluation s'effectue à l'aide de .evaluate() :

results = model.evaluate(x_test, y_test, verbose=2, return_dict=True)

Matrice de confusion

Pour obtenir plus d'informations sur les performances du modèle, il est possible de visualiser la matrice de confusion, qui affiche les vrais positifs, faux positifs, vrais négatifs et faux négatifs pour chaque classe. La matrice de confusion peut être calculée avec TensorFlow :

confusion_mtx = tf.math.confusion_matrix(y_test_classes, y_pred_classes)

Cette matrice peut ensuite être visualisée à l'aide de cartes thermiques pour observer les performances du modèle sur chaque classe :

plt.figure(figsize=(12, 9))
c = sns.heatmap(confusion_mtx, annot=True, fmt='g')
c.set(xticklabels=class_names, yticklabels=class_names)

plt.show()

Tâche

1. Charger et prétraiter le jeu de données

• Importer le jeu de données CIFAR-10 depuis Keras ;
• Normaliser les valeurs des pixels dans l'intervalle [0,1] pour une meilleure convergence ;
• Convertir les étiquettes de classe au format one-hot encoded pour la classification catégorielle.

2. Définir le modèle CNN

Implémentation d'une architecture CNN de type VGG avec les couches principales suivantes :

Couches convolutionnelles :

• Taille du noyau : 3×3 ;
• Fonction d'activation : ReLU ;
• Remplissage : 'same'.

Couches de pooling :

• Type de pooling : max pooling ;
• Taille du pooling : 2×2.

Couches de dropout (Prévention du surapprentissage par désactivation aléatoire de neurones)** :**

• Taux de dropout : 25%.

Couche Flatten – conversion des cartes de caractéristiques 2D en un vecteur 1D pour la classification.

Couches entièrement connectées – couches denses pour la classification finale, avec une couche de sortie relu ou softmax.

Compilation du modèle avec :

• Adam optimizer (pour un apprentissage efficace) ;
• Fonction de perte Categorical cross-entropy (pour la classification multi-classes) ;
• Métrique Accuracy metric pour mesurer la performance (les classes sont équilibrées, d'autres métriques peuvent être ajoutées selon vos besoins).

3. Entraîner le modèle

• Spécifier les paramètres epochs et batch_size pour l'entraînement (par exemple epochs=20, batch_size=64) ;
• Spécifier le paramètre validation_split pour définir le pourcentage de données d'entraînement utilisé pour la validation afin de suivre la performance du modèle sur des images non vues ;
• Sauvegarder l'historique d'entraînement pour visualiser l'évolution de la précision et de la perte.

4. Évaluer et visualiser les résultats

• Tester le modèle sur les données de test CIFAR-10 et afficher la précision ;
• Tracer la perte d'entraînement vs la perte de validation pour vérifier le surapprentissage ;
• Tracer la précision d'entraînement vs la précision de validation pour assurer la progression de l'apprentissage.

PROJET CNN COLAB