Object Detection: Was es ist, Algorithmen und Funktionsweise

Was ist Object Detection: Funktionsprinzip

Object Detection löst zwei Aufgaben gleichzeitig: Was ist im Bild (Klassifikation) und wo (Koordinatenregression). Das Modell teilt das Bild in ein Raster, sagt für jede Zelle einen Begrenzungsrahmen (x, y, Breite, Höhe) und Klassenwahrscheinlichkeiten voraus. Non-Maximum Suppression (NMS) entfernt doppelte Boxen für ein einzelnes Objekt und behält die sicherste Vorhersage. Moderne Architekturen werden in Two-Stage (Faster R-CNN — zuerst Regionsvorschläge, dann Klassifikation) und One-Stage (YOLO, SSD — alles auf einmal) unterteilt.

Bewertungsmetriken: mAP (mean Average Precision) — die wichtigste Qualitätsmetrik für Object Detection. mAP@0.5 — Genauigkeit bei IoU-Schwellwert 0,5, mAP@0.5:0,95 — Durchschnitt über Schwellwerte von 0,5 bis 0,95. FPS — Bilder pro Sekunde (Inferenzgeschwindigkeit). Für mobile Anwendungen ist das Gleichgewicht zwischen mAP und FPS entscheidend: YOLOv8-Nano liefert 42% mAP@0.5:0,95 bei 50+ FPS, SSD MobileNet — 22% mAP bei 60+ FPS. Für Echtzeit > 20 FPS, für interaktive Nutzung 5–15 FPS.

IoU (Intersection over Union) — eine Metrik für die Überlappung zwischen vorhergesagtem und tatsächlichem Begrenzungsrahmen. IoU = Schnittfläche / Vereinigungsfläche. Der IoU-Schwellwert für NMS beträgt typischerweise 0,5–0,7. Für das Objekt-Tracking zwischen Frames (Wiedererkennung) verwenden Sie Deep SORT oder ByteTrack mit IoU-Matching. Für die Objektzählung in Videos bietet BoT-SORT 85% MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — vordefinierte Begrenzungsrahmenformen, die das Modell anpasst. YOLOv8 verwendet Anker-freie Erkennung (anchor-free), was das Training vereinfacht und die Inferenz beschleunigt. SSD und ältere YOLO-Versionen erfordern eine Anpassung der Anker für jeden Datensatz. Für die mobile Entwicklung sind Anker-freie Architekturen (YOLOv8, FCOS) vorzuziehen — sie hängen nicht von der Objektgröße ab und sind einfacher anzupassen.

ML Kit Object Detection und Tracking

ML Kit Object Detection and Tracking — Googles Bibliothek für die Objekterkennung und -verfolgung auf dem Gerät. Unterstützt zwei Modi: Einzelbild-Detektor (für Fotos) und Streaming-Detektor (für Videos). Der Streaming-Modus verfolgt Objekte automatisch zwischen Frames mittels optischem Fluss und reduziert die Latenz zwischen Frames nach der ersten Erkennung auf 5–10 ms. Kategorien: fashion, food, home, places — jeweils 10–20 Klassen.

ML Kit API: ObjectDetector (Optionen: detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). TrackingId ermöglicht die Verfolgung desselben Objekts über Frames hinweg. MultipleObjects = true — erkennt bis zu 5 Objekte pro Frame. Classification — aktiviert die Objektkategorien-Erkennung (Standard false für Geschwindigkeit). Der Streaming-Modus wird für Echtzeit empfohlen: 20–30 FPS auf 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: Nach der Erkennung eines Objekts im ersten Frame verfolgt ML Kit es durch den Videostream ohne erneute Erkennung (basierend auf optischem Fluss + Merkmalsverfolgung). Dies reduziert die CPU/GPU-Last: Ersterkennung 30–60 ms, nachfolgende Tracking-Frames 2–5 ms. Wenn das Objekt den Frame verlässt oder sich um > 30° dreht, wird der Tracker zurückgesetzt und eine erneute Erkennung ist erforderlich. TrackingId bleibt bestehen, solange das Objekt im Frame ist. Zum Zählen eindeutiger Objekte verwenden Sie trackingId als Identifikator.

YOLO: You Only Look Once auf mobilen Geräten

YOLOv8-Nano — die kleinste Version von YOLOv8 (Ultralytics) für Edge-Geräte. 2,6M Parameter, 5,9 MB (FP16), 42% mAP@0.5:0,95 auf COCO. YOLOv8 verwendet Anker-freie Erkennung + C2f-Backbone + TaskAlignedAssigner für Vorhersagenabgleich. Für die mobile Entwicklung ist der Export nach TFLite (INT8 — 2,0 MB, Latenz 8–20 ms) und Core ML (4,5 MB, Latenz 5–15 ms auf iPhone 15 Pro) verfügbar. YOLOv8-Nano ist die beste Wahl für On-Device-Echtzeit-Object Detection.

YOLOv8-Export nach TFLite: Ultralytics bietet CLI: yolo export model=yolov8n.pt format=tflite int8. Die Ausgabe ist ein TFLite INT8-Modell, optimiert für GPU Delegate über NNAPI. Für benutzerdefinierte Datensätze (eigene Klassen, nicht COCO) — Training über Ultralytics HUB mit 50–500 Bildern pro Klasse. RT-DETR (Real-Time Detection Transformer) — eine Alternative basierend auf der Transformer-Architektur, 48% mAP bei 60 FPS auf NVIDIA Jetson, bleibt aber auf mobilen Geräten in der Geschwindigkeit hinter YOLOv8-Nano zurück.

# 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 auf mobilen Geräten: ML Kit Object Detection ist einfacher zu integrieren (10 Zeilen Code), erfordert kein ML-Fachwissen, ist aber auf Standardklassen (fashion, food, home, places) beschränkt. YOLOv8-Nano erfordert benutzerdefinierten Export, bietet aber vollständige Kontrolle: beliebige Klassen, Eingabegröße, Architektur. Für schnelles Prototyping — ML Kit. Für die Produktion mit nicht standardmäßigen Objekten — YOLOv8-Nano. Für iOS: YOLOv8-Core ML über Modellexport von Ultralytics + VNCoreMLRequest.

SSD und andere On-Device-Architekturen

SSD (Single Shot Multibox Detector) — eine klassische One-Stage-Architektur für mobile Geräte. SSD MobileNetV2 — der De-facto-Standard in den Jahren 2020–2023: 22% mAP@0.5:0,95 auf COCO, 15–40 ms auf Pixel 6. SSD verwendet eine Feature-Pyramide (verschiedene MobileNet-Schichten zur Erkennung von Objekten unterschiedlicher Größe) und Default Boxes (Anchor Boxes) für jede Feature-Map-Zelle. Vorteile: maximale Geschwindigkeit für seine Zeit. Nachteile: geringe Genauigkeit bei kleinen Objekten (10–30 px).

EfficientDet-Lite — eine Familie von Google (2020+), optimiert für TFLite. EfficientDet-Lite0: 3,9M Parameter, 35% mAP, 20–50 ms. EfficientDet-Lite2: 8,1M, 42% mAP, 40–80 ms. EfficientDet verwendet BiFPN (Bidirectional Feature Pyramid Network) für Multi-Scale Feature Fusion — dies bringt einen Gewinn von 2–4% mAP ohne Erhöhung der Latenz. Für die mobile Entwicklung empfiehlt Google EfficientDet-Lite als primären Detektor für TFLite Task Vision.

MediaPipe Object Detector — eine fertige Implementierung basierend auf EfficientDet-Lite als Teil von MediaPipe Tasks Vision. Bietet eine einheitliche API für Android, iOS, Python, Web. MediaPipe Object Detector unterstützt COCO-Klassen (80 Klassen), benutzerdefinierte Modelle, Streaming-Modus und CPU/GPU-Delegaten. Für die schnelle Integration von Object Detection in ein plattformübergreifendes Projekt ist MediaPipe die optimale Wahl: ein Code für alle Plattformen.

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

Wahl der Architektur für eine mobile Anwendung: für > 30 FPS auf Mittelklasse-Geräten — YOLOv8-Nano (INT8) oder SSD MobileNetV2. Für Genauigkeit > 40% mAP — YOLOv8-Small (11,2M) oder EfficientDet-Lite2 (8,1M). Für Plattformunabhängigkeit — MediaPipe Object Detector. Für Einfachheit — ML Kit. Für iOS-First — Core ML + YOLOv8 .mlpackage. Für Android-First — TFLite Task Vision (ObjectDetector API). Training: Roboflow (Datensatz) + Ultralytics YOLOv8 (Training) + Export nach TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — eine einheitliche API von Google zum Ausführen von Object Detection-Modellen auf Android und iOS. Die Task API übernimmt automatisch die Bildvorverarbeitung (Skalierung, Normalisierung, Far braumkonvertierung) und Nachverarbeitung (NMS, Schwellwertbildung). Der Entwickler muss nur ein .tflite-Modell übergeben und erhält eine Liste von Detections mit bounding box + Kategorie + Bewertung. Die Task API unterstützt COCO-kompatible Modelle (80 Klassen).

Konvertierung eines benutzerdefinierten Modells in die Task API: Das TFLite-Modell muss Eingabe [1, height, width, 3] (float32/uint8) und Ausgabe: detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1] haben. Export aus der TensorFlow Object Detection API mit eingeschlossenen Nachverarbeitungs-ops (SSD Postprocess). Für YOLOv8 — TFLite-Export mit NMS über ops-compat. Die Task API auf iOS verwendet Core ML Delegate zur Beschleunigung auf der 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
    )
}

Task API-Leistung: GPU Delegate auf Android bietet eine 3–5-fache Beschleunigung im Vergleich zur CPU (XNNPACK). NNAPI Delegate — weitere 1,5–2-fache auf Geräten mit NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — bis zu 10-fache auf DSP-Beschleunigern. Für iOS bietet Core ML Delegate — 4–6-fache gegenüber CPU. Die Task API wählt automatisch den verfügbaren Hardware-Beschleuniger aus, aber der Delegate kann über DetectorOptions erzwungen werden.

Einsatz von Object Detection in mobilen Anwendungen

Personen- und Objektzählung — Einzelhandelsanalyse: Erkennung von Besuchern in einem Geschäft, Warteschlangenzählung, Bestimmung des Regalbestands. Ein Object Detection-Personenzähler in einem Frame hilft, den Fußgängerverkehr und die Konversion zu schätzen. ML Kit Object Detector liefert bis zu 30 FPS — ausreichend für Echtzeitzählung. Für Zonenüberschreitung — eine Kombination aus Object Detection + ByteTrack-Tracking. Zählgenauigkeit: 92–95% bei guten Lichtverhältnissen.

Defekterkennung in der Fertigung — Object Detection identifiziert Defekte auf einem Förderband: Kratzer, Absplitterungen, Risse, fehlerhafte Montage. Ein benutzerdefiniertes YOLOv8-Nano (INT8)-Modell läuft auf einem Android-Tablet, das an eine USB-Kamera angeschlossen ist. Latenz: 20–40 ms pro Frame (25–50 FPS). Für komplexe Defekte (Mikrorisse) — erhöhen Sie die Eingabeauflösung auf 640x640 (Latenz 40–80 ms). Training: Roboflow — Datensatz mit 200–1000 Defektbildern + Ultralytics YOLOv8.

Echtzeit-AR-Objektmarkierung — ARCore (Android) und ARKit (iOS) verwenden Object Detection zur Erkennung von ebenen Flächen, vertikalen Ebenen und 3D-Objekten. ML Kit Object Detection + ARCore Scene Semantics bietet Objektsegmentierung: Wand, Boden, Decke, Möbel. Für benutzerdefinierte AR-Markierung (z. B. Erkennung eines bestimmten Sofamodells und Überlagerung von AR-Informationen) — YOLOv8-Nano + SceneKit/SceneForm. Echtzeitanforderung: > 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))
    }
}

Medizinische Bildgebung — Object Detection zur Analyse von Röntgenaufnahmen, MRTs, CT-Scans. Erkennung von Tumoren, Frakturen, Pathologien auf dem mobilen Gerät eines Arztes. YOLOv8-Nano auf einem Android-Tablet erkennt Lungenknötchen in 15–30 ms mit 89% Sensitivität und 93% Spezifität (NIH ChestX-ray14-Daten). Anforderungen: INT8-Quantisierung (Datenschutz), hoher Recall (das Übersehen einer Pathologie ist gefährlicher als ein falscher Alarm), Konfidenzschwelle < 0,4. Die Verarbeitung auf dem Gerät gewährleistet den Datenschutz medizinischer Daten.