Reconnaissance d’Objets

La reconnaissance d’objets constitue une extension de la classification d’images visant non seulement à identifier la catégorie d’un objet, mais également à localiser sa position au sein d’une image. Cette double tâche repose sur des modèles de réseaux convolutifs adaptés, capables d’extraire des caractéristiques visuelles tout en produisant des prédictions spatiales sous forme de coordonnées de boîtes englobantes. Contrairement à la classification simple, qui suppose la présence d’un seul objet principal, la reconnaissance d’objets doit gérer la détection simultanée de multiples instances appartenant à des classes distinctes. Cette section propose une étude pratique de la reconnaissance d’objets à travers l’utilisation de modèles modernes tels que R-CNN, YOLO ou SSD, en abordant les étapes essentielles du traitement : annotation et préparation des données, entraînement du modèle, ajustement des hyperparamètres et évaluation des performances selon des métriques adaptées (mAP, IoU). L’objectif est d’illustrer les fondements méthodologiques et les enjeux techniques de cette tâche centrale en vision par ordinateur.

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 :

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])`).