Les réseaux de neurones convolutifs (CNN) sont largement utilisés dans la classification d’images en raison de leur capacité à extraire des caractéristiques hiérarchiques. Dans cette tâche, vous allez implémenter et entraîner 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 plus encore.

Ce projet vous guidera à 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 cruciale pour garantir de meilleures performances et une convergence plus rapide. Les méthodes de prétraitement courantes incluent :

• Normalisation : cette méthode consiste à mettre à l’échelle les valeurs de pixels des images d’une plage comprise entre 0 et 255 à une plage comprise entre 0 et 1. Elle est souvent implémentée comme 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 à l’aide de 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. Vous pouvez implémenter les principales couches CNN en utilisant :

Couche convolutionnelle (Conv2D)

Remarque

Le paramètre input_shape doit être spécifié uniquement dans la couche d'entrée.

Couche de Pooling (MaxPooling2D)

Couche de Flatten

Couche Dense

Remarque

La couche dense finale comporte généralement un nombre d’unités égal au nombre de classes et utilise une fonction d’activation softmax pour produire une distribution de probabilité sur les classes.

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.

Fonction de perte (Entropie croisée catégorielle)

Pour la classification multi-classes, l'entropie croisée catégorielle est généralement utilisée comme fonction de perte. Cela peut être implémenté ainsi :

Métriques

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

Compilation

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 :

• 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 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, il ne faut donc pas oublier de les reconvertir à partir des vecteurs ([0,0,1,0] -> 2) :

Évaluation

Une fois le modèle entraîné, il est évalué sur le jeu de données 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 la méthode .evaluate() :

Matrice de confusion

Pour obtenir une meilleure compréhension des performances du modèle, il est possible de visualiser la matrice de confusion, qui affiche les prédictions vrais positifs, faux positifs, vrais négatifs et faux négatifs pour chaque classe. La matrice de confusion peut être calculée avec TensorFlow :

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

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 clés 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.

Compiler le 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).

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 les tendances de l’exactitude 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 l’exactitude ;

• Tracer la perte d’entraînement vs la perte de validation pour vérifier le surapprentissage ;

• Tracer l’exactitude d’entraînement vs l’exactitude de validation pour assurer la progression de l’apprentissage.

PROJET CNN COLAB