Classification d’Images

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 :

  📋 Copy

  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:`)