Object Detection: cos'è, algoritmi e come funziona

Cos'è Object Detection: principio di funzionamento

Object Detection risolve due compiti simultaneamente: cosa c'è nell'immagine (classificazione) e dove (regressione delle coordinate). Il modello divide l'immagine in una griglia, prevede un bounding box (x, y, larghezza, altezza) e probabilità di classe per ogni cella. La Non-Maximum Suppression (NMS) rimuove i riquadri duplicati per un singolo oggetto, mantenendo la previsione più sicura. Le architetture moderne si dividono in due stadi (Faster R-CNN — prima proposte di regione, poi classificazione) e uno stadio (YOLO, SSD — tutto in una volta).

Metriche di valutazione: mAP (mean Average Precision) — la metrica di qualità principale per Object Detection. mAP@0.5 — precisione alla soglia IoU di 0,5, mAP@0.5:0.95 — media tra soglie da 0,5 a 0,95. FPS — fotogrammi al secondo (velocità di inferenza). Per le applicazioni mobili, l'equilibrio mAP/FPS è critico: YOLOv8-Nano offre il 42% mAP@0.5:0.95 a 50+ FPS, SSD MobileNet — 22% mAP a 60+ FPS. Per il tempo reale > 20 FPS, per uso interattivo 5–15 FPS.

IoU (Intersection over Union) — una metrica di sovrapposizione tra il bounding box previsto e quello reale. IoU = area di intersezione / area di unione. La soglia IoU per NMS è tipicamente 0,5–0,7. Per il tracciamento degli oggetti tra fotogrammi (re-identificazione), utilizzare Deep SORT o ByteTrack con corrispondenza IoU. Per il conteggio degli oggetti in video, BoT-SORT fornisce l'85% MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — forme di bounding box predefinite che il modello aggiusta. YOLOv8 utilizza il rilevamento senza ancore (anchor-free), che semplifica l'addestramento e accelera l'inferenza. SSD e i vecchi YOLO richiedono la regolazione delle ancore per ogni dataset. Per lo sviluppo mobile, le architetture senza ancore (YOLOv8, FCOS) sono preferibili — non dipendono dalle dimensioni degli oggetti e sono più facili da personalizzare.

ML Kit Object Detection e Tracking

ML Kit Object Detection and Tracking — la libreria di Google per il rilevamento e il tracciamento degli oggetti sul dispositivo. Supporta due modalità: rilevatore a immagine singola (per foto) e rilevatore in streaming (per video). La modalità Streaming traccia automaticamente gli oggetti tra i fotogrammi utilizzando il flusso ottico, riducendo la latenza tra i fotogrammi a 5–10 ms dopo il rilevamento iniziale. Categorie: fashion, food, home, places — 10–20 classi ciascuna.

API ML Kit: ObjectDetector (opzioni: detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). TrackingId consente di tracciare lo stesso oggetto tra i fotogrammi. MultipleObjects = true — rileva fino a 5 oggetti per fotogramma. Classification — abilita il riconoscimento della categoria dell'oggetto (default false per velocità). La modalità Streaming è consigliata per il tempo reale: 20–30 FPS su 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: dopo aver rilevato un oggetto nel primo fotogramma, ML Kit lo traccia attraverso il flusso video senza ripetere il rilevamento (basato su flusso ottico + tracciamento delle caratteristiche). Ciò riduce il carico di CPU/GPU: rilevamento iniziale 30–60 ms, fotogrammi di tracciamento successivi 2–5 ms. Se l'oggetto esce dal fotogramma o ruota > 30°, il tracker si azzera e richiede un nuovo rilevamento. TrackingId persiste finché l'oggetto è nel fotogramma. Per contare oggetti unici, utilizzare trackingId come identificatore.

YOLO: You Only Look Once sui dispositivi mobili

YOLOv8-Nano — la versione più piccola di YOLOv8 (Ultralytics) per dispositivi edge. 2,6M parametri, 5,9 MB (FP16), 42% mAP@0.5:0.95 su COCO. YOLOv8 utilizza rilevamento senza ancore + backbone C2f + TaskAlignedAssigner per l'abbinamento delle previsioni. Per lo sviluppo mobile, l'esportazione è disponibile per TFLite (INT8 — 2,0 MB, latenza 8–20 ms) e Core ML (4,5 MB, latenza 5–15 ms su iPhone 15 Pro). YOLOv8-Nano è la scelta migliore per Object Detection in tempo reale sul dispositivo.

Esportazione di YOLOv8 in TFLite: Ultralytics fornisce CLI: yolo export model=yolov8n.pt format=tflite int8. L'output è un modello TFLite INT8 ottimizzato per GPU Delegate tramite NNAPI. Per dataset personalizzati (classi proprie, non COCO) — addestramento tramite Ultralytics HUB su 50–500 immagini per classe. RT-DETR (Real-Time Detection Transformer) — un'alternativa basata sull'architettura Transformer, 48% mAP a 60 FPS su NVIDIA Jetson, ma per i dispositivi mobili è ancora inferiore a YOLOv8-Nano in velocità.

# 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 sui dispositivi mobili: ML Kit Object Detection è più facile da integrare (10 righe di codice), non richiede competenze ML, ma è limitato alle classi standard (fashion, food, home, places). YOLOv8-Nano richiede esportazione personalizzata ma offre il controllo completo: qualsiasi classe, dimensione di input, architettura. Per prototipazione rapida — ML Kit. Per produzione con oggetti non standard — YOLOv8-Nano. Per iOS: YOLOv8-Core ML tramite esportazione del modello da Ultralytics + VNCoreMLRequest.

SSD e altre architetture sul dispositivo

SSD (Single Shot Multibox Detector) — un'architettura one-stage classica per dispositivi mobili. SSD MobileNetV2 — lo standard de facto nel 2020–2023: 22% mAP@0.5:0.95 su COCO, 15–40 ms su Pixel 6. SSD utilizza una piramide di caratteristiche (diversi livelli MobileNet per rilevare oggetti di varie dimensioni) e scatole predefinite (anchor boxes) per ogni cella della mappa delle caratteristiche. Vantaggi: velocità massima per l'epoca. Svantaggi: bassa precisione su oggetti piccoli (10–30 px).

EfficientDet-Lite — una famiglia di Google (2020+), ottimizzata per TFLite. EfficientDet-Lite0: 3,9M parametri, 35% mAP, 20–50 ms. EfficientDet-Lite2: 8,1M, 42% mAP, 40–80 ms. EfficientDet utilizza BiFPN (Bidirectional Feature Pyramid Network) per la fusione di caratteristiche multiscala — ciò fornisce un guadagno del 2–4% mAP senza aumentare la latenza. Per lo sviluppo mobile, Google raccomanda EfficientDet-Lite come rilevatore principale per TFLite Task Vision.

MediaPipe Object Detector — un'implementazione pronta basata su EfficientDet-Lite come parte di MediaPipe Tasks Vision. Fornisce un'API unificata per Android, iOS, Python, Web. MediaPipe Object Detector supporta le classi COCO (80 classi), modelli personalizzati, modalità streaming e delegati CPU/GPU. Per l'integrazione rapida di Object Detection in un progetto cross-platform, MediaPipe è la scelta ottimale: un codice per tutte le piattaforme.

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

Scelta dell'architettura per un'applicazione mobile: per > 30 FPS su dispositivi di fascia media — YOLOv8-Nano (INT8) o SSD MobileNetV2. Per precisione > 40% mAP — YOLOv8-Small (11,2M) o EfficientDet-Lite2 (8,1M). Per cross-platform — MediaPipe Object Detector. Per semplicità — ML Kit. Per iOS-first — Core ML + YOLOv8 .mlpackage. Per Android-first — TFLite Task Vision (ObjectDetector API). Addestramento: Roboflow (dataset) + Ultralytics YOLOv8 (addestramento) + export in TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — un'API unificata di Google per eseguire modelli Object Detection su Android e iOS. Task API gestisce automaticamente la pre-elaborazione dell'immagine (ridimensionamento, normalizzazione, conversione dello spazio colore) e la post-elaborazione (NMS, sogliatura). Lo sviluppatore deve solo passare un modello .tflite e ricevere un elenco di Detection con bounding box + categoria + punteggio. Task API supporta modelli compatibili con COCO (80 classi).

Conversione di un modello personalizzato in Task API: il modello TFLite deve avere input [1, height, width, 3] (float32/uint8) e output: detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1]. Esportazione da TensorFlow Object Detection API con operazioni di post-elaborazione incluse (SSD Postprocess). Per YOLOv8 — esportazione TFLite con NMS tramite ops-compat. Task API su iOS utilizza Core ML Delegate per l'accelerazione su 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
    )
}

Prestazioni di Task API: GPU Delegate su Android fornisce un'accelerazione 3–5x rispetto a CPU (XNNPACK). NNAPI Delegate — ulteriore 1,5–2x su dispositivi con NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — fino a 10x su acceleratori DSP. Per iOS, Core ML Delegate — 4–6x contro CPU. Task API seleziona automaticamente l'acceleratore hardware disponibile, ma è possibile forzare un delegato tramite DetectorOptions.

Applicazioni di Object Detection nelle app mobili

Conteggio di persone e oggetti — analisi del commercio al dettaglio: rilevamento dei visitatori in un negozio, conteggio delle code, determinazione dei livelli di scorta sugli scaffali. Un contapassi Object Detection in un fotogramma aiuta a stimare il traffico pedonale e la conversione. ML Kit Object Detector offre fino a 30 FPS — sufficiente per il conteggio in tempo reale. Per l'attraversamento di zone — una combinazione di Object Detection + tracciamento ByteTrack. Precisione di conteggio: 92–95% in buone condizioni di illuminazione.

Rilevamento di difetti nella produzione — Object Detection identifica i difetti su un nastro trasportatore: graffi, scheggiature, crepe, montaggio errato. Un modello YOLOv8-Nano (INT8) personalizzato viene eseguito su un tablet Android collegato a una telecamera USB. Latenza: 20–40 ms per fotogramma (25–50 FPS). Per difetti complessi (micro-crepe) — aumentare la risoluzione di input a 640x640 (latenza 40–80 ms). Addestramento: Roboflow — dataset di 200–1000 immagini di difetti + Ultralytics YOLOv8.

Marcatura AR di oggetti in tempo reale — ARCore (Android) e ARKit (iOS) utilizzano Object Detection per riconoscere superfici piane, piani verticali e oggetti 3D. ML Kit Object Detection + ARCore Scene Semantics fornisce la segmentazione degli oggetti: parete, pavimento, soffitto, mobili. Per la marcatura AR personalizzata (ad esempio, riconoscere un modello specifico di divano e sovrapporre informazioni AR) — YOLOv8-Nano + SceneKit/SceneForm. Requisito tempo reale: > 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))
    }
}

Imaging medico — Object Detection per analizzare radiografie, risonanze magnetiche, TAC. Rilevamento di tumori, fratture, patologie sul dispositivo mobile di un medico. YOLOv8-Nano su un tablet Android rileva noduli polmonari in 15–30 ms con sensibilità dell'89% e specificità del 93% (dati NIH ChestX-ray14). Requisiti: quantizzazione INT8 (privacy dei dati), alto richiamo (perdere una patologia è più pericoloso di un falso positivo), soglia di confidenza < 0,4. L'elaborazione sul dispositivo garantisce la privacy dei dati medici.