Détection d'objets avec Python et Deep Learning : Guide ultime de YOLO et Faster R-CNN

Dans le domaine de la vision par ordinateur, la détection d'objets constitue une tâche fondamentale permettant à un système d'identifier automatiquement les objets présents dans une image et de déterminer leur position. Le projet "Deep Learning with Python" offre une collection de notebooks Jupyter qui aident les développeurs à maîtriser les techniques de détection d'objets. Cet article vous plongera en profondeur dans deux algorithmes majeurs de détection d'objets - YOLO et Faster R-CNN - et vous guidera à travers des cas pratiques complets, de la construction du modèle à son déploiement.

Vue d'ensemble des techniques de détection d'objets : Architecture mono-étape versus bi-étape

Les algorithmes de détection d'objets se divisent principalement en deux catégories : les détecteurs mono-étape et les détecteurs bi-étape. Ces architectures présentent各自 des avantages et s'adaptent à différents scénarios d'application.

Détecteurs bi-étape R-CNN : Approche classique priorisant la précision

Les détecteurs bi-étape, représentés par Faster R-CNN, adoptent une stratégie en deux temps : "proposition de régions + classification". Ils génèrent d'abord des régions candidates potentiellement contenant des objets, puis procèdent à leur classification et à la régression des boîtes englobantes. Cette méthode offre généralement une précision de détection plus élevée, mais sa complexité computationnelle est également supérieure. Bien que le projet ne fournisse pas d'implémentation directe de Faster R-CNN, les techniques de proposition de régions et d'extraction de caractéristiques similaires sont disponibles dans le notebook chapter12_object-detection.ipynb.

Détecteurs mono-étape : Choix moderne privilégiant la rapidité

Les détecteurs mono-étape comme YOLO (You Only Look Once) prédisent directement les classes et les positions des objets dans l'image, sautant l'étape de proposition de régions. Cette architecture de bout en bout augmente considérablement la vitesse de détection, la rendant adaptée aux applications en temps réel. Le notebook chapter12_object-detection.ipynb détaille comment construire et entraîner un modèle YOLO à partir de zéro.

Construction d'un modèle YOLO de zéro : Guide pratique complet

YOLO, grâce à sa vitesse de détection efficace et son équilibre entre précision et performance, est devenu un choix populaire dans le domaine de la détection d'objets. Nous allons maintenant expliquer étape par étape comment construire un modèle YOLO en utilisant Keras et Keras Hub.

Préparation du jeu de données COCO : Annotation et prétraitement

L'entraînement d'un modèle de détection d'objets nécessite de grandes quantités de données annotées. Nous utilisons le jeu de données COCO (Common Objects in Context), qui contient plus de 330 000 images et 2,5 millions d'objets annotés. Le code suivant permet de télécharger et de prétraiter le jeu de données COCO :

chemin_images = keras.utils.get_file(
    "coco",
    "http://images.cocodataset.org/zips/train2017.zip",
    extract=True,
)
chemin_annotations = keras.utils.get_file(
    "annotations",
    "http://images.cocodataset.org/annotations/annotations_trainval2017.zip",
    extract=True,
)

Les étapes de prétraitement incluent le redimensionnement des boîtes englobantes, la conversion du format d'annotation, etc., pour garantir que les données puissent être correctement interprétées par le modèle YOLO.

Conception de l'architecture réseau YOLO : Du réseau de base aux couches de sortie

Le modèle YOLO se compose généralement d'un réseau de base (backbone) et d'une tête de détection. Nous utilisons ResNet50 comme réseau de base pour extraire les caractéristiques de l'image, puis construisons la tête de détection avec des couches de convolution et complètement connectées :

reseau_base = keras_hub.models.Backbone.from_preset("resnet_50_imagenet")
preprocesseur = keras_hub.layers.ImageConverter.from_preset(
    "resnet_50_imagenet",
    image_size=(taille_image, taille_image),
)

entrees = keras.Input(shape=(taille_image, taille_image, 3))
x = reseau_base(entrees)
x = layers.Conv2D(512, (3, 3), strides=(2, 2))(x)
x = keras.layers.Flatten()(x)
x = layers.Dense(2048, activation="relu", kernel_initializer="glorot_normal")(x)
x = layers.Dropout(0.5)(x)
x = layers.Dense(grille * grille * (etiquettes + 5))(x)
x = layers.Reshape((grille, grille, etiquettes + 5))(x)
predictions_boites = x[..., :5]
predictions_classes = layers.Activation("softmax")(x[..., 5:])
sorties = {"boite": predictions_boites, "classe": predictions_classes}
modele = keras.Model(entrees, sorties)

Ce modèle divise l'image en une grille, où chaque cellule est responsable de la prédiction d'un certain nombre de boîtes englobantes et de probabilités de classe.

Entraînement du modèle YOLO : Fonction de perte et stratégie d'optimisation

YOLO utilise une fonction de perte spécifique pour optimiser simultanément les coordonnées des boîtes englobantes et les prédictions de classe. La fonction de perte inclut la perte de coordonnées, la perte de confiance et la perte de classe, combinées par pondération pour équilibrer l'importance des différentes parties :

def perte_boite(vrai, predit):
    xy_vrai, wh_vrai, conf_vrai = vrai[..., :2], vrai[..., 2:4], vrai[..., 4:]
    xy_predit, wh_predit, conf_predit = predit[..., :2], predit[..., 2:4], predit[..., 4:]
    # Calcul de la perte de coordonnées, de confiance, etc.
    return ops.sum(erreur, axis=(1, 2, 3))

modele.compile(
    optimizer=keras.optimizers.Adam(2e-4),
    loss={"boite": perte_boite, "classe": "sparse_categorical_crossentropy"},
)
modele.fit(
    jeu_donnees_entrainement,
    validation_data=jeu_donnees_validation,
    epochs=4,
)

Pendant l'entraînement, nous utilisons l'optimiseur Adam et ajustons les hyperparamètres en surveillant les performances sur l'ensemble de validation.

Utilisation de modèles pré-entraînés : Implémentation rapide de la détection d'objets

Pour la plupart des scénarios d'application, l'utilisation de modèles pré-entraînés est la meilleure approche pour une mise en œuvre rapide de la détection d'objets. Le projet montre comment utiliser le modèle RetinaNet pré-entraîné de Keras Hub :

detecteur = keras_hub.models.ObjectDetector.from_preset(
    "retinanet_resnet50_fpn_v2_coco",
    bounding_box_format="rel_xywh",
)
predictions = detecteur.predict(image)

RetinaNet est un détecteur mono-étape qui combine la structure FPN (Feature Pyramid Network) et permet de détecter efficacement des objets de différentes échelles. Avec quelques lignes de code, nous pouvons réaliser une détection d'objets de haute précision.

Évaluation et visualisation du modèle : Compréhension intuitive des résultats de détection

Une fois l'entraînement terminé, nous devons évaluer les performances du modèle et visualiser les résultats de détection. Le projet fournit des fonctions utilitaires pour dessiner les boîtes englobantes et les étiquettes de classe :

def dessiner_prediction(image, boites, classes, seuil=None):
    fig, ax = plt.subplots(dpi=300)
    dessiner_image(ax, image)
    # Dessin des boîtes englobantes et étiquettes de classe
    plt.show()

Grâce à la visualisation, nous pouvons comprendre intuitivement les performances de détection du modèle, identifier les aspects à améliorer, tels que le mauvais positionnement des boîtes englobantes ou la confusion entre classes.

Conclusion : Choisir la solution de détection d'objets adaptée à vos besoins

YOLO et Faster R-CNN représentent les deux principales approches technologiques en matière de détection d'objets. YOLO, avec son avantage en vitesse, convient aux applications en temps réel telles que la vidéosurveillance, l'automatisation automobile, etc. Faster R-CNN, en revanche, montre de meilleures performances dans les scénarios exigeants en précision, comme l'analyse d'images médicales ou le contrôle industriel précis.

À travers le notebook chapter12_object-detection.ipynb du projet "Deep Learning with Python", vous pouvez approfondir les détails d'implémentation de ces deux algorithmes et choisir la solution appropriée en fonction de vos besoins d'application. Que vous choisissiez d'entraîner un modèle à partir de zéro ou d'utiliser un modèle pré-entraîné pour un déploiement rapide, le projet offre des directives claires et des exemples de code pratiques.