Classification d’Images

La classification d’images constitue l’un des champs d’application les plus emblématiques des réseaux de neurones convolutifs (Convolutional Neural Networks, CNN). Cette tâche consiste à attribuer à chaque image une catégorie prédéfinie en s’appuyant sur l’extraction automatique de caractéristiques visuelles pertinentes. Les CNN se distinguent des approches traditionnelles par leur capacité à hiérarchiser les représentations visuelles : des motifs simples tels que les bords ou les textures dans les premières couches, jusqu’à des structures complexes comme des objets ou des formes spécifiques dans les couches profondes. Dans cette section, nous proposons une mise en pratique de la classification d’images à travers l’entraînement d’un modèle CNN, en mettant en évidence les étapes clés du processus — préparation des données, conception de l’architecture, optimisation et évaluation — afin d’illustrer concrètement l’efficacité de cette approche dans un cas d’utilisation réel.

Fonctions :

Classification d’Images (exemple)

La classification d’images est une tâche d’apprentissage supervisé où l’objectif est d’assigner une étiquette à une image parmi plusieurs classes. Elle repose généralement sur des réseaux de neurones convolutifs (CNN) qui extraient automatiquement les caractéristiques visuelles.

Importation :

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
from tensorflow.keras.preprocessing.image import ImageDataGenerator

Attributs :

Paramètre	Type	Description	Valeur par défaut
`batch_size`	int	Nombre d’images utilisées pour chaque mise à jour du modèle.	`32`
`epochs`	int	Nombre de fois que le modèle parcourt l’ensemble des données d’entraînement.	`10`
`steps_per_epoch`	int	Nombre d’étapes (lots d’images) par époque.	`nb_samples // batch_size`
`validation_split`	float	Fraction des données utilisée pour la validation.	`0.2`

Exemple de code :

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

# 1. Charger le dataset Fashion MNIST
(X_train, y_train), (X_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()

# 2. Normalisation et reshaping
X_train = X_train / 255.0
X_test = X_test / 255.0
X_train = X_train[..., np.newaxis]  # (batch, 28, 28, 1)
X_test = X_test[..., np.newaxis]

# 3. Liste des classes
class_names = ["T-shirt", "Pantalon", "Pull", "Robe", "Manteau",
               "Sandale", "Chemise", "Basket", "Sac", "Botte"]

# 4. Construction du modèle CNN
model = tf.keras.Sequential([
    tf.keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
    tf.keras.layers.MaxPooling2D(2,2),
    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')  # 10 classes
])

# 5. Compilation et entraînement
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(X_train, y_train, epochs=5, validation_split=0.1)

# 6. Évaluation
test_loss, test_acc = model.evaluate(X_test, y_test)
print(f"\n✅ Accuracy sur les données de test : {test_acc:.4f}")

# 7. Prédictions sur quelques images
predictions = model.predict(X_test)

plt.figure(figsize=(10, 5))
for i in range(10):
    plt.subplot(2, 5, i + 1)
    plt.imshow(X_test[i].squeeze(), cmap='gray')
    pred_class = class_names[np.argmax(predictions[i])]
    true_class = class_names[y_test[i]]
    plt.title(f"Préd: {pred_class}\nVrai: {true_class}")
    plt.axis('off')
plt.tight_layout()
plt.show()

Explication du code :

1. Chargement du dataset Fashion MNIST 
- Dataset de 70 000 images (60 000 train / 10 000 test) en niveaux de gris (28x28 pixels). 
- Chaque image correspond à un vêtement appartenant à l'une des 10 classes.

2. Prétraitement des données 
- **Normalisation** des valeurs des pixels : division par 255. 
- **Ajout d’une dimension** pour le canal (passage à la forme `(28, 28, 1)`).

3. Définition des noms de classes 
- Liste descriptive des 10 catégories : `["T-shirt", "Pantalon", ..., "Botte"]`.

4. Construction du modèle CNN 
- **Architecture** : 
- `Conv2D(32)` + `MaxPooling2D(2x2)` 
- `Conv2D(64)` + `MaxPooling2D(2x2)` 
- `Flatten` - `Dense(128, relu)` 
- `Dense(10, softmax)` 
- **Forme d’entrée** : `(28, 28, 1)` 
- **Nombre de classes en sortie** : 10 (activation softmax).

5. Compilation et entraînement 
- **Optimiseur** : `Adam` 
- **Fonction de perte** : `sparse_categorical_crossentropy` (car `y_train` n’est pas encodé en one-hot). 
- **Métrique** : `accuracy` 
- Entraînement sur 5 époques avec 10% des données utilisées pour la validation.

6. Évaluation 
- Évaluation sur les données de test. 
- Affichage de la précision obtenue (`test_acc`).

7. Prédictions et visualisation 
- Prédiction sur 10 images de test. 
- Affichage de chaque image avec : 
- **Classe prédite** (`Préd:`) - **Classe réelle** (`Vrai:`)