Object Detection: ce este, algoritmi și principiul de funcționare

Ce este Object Detection: principiul de funcționare

Object Detection rezolvă două sarcini simultan: ce este în imagine (clasificare) și unde (regresie coordonate). Modelul împarte imaginea într-o grilă, pentru fiecare celulă prezice bounding box (x, y, width, height) și probabilitățile claselor. Non-Maximum Suppression (NMS) elimină cadrele duplicate pentru un obiect, păstrând cea mai sigură predicție. Arhitecturile moderne se împart în two-stage (Faster R-CNN — mai întâi region proposals, apoi clasificare) și one-stage (YOLO, SSD — totul odată).

Metrici de evaluare: mAP (mean Average Precision) — metrica principală de calitate a Object Detection. mAP@0.5 — precizia la pragul IoU 0.5, mAP@0.5:0.95 — media pe praguri de la 0.5 la 0.95. FPS — numărul de cadre pe secundă (viteza de inferență). Pentru aplicațiile mobile, echilibrul mAP/FPS este critic: YOLOv8-Nano oferă 42% mAP@0.5:0.95 la 50+ FPS, SSD MobileNet — 22% mAP la 60+ FPS. Pentru real-time > 20 FPS, pentru utilizare interactivă 5–15 FPS.

IoU (Intersection over Union) — metrica de suprapunere între bounding box prezis și ground truth. IoU = aria intersecției / aria reuniunii. Pragul IoU pentru NMS este de obicei 0.5–0.7. Pentru urmărirea obiectelor între cadre (re-identification) utilizați Deep SORT sau ByteTrack cu potrivire IoU. Pentru numărarea obiectelor pe video — BoT-SORT asigură 85% MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — forme predefinite de bounding box pe care modelul le corectează. YOLOv8 utilizează detecție fără ancore (anchor-free), ceea ce simplifică învățarea și accelerează inferența. SSD și YOLO vechi necesită selectarea ancorelor pentru setul de date. Pentru dezvoltarea mobilă, arhitecturile anchor-free (YOLOv8, FCOS) sunt preferate — nu depind de dimensiunea obiectelor și sunt mai simple de personalizat.

ML Kit Object Detection și Tracking

ML Kit Object Detection and Tracking — biblioteca Google pentru detectarea și urmărirea obiectelor pe dispozitiv. Suportă două modificări: single-image detector (pentru fotografii) și streaming detector (pentru video). Modul streaming urmărește automat obiectele între cadre utilizând fluxul optic, reducând latența între cadre la 5–10 ms după detectarea inițială. Categorii: fashion, food, home, places — câte 10–20 clase fiecare.

API ML Kit: ObjectDetector (opțiuni: detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). TrackingId permite urmărirea aceluiași obiect între cadre. MultipleObjects = true — detectează până la 5 obiecte pe cadru. Classification — activează recunoașterea categoriei obiectului (implicit false pentru viteză). Modul streaming este recomandat pentru real-time: 20–30 FPS pe 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: după detectarea obiectului pe primul cadru, ML Kit îl urmărește prin fluxul video fără redetectare (pe baza optical flow + feature tracking). Aceasta reduce încărcarea CPU/GPU: prima detectare 30–60 ms, cadrele de urmărire ulterioare 2–5 ms. Dacă obiectul iese din cadru sau se rotește > 30°, tracker-ul se resetează și este necesară o nouă detectare. TrackingId rămâne cât timp obiectul se află în cadru. Pentru numărarea obiectelor unice, utilizați trackingId ca identificator.

YOLO: You Only Look Once pe dispozitive mobile

YOLOv8-Nano — cea mai mică versiune a YOLOv8 (Ultralytics) pentru dispozitive edge. 2.6M parametri, 5.9 MB (FP16), 42% mAP@0.5:0.95 pe COCO. YOLOv8 utilizează detecție anchor-free + C2f backbone + TaskAlignedAssigner pentru potrivirea predicțiilor. Pentru dezvoltarea mobilă este disponibil exportul în TFLite (INT8 — 2.0 MB, latență 8–20 ms) și Core ML (4.5 MB, latență 5–15 ms pe iPhone 15 Pro). YOLOv8-Nano — cea mai bună alegere pentru Object Detection în timp real pe dispozitiv.

Exportul YOLOv8 în TFLite: Ultralytics oferă CLI: yolo export model=yolov8n.pt format=tflite int8. Rezultatul — model TFLite INT8 optimizat pentru GPU Delegate prin NNAPI. Pentru setul de date personalizat (clase proprii, nu COCO) — instruire prin Ultralytics HUB pe 50–500 de imagini per clasă. RT-DETR (Real-Time Detection Transformer) — alternativă pe arhitectura Transformer, 48% mAP la 60 FPS pe NVIDIA Jetson, dar pentru dispozitive mobile încă este inferior YOLOv8-Nano ca viteză.

# Export YOLOv8 în TFLite
from ultralytics import YOLO

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

# Inferență cu TFLite pe Android
val interpreter = Interpreter(loadFile("yolov8n_int8.tflite"))
val output = Array(1) { Array(8400) { FloatArray(6) } }
interpreter.run(inputBuffer, output)

YOLO vs ML Kit pe dispozitive mobile: ML Kit Object Detection este mai simplu de integrat (10 linii de cod), nu necesită expertiză ML, dar este limitat la clase standard (fashion, food, home, places). YOLOv8-Nano necesită export personalizat, dar oferă control complet: orice clase, dimensiune de intrare, arhitectură. Pentru prototipare rapidă — ML Kit. Pentru producție cu obiecte nestandard — YOLOv8-Nano. Pentru iOS: YOLOv8-Core ML prin exportul modelului din Ultralytics + VNCoreMLRequest.

SSD și alte arhitecturi on-device

SSD (Single Shot Multibox Detector) — arhitectură clasică one-stage pentru dispozitive mobile. SSD MobileNetV2 — standardul de facto în 2020–2023: 22% mAP@0.5:0.95 pe COCO, 15–40 ms pe Pixel 6. SSD utilizează feature pyramid (diferite straturi MobileNet pentru detectarea obiectelor de diferite dimensiuni) și default boxes (anchor boxes) pentru fiecare celulă a hărții de caracteristici. Avantaj: viteză maximă pentru vremea sa. Dezavantaj: precizie scăzută pe obiecte mici (10–30 px).

EfficientDet-Lite — familie de la Google (2020+), optimizată pentru TFLite. EfficientDet-Lite0: 3.9M parametri, 35% mAP, 20–50 ms. EfficientDet-Lite2: 8.1M, 42% mAP, 40–80 ms. EfficientDet utilizează BiFPN (Bidirectional Feature Pyramid Network) pentru multi-scale feature fusion — oferind o creștere de 2–4% mAP fără creșterea latenței. Pentru dezvoltarea mobilă, Google recomandă EfficientDet-Lite ca detector principal pentru TFLite Task Vision.

MediaPipe Object Detector — implementare gata făcută bazată pe EfficientDet-Lite în cadrul MediaPipe Tasks Vision. Oferă API unificat pentru Android, iOS, Python, Web. MediaPipe Object Detector suportă clase COCO (80 clase), modele personalizate, modul streaming și delegate CPU/GPU. Pentru integrare rapidă Object Detection într-un proiect cross-platform, MediaPipe este alegerea optimă: un singur cod pentru toate platformele.

// 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()
}

Alegerea arhitecturii pentru aplicația mobilă: pentru > 30 FPS pe dispozitive medii — YOLOv8-Nano (INT8) sau SSD MobileNetV2. Pentru precizie > 40% mAP — YOLOv8-Small (11.2M) sau EfficientDet-Lite2 (8.1M). Pentru cross-platform — MediaPipe Object Detector. Pentru simplitate — ML Kit. Pentru iOS-first — Core ML + YOLOv8 .mlpackage. Pentru Android-first — TFLite Task Vision (ObjectDetector API). Instruire: Roboflow (set de date) + Ultralytics YOLOv8 (antrenare) + export în TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — API unificat de la Google pentru rularea modelelor Object Detection pe Android și iOS. Task API gestionează automat preprocesarea imaginii (scalare, normalizare, conversie spațiu de culoare) și postprocesarea (NMS, thresholding). Dezvoltatorul trebuie să trimită modelul .tflite și să primească lista Detections cu bounding box + category + score. Task API suportă modele compatibile COCO (80 clase).

Conversia modelului personalizat în Task API: Modelul TFLite trebuie să aibă intrare [1, height, width, 3] (float32/uint8) și ieșire: detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1]. Export din TensorFlow Object Detection API cu operații post-procesare incluse (SSD Postprocess). Pentru YOLOv8 — export TFLite cu NMS prin ops-compat. Task API pe iOS utilizează Core ML Delegate pentru accelerare pe 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
    )
}

Performanța Task API: GPU Delegate pe Android oferă o accelerare de 3–5x comparativ cu CPU (XNNPACK). NNAPI Delegate — încă 1.5–2x pe dispozitive cu NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — până la 10x pe acceleratoare DSP. Pentru iOS, Core ML Delegate — 4–6x față de CPU. Task API selectează automat acceleratorul hardware disponibil, dar se poate forța delegatul prin DetectorOptions.

Aplicarea Object Detection în aplicațiile mobile

Numărarea persoanelor și obiectelor — analiză de retail: detectarea vizitatorilor în magazin, numărarea cozilor, determinarea gradului de umplere a rafturilor cu marfă. Contorul Object Detection în cadru permite evaluarea traficului și conversiei. ML Kit Object Detector oferă până la 30 FPS — suficient pentru numărare în timp real. Pentru traversarea liniilor (zone crossing) — combinație Object Detection + urmărire ByteTrack. Precizia numărării: 92–95% la iluminare bună.

Detectarea defectelor în producție — Object Detection identifică defecte pe linia de producție: zgârieturi, ciobituri, fisuri, asamblare incorectă. Modelul personalizat YOLOv8-Nano (INT8) rulează pe o tabletă Android conectată la o cameră USB. Latență: 20–40 ms per cadru (25–50 FPS). Pentru defecte complexe (microfisuri) — măriți rezoluția de intrare la 640x640 (latență 40–80 ms). Instruire: Roboflow — set de date de 200–1000 de imagini cu defecte + Ultralytics YOLOv8.

Marcare AR a obiectelor în timp real — ARCore (Android) și ARKit (iOS) utilizează Object Detection pentru recunoașterea suprafețelor plane, planurilor verticale și obiectelor 3D. ML Kit Object Detection + ARCore Scene Semantics oferă segmentarea obiectelor: perete, podea, tavan, mobilier. Pentru marcare AR personalizată (de exemplu, recunoașterea unui model specific de canapea și suprapunerea informațiilor AR) — YOLOv8-Nano + SceneKit/SceneForm. Cerința real-time: > 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))
    }
}

Imagistică medicală — Object Detection pentru analiza radiografiilor, RMN, CT. Detectarea tumorilor, fracturilor, patologiilor pe dispozitivul mobil al medicului. YOLOv8-Nano pe o tabletă Android detectează noduli pulmonari în 15–30 ms cu sensibilitate de 89% și specificitate de 93% (date NIH ChestX-ray14). Cerințe: cuantizare INT8 (confidențialitatea datelor), high recall (omiterea unei patologii este mai periculoasă decât un fals pozitiv), utilizarea pragului de încredere < 0.4. Procesarea pe dispozitiv garantează confidențialitatea datelor medicale.