Object Detection: co to jest, algorytmy i zasada działania

Czym jest Object Detection: zasada działania

Object Detection rozwiązuje dwa zadania jednocześnie: co jest na obrazie (klasyfikacja) i gdzie (regresja współrzędnych). Model dzieli obraz na siatkę, dla każdej komórki przewiduje bounding box (x, y, width, height) i prawdopodobieństwa klas. Non-Maximum Suppression (NMS) usuwa duplikujące się ramki dla jednego obiektu, pozostawiając najbardziej pewne przewidywanie. Nowoczesne architektury dzielą się na two-stage (Faster R-CNN — najpierw region proposals, potem klasyfikacja) i one-stage (YOLO, SSD — wszystko naraz).

Metryki oceny: mAP (mean Average Precision) — główna metryka jakości Object Detection. mAP@0.5 — dokładność przy progu IoU 0.5, mAP@0.5:0.95 — średnia po progach od 0.5 do 0.95. FPS — liczba klatek na sekundę (szybkość inferencji). Dla aplikacji mobilnych balans mAP/FPS jest krytyczny: YOLOv8-Nano daje 42% mAP@0.5:0.95 przy 50+ FPS, SSD MobileNet — 22% mAP przy 60+ FPS. Dla real-time > 20 FPS, dla interaktywnego użytku 5–15 FPS.

IoU (Intersection over Union) — metryka nakładania się przewidywanego i ground truth bounding box. IoU = pole przecięcia / pole sumy. Próg IoU dla NMS zwykle 0.5–0.7. Do śledzenia obiektów między klatkami (re-identification) używaj Deep SORT lub ByteTrack z IoU-matchigiem. Do zliczania obiektów na wideo — BoT-SORT zapewnia 85% MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — predefiniowane kształty bounding box, które model koryguje. YOLOv8 używa detekcji bezanchorowej (anchor-free), co upraszcza uczenie i przyspiesza inferencję. SSD i stare YOLO wymagają doboru anchorów pod zbiór danych. Dla rozwoju mobilnego architektury anchor-free (YOLOv8, FCOS) są preferowane — nie zależą od rozmiaru obiektów i są prostsze w dostosowywaniu.

ML Kit Object Detection i Tracking

ML Kit Object Detection and Tracking — biblioteka Google do wykrywania i śledzenia obiektów na urządzeniu. Wspiera dwie modyfikacje: single-image detector (do zdjęć) i streaming detector (do wideo). Tryb streaming automatycznie śledzi obiekty między klatkami za pomocą przepływu optycznego, co zmniejsza latency do 5–10 ms między klatkami po wstępnej detekcji. Kategorie: fashion, food, home, places — po 10–20 klas każda.

API ML Kit: ObjectDetector (opcje: detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). TrackingId pozwala śledzić ten sam obiekt między klatkami. MultipleObjects = true — detekcja do 5 obiektów na klatkę. Classification — włącza rozpoznawanie kategorii obiektu (domyślnie false dla szybkości). Tryb streaming zalecany dla real-time: 20–30 FPS na 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: po detekcji obiektu na pierwszej klatce ML Kit śledzi go przez strumień wideo bez ponownej detekcji (na podstawie optical flow + feature tracking). Zmniejsza to obciążenie CPU/GPU: pierwsza detekcja 30–60 ms, kolejne klatki śledzenia 2–5 ms. Jeśli obiekt opuści kadr lub obróci się > 30°, tracker resetuje się i wymagana jest ponowna detekcja. TrackingId pozostaje, dopóki obiekt znajduje się w kadrze. Do zliczania unikalnych obiektów używaj trackingId jako identyfikatora.

YOLO: You Only Look Once na urządzeniach mobilnych

YOLOv8-Nano — najmniejsza wersja YOLOv8 (Ultralytics) dla urządzeń brzegowych. 2.6M parametrów, 5.9 MB (FP16), 42% mAP@0.5:0.95 na COCO. YOLOv8 używa detekcji anchor-free + C2f backbone + TaskAlignedAssigner do dopasowywania przewidywań. Dla rozwoju mobilnego dostępny jest eksport do TFLite (INT8 — 2.0 MB, latency 8–20 ms) i Core ML (4.5 MB, latency 5–15 ms na iPhone 15 Pro). YOLOv8-Nano — najlepszy wybór do on-device real-time Object Detection.

Eksport YOLOv8 do TFLite: Ultralytics udostępnia CLI: yolo export model=yolov8n.pt format=tflite int8. Na wyjściu — model TFLite INT8, zoptymalizowany pod GPU Delegate przez NNAPI. Dla własnego zbioru danych (własne klasy, nie COCO) — uczenie przez Ultralytics HUB na 50–500 obrazach na klasę. RT-DETR (Real-Time Detection Transformer) — alternatywa na architekturze Transformer, 48% mAP przy 60 FPS na NVIDIA Jetson, ale dla urządzeń mobilnych na razie ustępuje YOLOv8-Nano pod względem szybkości.

# Eksport YOLOv8 do TFLite
from ultralytics import YOLO

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

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

YOLO vs ML Kit na urządzeniach mobilnych: ML Kit Object Detection jest prostszy w integracji (10 linii kodu), nie wymaga wiedzy ML, ale jest ograniczony do standardowych klas (fashion, food, home, places). YOLOv8-Nano wymaga własnego eksportu, ale daje pełną kontrolę: dowolne klasy, rozmiar wejścia, architektura. Do szybkiego prototypowania — ML Kit. Do produkcji z niestandardowymi obiektami — YOLOv8-Nano. Dla iOS: YOLOv8-Core ML przez eksport modelu z Ultralytics + VNCoreMLRequest.

SSD i inne architektury on-device

SSD (Single Shot Multibox Detector) — klasyczna architektura one-stage dla urządzeń mobilnych. SSD MobileNetV2 — standard de facto w latach 2020–2023: 22% mAP@0.5:0.95 na COCO, 15–40 ms na Pixel 6. SSD używa feature pyramid (różne warstwy MobileNet do detekcji obiektów różnej wielkości) i default boxes (anchor boxes) dla każdej komórki mapy cech. Plus: maksymalna szybkość jak na swoje czasy. Minus: niska dokładność na małych obiektach (10–30 px).

EfficientDet-Lite — rodzina od Google (2020+), zoptymalizowana dla TFLite. EfficientDet-Lite0: 3.9M parametrów, 35% mAP, 20–50 ms. EfficientDet-Lite2: 8.1M, 42% mAP, 40–80 ms. EfficientDet używa BiFPN (Bidirectional Feature Pyramid Network) do multi-scale feature fusion — daje to przyrost 2–4% mAP bez zwiększania latency. Dla rozwoju mobilnego Google zaleca EfficientDet-Lite jako główny detektor dla TFLite Task Vision.

MediaPipe Object Detector — gotowa implementacja oparta na EfficientDet-Lite w ramach MediaPipe Tasks Vision. Udostępnia ujednolicone API dla Android, iOS, Python, Web. MediaPipe Object Detector wspiera klasy COCO (80 klas), modele niestandardowe, tryb streaming i delegaty CPU/GPU. Do szybkiej integracji Object Detection w projekcie międzyplatformowym MediaPipe — optymalny wybór: jeden kod na wszystkie platformy.

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

Wybór architektury dla aplikacji mobilnej: dla > 30 FPS na średnich urządzeniach — YOLOv8-Nano (INT8) lub SSD MobileNetV2. Dla dokładności > 40% mAP — YOLOv8-Small (11.2M) lub EfficientDet-Lite2 (8.1M). Dla międzyplatformowości — MediaPipe Object Detector. Dla prostoty — ML Kit. Dla iOS-first — Core ML + YOLOv8 .mlpackage. Dla Android-first — TFLite Task Vision (ObjectDetector API). Uczenie: Roboflow (zbiór danych) + Ultralytics YOLOv8 (trenowanie) + eksport do TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — ujednolicone API od Google do uruchamiania modeli Object Detection na Android i iOS. Task API automatycznie obsługuje przetwarzanie wstępne obrazu (skalowanie, normalizacja, konwersja przestrzeni kolorów) i przetwarzanie końcowe (NMS, thresholding). Deweloper musi przekazać model .tflite i otrzymać listę Detections z bounding box + category + score. Task API wspiera modele zgodne z COCO (80 klas).

Konwersja modelu niestandardowego do Task API: Model TFLite musi mieć wejście [1, height, width, 3] (float32/uint8) i wyjście: detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1]. Eksport z TensorFlow Object Detection API z włączonymi operacjami post-processing (SSD Postprocess). Dla YOLOv8 — eksport TFLite z NMS przez ops-compat. Task API na iOS używa Core ML Delegate do przyspieszenia na 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
    )
}

Wydajność Task API: GPU Delegate na Android daje przyspieszenie 3–5x w porównaniu do CPU (XNNPACK). NNAPI Delegate — kolejne 1.5–2x na urządzeniach z NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — do 10x na akceleratorach DSP. Dla iOS Core ML Delegate — 4–6x względem CPU. Task API automatycznie wybiera dostępny akcelerator sprzętowy, ale można wymusić delegat przez DetectorOptions.

Zastosowanie Object Detection w aplikacjach mobilnych

Zliczanie osób i obiektów — analityka retailowa: detekcja odwiedzających w sklepie, zliczanie kolejek, określanie zapełnienia półek towarem. Licznik obiektów Object Detection w kadrze pozwala ocenić przepustowość i konwersję. ML Kit Object Detector daje do 30 FPS — wystarczająco do zliczania w czasie rzeczywistym. Do przekraczania linii (zone crossing) — kombinacja Object Detection + tracking ByteTrack. Dokładność zliczania: 92–95% przy dobrym oświetleniu.

Detekcja wad na produkcji — Object Detection określa braki na taśmie produkcyjnej: rysy, odpryski, pęknięcia, nieprawidłowy montaż. Model niestandardowy YOLOv8-Nano (INT8) działa na tablecie Android podłączonym do kamery USB. Latency: 20–40 ms na klatkę (25–50 FPS). Do złożonych wad (mikropęknięcia) — zwiększ rozdzielczość wejścia do 640x640 (latency 40–80 ms). Uczenie: Roboflow — zbiór danych z 200–1000 obrazów wad + Ultralytics YOLOv8.

AR-oznaczanie obiektów w czasie rzeczywistym — ARCore (Android) i ARKit (iOS) używają Object Detection do rozpoznawania płaskich powierzchni, pionowych płaszczyzn i obiektów 3D. ML Kit Object Detection + ARCore Scene Semantics daje segmentację obiektów: ściana, podłoga, sufit, meble. Do niestandardowego oznaczania AR (np. rozpoznawanie konkretnego modelu sofy i nakładanie informacji AR) — YOLOv8-Nano + SceneKit/SceneForm. Wymóg 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))
    }
}

Obrazowanie medyczne — Object Detection do analizy zdjęć rentgenowskich, MRI, CT. Detekcja guzów, złamań, patologii na urządzeniu mobilnym lekarza. YOLOv8-Nano na tablecie Android wykrywa guzki w płucach w 15–30 ms z czułością 89% i swoistością 93% (dane NIH ChestX-ray14). Wymagania: kwantyzacja INT8 (prywatność danych), high recall (przeoczenie patologii jest groźniejsze niż fałszywy alarm), użycie progu confidence < 0.4. Przetwarzanie na urządzeniu gwarantuje prywatność danych medycznych.