Implémentation d'un modèle de localisation d'objets

La localisation d’objets consiste à identifier la position d’un objet spécifique dans une image. Dans ce tutoriel, nous allons implémenter un modèle de localisation d’objets en utilisant un réseau de neurones convolutifs (CNN). Nous allons utiliser TensorFlow et Keras pour construire et entraîner le modèle.

Étape 1 : Préparation des données

Pour ce tutoriel, nous allons utiliser un jeu de données simple contenant des images et des coordonnées de boîtes englobantes (bounding boxes) pour les objets. Vous pouvez utiliser un jeu de données comme le jeu de données de chats et de chiens de Kaggle, ou tout autre jeu de données approprié.

Chargement et prétraitement des données

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Chemin vers les données
train_dir = 'path_to_train_data'
val_dir = 'path_to_val_data'

# Paramètres de prétraitement
img_height, img_width = 224, 224
batch_size = 32

# Générateurs de données
train_datagen = ImageDataGenerator(rescale=1./255)
val_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
    train_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='input',  # Pour la localisation d'objets, nous avons besoin des images et des coordonnées
    shuffle=True
)

val_generator = val_datagen.flow_from_directory(
    val_dir,
    target_size=(img_height, img_width),
    batch_size=batch_size,
    class_mode='input',
    shuffle=False
)

Étape 2 : Construction du modèle

Nous allons construire un modèle CNN pour la localisation d’objets. Le modèle prendra une image en entrée et produira les coordonnées de la boîte englobante (x, y, largeur, hauteur) en sortie.

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

def build_model():
    model = Sequential([
        Conv2D(32, (3, 3), activation='relu', input_shape=(img_height, img_width, 3)),
        MaxPooling2D((2, 2)),
        Conv2D(64, (3, 3), activation='relu'),
        MaxPooling2D((2, 2)),
        Conv2D(128, (3, 3), activation='relu'),
        MaxPooling2D((2, 2)),
        Flatten(),
        Dense(512, activation='relu'),
        Dense(4)  # Sortie : (x, y, largeur, hauteur)
    ])
    return model

model = build_model()
model.summary()

Étape 3 : Compilation du modèle

Nous allons compiler le modèle en utilisant une fonction de perte appropriée pour la localisation d’objets, comme la perte de moyenne quadratique (Mean Squared Error).

model.compile(optimizer='adam', loss='mean_squared_error', metrics=['accuracy'])

Étape 4 : Entraînement du modèle

Nous allons entraîner le modèle sur les données de formation et évaluer ses performances sur les données de validation.

history = model.fit(
    train_generator,
    steps_per_epoch=len(train_generator),
    epochs=10,
    validation_data=val_generator,
    validation_steps=len(val_generator)
)

Étape 5 : Évaluation du modèle

Nous allons évaluer le modèle sur les données de validation et afficher les résultats.

val_loss, val_accuracy = model.evaluate(val_generator, steps=len(val_generator))
print(f'Validation Loss: {val_loss}')
print(f'Validation Accuracy: {val_accuracy}')

Étape 6 : Visualisation des résultats

Nous allons visualiser les résultats de la localisation d’objets sur quelques images de test.

def visualize_results(model, val_generator):
    images, labels = next(val_generator)
    predictions = model.predict(images)

    plt.figure(figsize=(12, 12))
    for i in range(4):
        plt.subplot(2, 2, i + 1)
        plt.imshow(images[i])
        plt.axis('off')

        # Coordonnées de la boîte englobante prédite
        x, y, w, h = predictions[i]
        rect = plt.Rectangle((x, y), w, h, linewidth=2, edgecolor='r', facecolor='none')
        plt.gca().add_patch(rect)

    plt.show()

visualize_results(model, val_generator)

Conclusion

Dans ce tutoriel, nous avons implémenté un modèle de localisation d’objets en utilisant un réseau de neurones convolutifs (CNN) avec TensorFlow et Keras. Nous avons préparé les données, construit et compilé le modèle, entraîné le modèle, évalué ses performances et visualisé les résultats. La localisation d’objets est une tâche fondamentale en vision par ordinateur et peut être utilisée dans de nombreuses applications, comme la reconnaissance de visages, la détection de véhicules, et bien plus encore.