Object Detection: vad det är, algoritmer och funktionsprincip

Vad är Object Detection: funktionsprincip

Object Detection löser två uppgifter samtidigt: vad som finns på bilden (klassificering) och var (koordinatregression). Modellen delar upp bilden i ett rutnät, för varje cell förutsäger den bounding box (x, y, width, height) och klassannolikheter. Non-Maximum Suppression (NMS) tar bort dubblettramar för ett objekt och lämnar den mest säkra förutsägelsen. Moderna arkitekturer delas in i two-stage (Faster R-CNN — först region proposals, sedan klassificering) och one-stage (YOLO, SSD — allt på en gång).

Utvärderingsmetriker: mAP (mean Average Precision) — den huvudsakliga kvalitetsmetriken för Object Detection. mAP@0.5 — noggrannhet vid IoU-tröskel 0.5, mAP@0.5:0.95 — medelvärde över trösklar från 0.5 till 0.95. FPS — antal bildrutor per sekund (inferenshastighet). För mobila applikationer är balansen mAP/FPS kritisk: YOLOv8-Nano ger 42% mAP@0.5:0.95 vid 50+ FPS, SSD MobileNet — 22% mAP vid 60+ FPS. För realtid > 20 FPS, för interaktiv användning 5–15 FPS.

IoU (Intersection over Union) — metrik för överlappning mellan förutsagd och ground truth bounding box. IoU = area av överlappning / area av förening. IoU-tröskeln för NMS är vanligtvis 0.5–0.7. För spårning av objekt mellan bildrutor (re-identification) använd Deep SORT eller ByteTrack med IoU-matchning. För räkning av objekt på video — BoT-SORT ger 85% MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — fördefinierade bounding box-former som modellen korrigerar. YOLOv8 använder ankarlös detektering (anchor-free), vilket förenklar inlärning och påskyndar inferens. SSD och gamla YOLO kräver val av ankare för datasetet. För mobil utveckling är anchor-free-arkitekturer (YOLOv8, FCOS) att föredra — de är inte beroende av objektstorlek och är enklare att anpassa.

ML Kit Object Detection och Tracking

ML Kit Object Detection and Tracking — Googles bibliotek för att detektera och spåra objekt på enheten. Stöder två modifieringar: single-image detector (för foton) och streaming detector (för video). Strömläge spårar automatiskt objekt mellan bildrutor med hjälp av optiskt flöde, vilket minskar latensen mellan bildrutor till 5–10 ms efter initial detektering. Kategorier: fashion, food, home, places — 10–20 klasser vardera.

ML Kit API: ObjectDetector (alternativ: detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). TrackingId gör det möjligt att spåra samma objekt mellan bildrutor. MultipleObjects = true — detekterar upp till 5 objekt per bildruta. Classification — aktiverar igenkänning av objektkategori (standard false för hastighet). Strömläge rekommenderas för realtid: 20–30 FPS på 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: efter detektering av objektet på den första bildrutan spårar ML Kit det genom videoströmmen utan omdetektering (baserat på optical flow + feature tracking). Detta minskar CPU/GPU-belastningen: första detektering 30–60 ms, efterföljande spårningsbildrutor 2–5 ms. Om objektet lämnar bildrutan eller roterar > 30° återställs trackern och omdetektering krävs. TrackingId finns kvar så länge objektet är i bildrutan. För räkning av unika objekt, använd trackingId som identifierare.

YOLO: You Only Look Once på mobila enheter

YOLOv8-Nano — den minsta versionen av YOLOv8 (Ultralytics) för edge-enheter. 2.6M parametrar, 5.9 MB (FP16), 42% mAP@0.5:0.95 på COCO. YOLOv8 använder ankarlös detektering + C2f backbone + TaskAlignedAssigner för matchning av förutsägelser. För mobil utveckling är export till TFLite (INT8 — 2.0 MB, latens 8–20 ms) och Core ML (4.5 MB, latens 5–15 ms på iPhone 15 Pro) tillgänglig. YOLOv8-Nano — det bästa valet för on-device real-time Object Detection.

Exportera YOLOv8 till TFLite: Ultralytics tillhandahåller CLI: yolo export model=yolov8n.pt format=tflite int8. Resultatet är en TFLite INT8-modell optimerad för GPU Delegate via NNAPI. För anpassad datauppsättning (egna klasser, inte COCO) — träning via Ultralytics HUB på 50–500 bilder per klass. RT-DETR (Real-Time Detection Transformer) — alternativ på Transformer-arkitektur, 48% mAP vid 60 FPS på NVIDIA Jetson, men för mobila enheter ligger den fortfarande efter YOLOv8-Nano i hastighet.

# Exportera YOLOv8 till TFLite
from ultralytics import YOLO

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

# Inferens med TFLite på Android
val interpreter = Interpreter(loadFile("yolov8n_int8.tflite"))
val output = Array(1) { Array(8400) { FloatArray(6) } }
interpreter.run(inputBuffer, output)

YOLO vs ML Kit på mobila enheter: ML Kit Object Detection är enklare att integrera (10 rader kod), kräver ingen ML-expertis, men är begränsad till standardklasser (fashion, food, home, places). YOLOv8-Nano kräver anpassad export, men ger full kontroll: alla klasser, ingångsstorlek, arkitektur. För snabb prototypframställning — ML Kit. För produktion med icke-standardobjekt — YOLOv8-Nano. För iOS: YOLOv8-Core ML via modelexport från Ultralytics + VNCoreMLRequest.

SSD och andra on-device-arkitekturer

SSD (Single Shot Multibox Detector) — klassisk one-stage-arkitektur för mobila enheter. SSD MobileNetV2 — de facto-standard 2020–2023: 22% mAP@0.5:0.95 på COCO, 15–40 ms på Pixel 6. SSD använder feature pyramid (olika lager av MobileNet för detektering av objekt av olika storlek) och default boxes (anchor boxes) för varje cell i feature map. Fördel: maximal hastighet för sin tid. Nackdel: låg noggrannhet på små objekt (10–30 px).

EfficientDet-Lite — familj från Google (2020+), optimerad för TFLite. EfficientDet-Lite0: 3.9M parametrar, 35% mAP, 20–50 ms. EfficientDet-Lite2: 8.1M, 42% mAP, 40–80 ms. EfficientDet använder BiFPN (Bidirectional Feature Pyramid Network) för multi-scale feature fusion — detta ger en ökning på 2–4% mAP utan att öka latensen. För mobil utveckling rekommenderar Google EfficientDet-Lite som den primära detektorn för TFLite Task Vision.

MediaPipe Object Detector — färdig implementering baserad på EfficientDet-Lite inom MediaPipe Tasks Vision. Tillhandahåller ett enhetligt API för Android, iOS, Python, Web. MediaPipe Object Detector stöder COCO-klasser (80 klasser), anpassade modeller, strömläge och CPU/GPU-delegater. För snabb integration av Object Detection i ett cross-platform-projekt är MediaPipe det optimala valet: en kod för alla plattformar.

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

Val av arkitektur för mobil applikation: för > 30 FPS på medelstora enheter — YOLOv8-Nano (INT8) eller SSD MobileNetV2. För noggrannhet > 40% mAP — YOLOv8-Small (11.2M) eller EfficientDet-Lite2 (8.1M). För cross-platform — MediaPipe Object Detector. För enkelhet — ML Kit. För iOS-first — Core ML + YOLOv8 .mlpackage. För Android-first — TFLite Task Vision (ObjectDetector API). Träning: Roboflow (dataset) + Ultralytics YOLOv8 (träning) + export till TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — enhetligt API från Google för att köra Object Detection-modeller på Android och iOS. Task API hanterar automatiskt förbehandling av bild (skalning, normalisering, färgrymdsomvandling) och efterbehandling (NMS, thresholding). Utvecklaren måste skicka .tflite-modellen och få en lista med Detections med bounding box + category + score. Task API stöder COCO-kompatibla modeller (80 klasser).

Konvertering av anpassad modell till Task API: TFLite-modellen måste ha ingång [1, height, width, 3] (float32/uint8) och utgång: detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1]. Export från TensorFlow Object Detection API med inbyggda post-processing-operatorer (SSD Postprocess). För YOLOv8 — TFLite-export med NMS via ops-compat. Task API på iOS använder Core ML Delegate för acceleration på 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
    )
}

Prestanda för Task API: GPU Delegate på Android ger en acceleration på 3–5x jämfört med CPU (XNNPACK). NNAPI Delegate — ytterligare 1.5–2x på enheter med NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — upp till 10x på DSP-acceleratorer. För iOS Core ML Delegate — 4–6x jämfört med CPU. Task API väljer automatiskt tillgänglig hårdvaruaccelerator, men delegaten kan tvingas via DetectorOptions.

Tillämpning av Object Detection i mobila applikationer

Räkning av personer och objekt — detaljhandelsanalys: detektering av besökare i butik, räkning av köer, bestämning av hyllors fyllnadsgrad med varor. Object Detection-räknaren i bildrutan gör det möjligt att utvärdera trafik och konvertering. ML Kit Object Detector ger upp till 30 FPS — tillräckligt för realtidsräkning. För linjeöverskridning (zone crossing) — kombination av Object Detection + ByteTrack-spårning. Räkningsnoggrannhet: 92–95% vid bra belysning.

Detektering av defekter i produktion — Object Detection identifierar defekter på löpande band: repor, flisor, sprickor, felaktig montering. Den anpassade YOLOv8-Nano (INT8) modellen körs på en Android-surfplatta ansluten till en USB-kamera. Latens: 20–40 ms per bildruta (25–50 FPS). För komplexa defekter (mikrosprickor) — öka ingångsupplösningen till 640x640 (latens 40–80 ms). Träning: Roboflow — dataset med 200–1000 defektbilder + Ultralytics YOLOv8.

AR-markering av objekt i realtid — ARCore (Android) och ARKit (iOS) använder Object Detection för att känna igen plana ytor, vertikala plan och 3D-objekt. ML Kit Object Detection + ARCore Scene Semantics ger segmentering av objekt: vägg, golv, tak, möbler. För anpassad AR-markering (t.ex. igenkänning av en specifik soffmodell och placering av AR-information) — YOLOv8-Nano + SceneKit/SceneForm. Realtidskrav: > 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))
    }
}

Medicinsk bildbehandling — Object Detection för analys av röntgenbilder, MRT, CT. Detektering av tumörer, frakturer, patologier på läkarens mobila enhet. YOLOv8-Nano på en Android-surfplatta detekterar lungknutor på 15–30 ms med en känslighet på 89% och specificitet på 93% (data NIH ChestX-ray14). Krav: INT8-kvantisering (dataintegritet), high recall (att missa patologi är farligare än falsklarm), användning av konfidenströskel < 0.4. Bearbetning på enheten garanterar integriteten för medicinska data.