Reconnaissance d’Objets

Fonctions :

• Reconnaissance d’Objets (exemple)

  La reconnaissance d’objets avec un réseau de neurones convolutif (CNN) consiste à détecter et classer automatiquement des objets présents dans une image. Elle repose sur l’extraction hiérarchique de caractéristiques (bords, formes, textures, etc.) à travers des couches convolutives.

  Importation :

  import tensorflow as tf
  from tensorflow.keras import layers, models
  from tensorflow.keras.datasets import cifar10
  import matplotlib.pyplot as plt
  import numpy as np

  Attributs :

  Composant	Rôle	Description
  Conv2D	Extraction de caractéristiques	Applique des filtres pour détecter des motifs locaux dans l’image.
  Activation	Non-linéarité	Utilise souvent ReLU pour introduire de la non-linéarité entre les couches.
  MaxPooling2D	Réduction de dimension	Diminue la taille des cartes de caractéristiques tout en conservant les informations importantes.
  Flatten	Vectorisation	Transforme les cartes 2D en vecteur 1D pour la classification.
  Dense	Classification	Couches pleinement connectées pour prédire la classe de l’objet.

  Exemple de code :

  📋 Copy

  import tensorflow as tf
  from tensorflow.keras import layers, models
  from tensorflow.keras.datasets import cifar10
  import matplotlib.pyplot as plt
  import numpy as np
  
  # Charger les données CIFAR-10
  (x_train, y_train), (x_test, y_test) = cifar10.load_data()
  
  # Normalisation des pixels entre 0 et 1
  x_train = x_train.astype("float32") / 255.0
  x_test = x_test.astype("float32") / 255.0
  
  # Conversion des labels en one-hot encoding
  y_train = tf.keras.utils.to_categorical(y_train, 10)
  y_test = tf.keras.utils.to_categorical(y_test, 10)
  
  # Définition du modèle CNN
  model = models.Sequential([
      layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
      layers.MaxPooling2D((2, 2)),
  
      layers.Conv2D(64, (3, 3), activation='relu'),
      layers.MaxPooling2D((2, 2)),
  
      layers.Conv2D(64, (3, 3), activation='relu'),
      layers.Flatten(),
  
      layers.Dense(64, activation='relu'),
      layers.Dense(10, activation='softmax')
  ])
  
  # Compilation
  model.compile(optimizer='adam',
                loss='categorical_crossentropy',
                metrics=['accuracy'])
  
  # Entraînement
  model.fit(x_train, y_train, epochs=10, batch_size=64, validation_split=0.1)
  
  # Évaluation
  test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
  print(f"Test accuracy: {test_acc:.2f}")
  
  # Prédiction sur une image de test
  predictions = model.predict(x_test)
  predicted_label = np.argmax(predictions[0])
  
  # Affichage d’une image test et sa prédiction
  plt.imshow(x_test[0])
  plt.title(f"Prédiction : {predicted_label}")
  plt.axis("off")
  plt.show()

  Explication du code :

  1. Chargement et préparation des données CIFAR-10
   
  - Dataset utilisé : `CIFAR-10` (images 32x32 RGB réparties en 10 classes). 
  - Normalisation des images : les valeurs des pixels sont converties en float32 et divisées par 255.0. 
  - Conversion des labels : encodage one-hot pour les 10 classes.
  
  2. Architecture du modèle CNN (Convolutional Neural Network)
   
  - Réseau défini avec l’API `Sequential` : 
  - `Conv2D` : 32 filtres, noyau `(3, 3)`, activation `relu`, entrée `(32, 32, 3)`. 
  - `MaxPooling2D` : pool size `(2, 2)`. 
  - `Conv2D` : 64 filtres, noyau `(3, 3)`, activation `relu`. 
  - `MaxPooling2D` : pool size `(2, 2)`. 
  - `Conv2D` : 64 filtres, noyau `(3, 3)`, activation `relu`. 
  - `Flatten` : aplatissement de la sortie pour la couche dense. 
  - `Dense` : 64 neurones, activation `relu`. 
  - `Dense` : 10 neurones, activation `softmax` (classification multi-classes).
  
  3. Compilation et entraînement
   
  - Optimiseur : `Adam`. 
  - Fonction de perte : `categorical_crossentropy` (adaptée au one-hot). 
  - Métrique : `accuracy`. 
  - Entraînement sur 5 époques, batch de 64, avec 10% des données de validation.
  
  4. Évaluation et prédiction
   
  - Évaluation du modèle sur les données de test avec affichage de la précision (`accuracy`). 
  - Prédiction : application du modèle sur `x_test[0]`. 
  - Affichage de l’image testée avec la classe prédite (`np.argmax(predictions[0])`).