Object Detection : ce que c'est, algorithmes et fonctionnement

Qu'est-ce que Object Detection : principe de fonctionnement

Object Detection résout deux tâches simultanément : ce qui est dans l'image (classification) et où (régression de coordonnées). Le modèle divise l'image en une grille, prédit une bounding box (x, y, largeur, hauteur) et des probabilités de classe pour chaque cellule. La Non-Maximum Suppression (NMS) supprime les boîtes en double pour un seul objet, en conservant la prédiction la plus confiante. Les architectures modernes sont divisées en deux étapes (Faster R-CNN — d'abord des propositions de région, puis classification) et une étape (YOLO, SSD — tout en une fois).

Métriques d'évaluation : mAP (mean Average Precision) — la métrique de qualité principale pour Object Detection. mAP@0.5 — précision au seuil IoU de 0,5, mAP@0.5:0.95 — moyenne sur les seuils de 0,5 à 0,95. FPS — images par seconde (vitesse d'inférence). Pour les applications mobiles, l'équilibre mAP/FPS est critique : YOLOv8-Nano offre 42 % mAP@0.5:0.95 à 50+ FPS, SSD MobileNet — 22 % mAP à 60+ FPS. Pour le temps réel > 20 FPS, pour une utilisation interactive 5–15 FPS.

IoU (Intersection over Union) — une métrique de chevauchement entre la bounding box prédite et réelle. IoU = zone d'intersection / zone d'union. Le seuil IoU pour NMS est généralement de 0,5 à 0,7. Pour le suivi d'objets entre les images (ré-identification), utilisez Deep SORT ou ByteTrack avec correspondance IoU. Pour le comptage d'objets dans une vidéo, BoT-SORT fournit 85 % MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — des formes de bounding box prédéfinies que le modèle ajuste. YOLOv8 utilise la détection sans ancres (anchor-free), ce qui simplifie l'entraînement et accélère l'inférence. SSD et les anciens YOLO nécessitent un réglage des ancres pour chaque ensemble de données. Pour le développement mobile, les architectures sans ancres (YOLOv8, FCOS) sont préférables — elles ne dépendent pas de la taille des objets et sont plus faciles à personnaliser.

ML Kit Object Detection et Tracking

ML Kit Object Detection and Tracking — la bibliothèque de Google pour la détection et le suivi d'objets sur l'appareil. Prend en charge deux modes : détecteur d'image unique (pour les photos) et détecteur de streaming (pour la vidéo). Le mode Streaming suit automatiquement les objets entre les images à l'aide du flux optique, réduisant la latence entre les images à 5–10 ms après la détection initiale. Catégories : fashion, food, home, places — 10–20 classes chacune.

API ML Kit : ObjectDetector (options : detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). TrackingId permet de suivre le même objet à travers les images. MultipleObjects = true — détecte jusqu'à 5 objets par image. Classification — active la reconnaissance de catégorie d'objet (par défaut false pour la vitesse). Le mode Streaming est recommandé pour le temps réel : 20–30 FPS sur Pixel 6.

val options = ObjectDetectorOptions.Builder()
    .setDetectorMode(ObjectDetectorOptions.STREAM_MODE)
    .enableClassification()
    .enableMultipleObjects()
    .build()

val detector = ObjectDetection.getClient(options)

detector.process(inputImage)
    .addOnSuccessListener { objects ->
        objects.forEach { obj ->
            val box = obj.boundingBox
            val trackingId = obj.trackingId
            val category = obj.classificationCategory()
            drawBoundingBox(box, trackingId, category)
        }
    }

Object Tracking : après avoir détecté un objet dans la première image, ML Kit le suit à travers le flux vidéo sans re-détection (basé sur le flux optique + suivi de caractéristiques). Cela réduit la charge CPU/GPU : détection initiale 30–60 ms, images de suivi suivantes 2–5 ms. Si l'objet quitte l'image ou tourne à > 30°, le tracker se réinitialise et nécessite une re-détection. TrackingId persiste tant que l'objet est dans l'image. Pour compter les objets uniques, utilisez trackingId comme identifiant.

YOLO : You Only Look Once sur les appareils mobiles

YOLOv8-Nano — la plus petite version de YOLOv8 (Ultralytics) pour les appareils de périphérie. 2,6M paramètres, 5,9 Mo (FP16), 42 % mAP@0.5:0.95 sur COCO. YOLOv8 utilise la détection sans ancres + backbone C2f + TaskAlignedAssigner pour la correspondance des prédictions. Pour le développement mobile, l'exportation est disponible vers TFLite (INT8 — 2,0 Mo, latence 8–20 ms) et Core ML (4,5 Mo, latence 5–15 ms sur iPhone 15 Pro). YOLOv8-Nano est le meilleur choix pour Object Detection en temps réel sur l'appareil.

Exportation YOLOv8 vers TFLite : Ultralytics fournit une CLI : yolo export model=yolov8n.pt format=tflite int8. La sortie est un modèle TFLite INT8 optimisé pour GPU Delegate via NNAPI. Pour des ensembles de données personnalisés (vos propres classes, pas COCO) — entraînement via Ultralytics HUB sur 50–500 images par classe. RT-DETR (Real-Time Detection Transformer) — une alternative basée sur l'architecture Transformer, 48 % mAP à 60 FPS sur NVIDIA Jetson, mais pour les appareils mobiles, il reste inférieur à YOLOv8-Nano en vitesse.

# YOLOv8 export to TFLite
from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.export(format="tflite", int8=True, imgsz=320)

# Inference with TFLite on Android
val interpreter = Interpreter(loadFile("yolov8n_int8.tflite"))
val output = Array(1) { Array(8400) { FloatArray(6) } }
interpreter.run(inputBuffer, output)

YOLO vs ML Kit sur les appareils mobiles : ML Kit Object Detection est plus facile à intégrer (10 lignes de code), ne nécessite pas d'expertise en ML, mais est limité aux classes standard (fashion, food, home, places). YOLOv8-Nano nécessite une exportation personnalisée mais offre un contrôle total : toutes les classes, taille d'entrée, architecture. Pour un prototypage rapide — ML Kit. Pour la production avec des objets non standard — YOLOv8-Nano. Pour iOS : YOLOv8-Core ML via exportation de modèle depuis Ultralytics + VNCoreMLRequest.

SSD et autres architectures sur l'appareil

SSD (Single Shot Multibox Detector) — une architecture one-stage classique pour les appareils mobiles. SSD MobileNetV2 — le standard de facto en 2020–2023 : 22 % mAP@0.5:0.95 sur COCO, 15–40 ms sur Pixel 6. SSD utilise une pyramide de caractéristiques (différentes couches MobileNet pour détecter des objets de différentes tailles) et des boîtes par défaut (anchor boxes) pour chaque cellule de carte de caractéristiques. Avantages : vitesse maximale pour son époque. Inconvénients : faible précision sur les petits objets (10–30 px).

EfficientDet-Lite — une famille de Google (2020+), optimisée pour TFLite. EfficientDet-Lite0 : 3,9M paramètres, 35 % mAP, 20–50 ms. EfficientDet-Lite2 : 8,1M, 42 % mAP, 40–80 ms. EfficientDet utilise BiFPN (Bidirectional Feature Pyramid Network) pour la fusion de caractéristiques multi-échelles — cela offre un gain de 2–4 % mAP sans augmenter la latence. Pour le développement mobile, Google recommande EfficientDet-Lite comme détecteur principal pour TFLite Task Vision.

MediaPipe Object Detector — une implémentation prête à l'emploi basée sur EfficientDet-Lite dans le cadre de MediaPipe Tasks Vision. Fournit une API unifiée pour Android, iOS, Python, Web. MediaPipe Object Detector prend en charge les classes COCO (80 classes), les modèles personnalisés, le mode streaming et les délégués CPU/GPU. Pour une intégration rapide de Object Detection dans un projet multiplateforme, MediaPipe est le choix optimal : un code pour toutes les plateformes.

// MediaPipe Object Detection
val options = ObjectDetectorOptions.Builder()
    .setBaseOptions(BaseOptions.builder()
        .setDelegate(BaseOptions.Delegate.GPU)
        .build())
    .setMaxResults(5)
    .setScoreThreshold(0.5f)
    .build()

val detector = ObjectDetector.createFromOptions(context, options)

val image = MPImage.fromBitmap(bitmap)
val result = detector.detect(image)
result.detections.forEach { detection ->
    val box = detection.boundingBox
    val category = detection.categories.first()
}

Choix d'une architecture pour une application mobile : pour > 30 FPS sur les appareils de milieu de gamme — YOLOv8-Nano (INT8) ou SSD MobileNetV2. Pour une précision > 40 % mAP — YOLOv8-Small (11,2M) ou EfficientDet-Lite2 (8,1M). Pour le multiplateforme — MediaPipe Object Detector. Pour la simplicité — ML Kit. Pour iOS-first — Core ML + YOLOv8 .mlpackage. Pour Android-first — TFLite Task Vision (ObjectDetector API). Entraînement : Roboflow (ensemble de données) + Ultralytics YOLOv8 (entraînement) + exportation vers TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — une API unifiée de Google pour exécuter des modèles Object Detection sur Android et iOS. Task API gère automatiquement le prétraitement d'image (redimensionnement, normalisation, conversion d'espace colorimétrique) et le post-traitement (NMS, seuillage). Le développeur a seulement besoin de passer un modèle .tflite et de recevoir une liste de Detections avec bounding box + catégorie + score. Task API prend en charge les modèles compatibles COCO (80 classes).

Conversion d'un modèle personnalisé vers Task API : le modèle TFLite doit avoir une entrée [1, height, width, 3] (float32/uint8) et une sortie : detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1]. Exportation depuis TensorFlow Object Detection API avec les ops de post-traitement inclus (SSD Postprocess). Pour YOLOv8 — exportation TFLite avec NMS via ops-compat. Task API sur iOS utilise Core ML Delegate pour l'accélération sur ANE.

// TFLite Task Vision Object Detector
val options = ObjectDetectorOptions.Builder()
    .setScoreThreshold(0.5f)
    .setMaxResults(10)
    .setDelegate(Delegate.GPU)
    .build()

val detector = ObjectDetector.createFromFileAndOptions(
    context, "custom_model.tflite", options
)

val image = TensorImage.fromBitmap(bitmap)
val results = detector.detect(image)
results.forEach { detection ->
    onObjectDetected(
        detection.boundingBox,
        detection.categories.first().label,
        detection.categories.first().score
    )
}

Performances de Task API : GPU Delegate sur Android offre une accélération 3–5x par rapport au CPU (XNNPACK). NNAPI Delegate — encore 1,5–2x sur les appareils avec NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — jusqu'à 10x sur les accélérateurs DSP. Pour iOS, Core ML Delegate — 4–6x contre CPU. Task API sélectionne automatiquement l'accélérateur matériel disponible, mais on peut forcer un délégué via DetectorOptions.

Utilisations de Object Detection dans les applications mobiles

Comptage de personnes et d'objets — analyse du commerce de détail : détection des visiteurs dans un magasin, comptage des files d'attente, détermination des niveaux de stock en rayon. Un compteur de personnes Object Detection dans une image aide à estimer le trafic piétonnier et la conversion. ML Kit Object Detector offre jusqu'à 30 FPS — suffisant pour le comptage en temps réel. Pour le franchissement de zones — une combinaison de Object Detection + suivi ByteTrack. Précision de comptage : 92–95 % dans de bonnes conditions d'éclairage.

Détection de défauts dans la fabrication — Object Detection identifie les défauts sur un convoyeur : rayures, éclats, fissures, mauvais assemblage. Un modèle YOLOv8-Nano (INT8) personnalisé fonctionne sur une tablette Android connectée à une caméra USB. Latence : 20–40 ms par image (25–50 FPS). Pour les défauts complexes (micro-fissures) — augmentez la résolution d'entrée à 640x640 (latence 40–80 ms). Entraînement : Roboflow — ensemble de données de 200–1000 images de défauts + Ultralytics YOLOv8.

Marquage AR d'objets en temps réel — ARCore (Android) et ARKit (iOS) utilisent Object Detection pour reconnaître les surfaces planes, les plans verticaux et les objets 3D. ML Kit Object Detection + ARCore Scene Semantics fournit la segmentation d'objets : mur, sol, plafond, meubles. Pour le marquage AR personnalisé (par exemple, reconnaître un modèle de canapé spécifique et superposer des informations AR) — YOLOv8-Nano + SceneKit/SceneForm. Exigence temps réel : > 20 FPS.

// ARKit + Object Detection
let request = VNCoreMLRequest(model: objectDetector) { req, _ in
    guard let results = req.results as? [VNDetectedObjectObservation] else { return }
    for result in results where result.confidence > 0.6 {
        let rect = result.boundingBox
        let worldPos = arView.hitTest(rect.center)
        arView.addAnchor(ARAnchor(name: label, transform: worldPos))
    }
}

Imagerie médicale — Object Detection pour analyser les radiographies, IRM, tomodensitogrammes. Détection de tumeurs, fractures, pathologies sur l'appareil mobile d'un médecin. YOLOv8-Nano sur une tablette Android détecte les nodules pulmonaires en 15–30 ms avec une sensibilité de 89 % et une spécificité de 93 % (données NIH ChestX-ray14). Exigences : quantification INT8 (confidentialité des données), haut rappel (manquer une pathologie est plus dangereux qu'une fausse alerte), seuil de confiance < 0,4. Le traitement sur l'appareil garantit la confidentialité des données médicales.