Projet de classification d’images

Dans ce projet, nous allons créer un CNN simple pour classer des images par catégories. La classification d’images consiste à prédire la catégorie ou l’étiquette d’une image d’entrée.

Jeu de données pour la classification

Nous utiliserons le jeu de données CIFAR-10, qui contient 60 000 images réparties en 10 catégories telles que les avions, les voitures, les oiseaux et les chats. Chaque image mesure 32×32 pixels et possède 3 canaux de couleur (RGB).

Chargement du jeu de données

Nous chargerons le jeu de données CIFAR-10 à l’aide de TensorFlow :

import tensorflow as tf
from tensorflow.keras.datasets import cifar10

# Load dataset
(x_train, y_train), (x_test, y_test) = cifar10.load_data()

# Normalize the pixel values to [0, 1]
x_train = x_train / 255.0
x_test = x_test / 255.0

print("Training data shape:", x_train.shape)

Création du modèle CNN

Nous définirons une architecture CNN composée de couches convolutives, de mise en commun et entièrement connectées :

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# Define the CNN model
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

Compilation du modèle

Nous utilisons la méthode compile pour le modèle :

• Fonction de perte : Entropie croisée catégorielle pour la classification multi-classes.
• Optimiseur : Optimiseur Adam pour un apprentissage efficace.
• Métriques : Exactitude pour évaluer les performances.

# Compile the model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

Entraîner le modèle

Nous entraînons le modèle avec les données d’entraînement pendant 10 époques. Au cours de l’entraînement, le modèle apprend à classer les images par catégories.

# Train the model
model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

Évaluer le modèle

Après l'entraînement, nous évaluons le modèle sur les données d'évaluation afin de vérifier son exactitude :

# Evaluate the model
loss, accuracy = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {accuracy * 100:.2f}%")

Effectuer des prédictions

Nous pouvons utiliser le modèle entraîné pour effectuer des prédictions sur de nouvelles images :

# Predict the category of a test image
import numpy as np

sample_image = x_test[0]
sample_label = y_test[0]

prediction = np.argmax(model.predict(sample_image[np.newaxis, ...]))
print(f"Predicted Label: {prediction}, Actual Label: {sample_label[0]}")

Difficultés de la classification d'images

Les difficultés courantes comprennent :

• Surapprentissage : Le modèle fonctionne bien sur les données d'entraînement, mais mal sur de nouvelles données.
• Déséquilibre des classes : Représentation inégale des catégories dans le jeu de données.
• Coût de calcul : L'entraînement de réseaux profonds nécessite des ressources importantes.

Résumé et prochaines étapes

Dans ce projet, nous avons :

• Créé et entraîné un CNN pour la classification d'images à l'aide du jeu de données CIFAR-10.
• Appris à charger, prétraiter et evaluate le jeu de données.
• Examiné les difficultés liées aux tâches de classification d'images.

Nous allons maintenant explorer des techniques d'augmentation des données afin d'améliorer les performances du modèle en générant des variations des images d'entraînement.