Object Detection: apa itu, algoritma dan prinsip kerja

Apa itu Object Detection: prinsip kerja

Object Detection memecahkan dua tugas secara bersamaan: apa yang ada di gambar (klasifikasi) dan di mana (regresi koordinat). Model membagi gambar menjadi grid, untuk setiap sel memprediksi bounding box (x, y, width, height) dan probabilitas kelas. Non-Maximum Suppression (NMS) menghapus bingkai duplikat untuk satu objek, menyisakan prediksi paling yakin. Arsitektur modern dibagi menjadi two-stage (Faster R-CNN — pertama region proposals, lalu klasifikasi) dan one-stage (YOLO, SSD — semuanya sekaligus).

Metrik evaluasi: mAP (mean Average Precision) — metrik kualitas utama Object Detection. mAP@0.5 — akurasi pada ambang IoU 0.5, mAP@0.5:0.95 — rata-rata pada ambang dari 0.5 hingga 0.95. FPS — jumlah frame per detik (kecepatan inferensi). Untuk aplikasi mobile, keseimbangan mAP/FPS sangat penting: YOLOv8-Nano memberikan 42% mAP@0.5:0.95 pada 50+ FPS, SSD MobileNet — 22% mAP pada 60+ FPS. Untuk real-time > 20 FPS, untuk penggunaan interaktif 5–15 FPS.

IoU (Intersection over Union) — metrik tumpang tindih antara bounding box prediksi dan ground truth. IoU = luas irisan / luas gabungan. Ambang IoU untuk NMS biasanya 0.5–0.7. Untuk pelacakan objek antar frame (re-identification) gunakan Deep SORT atau ByteTrack dengan pencocokan IoU. Untuk menghitung objek pada video — BoT-SORT memberikan 85% MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — bentuk bounding box yang telah ditentukan sebelumnya yang dikoreksi oleh model. YOLOv8 menggunakan deteksi tanpa jangkar (anchor-free), yang menyederhanakan pembelajaran dan mempercepat inferensi. SSD dan YOLO lama memerlukan pemilihan anchor untuk dataset. Untuk pengembangan mobile, arsitektur anchor-free (YOLOv8, FCOS) lebih disukai — tidak tergantung pada ukuran objek dan lebih sederhana dalam penyesuaian.

ML Kit Object Detection dan Tracking

ML Kit Object Detection and Tracking — pustaka Google untuk mendeteksi dan melacak objek pada perangkat. Mendukung dua modifikasi: single-image detector (untuk foto) dan streaming detector (untuk video). Mode streaming secara otomatis melacak objek antar frame menggunakan aliran optik, mengurangi latensi antar frame menjadi 5–10 ms setelah deteksi awal. Kategori: fashion, food, home, places — masing-masing 10–20 kelas.

API ML Kit: ObjectDetector (opsi: detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). TrackingId memungkinkan pelacakan objek yang sama antar frame. MultipleObjects = true — mendeteksi hingga 5 objek per frame. Classification — mengaktifkan pengenalan kategori objek (default false untuk kecepatan). Mode streaming direkomendasikan untuk real-time: 20–30 FPS pada 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: setelah deteksi objek pada frame pertama, ML Kit melacaknya melalui aliran video tanpa deteksi ulang (berdasarkan optical flow + feature tracking). Ini mengurangi beban CPU/GPU: deteksi pertama 30–60 ms, frame pelacakan berikutnya 2–5 ms. Jika objek keluar dari frame atau berputar > 30°, tracker direset dan diperlukan deteksi ulang. TrackingId tetap ada selama objek berada dalam frame. Untuk menghitung objek unik, gunakan trackingId sebagai pengidentifikasi.

YOLO: You Only Look Once pada perangkat mobile

YOLOv8-Nano — versi terkecil YOLOv8 (Ultralytics) untuk perangkat edge. 2.6M parameter, 5.9 MB (FP16), 42% mAP@0.5:0.95 pada COCO. YOLOv8 menggunakan deteksi anchor-free + C2f backbone + TaskAlignedAssigner untuk pencocokan prediksi. Untuk pengembangan mobile, ekspor ke TFLite (INT8 — 2.0 MB, latensi 8–20 ms) dan Core ML (4.5 MB, latensi 5–15 ms pada iPhone 15 Pro) tersedia. YOLOv8-Nano — pilihan terbaik untuk Object Detection real-time pada perangkat.

Ekspor YOLOv8 ke TFLite: Ultralytics menyediakan CLI: yolo export model=yolov8n.pt format=tflite int8. Hasilnya — model TFLite INT8 yang dioptimalkan untuk GPU Delegate melalui NNAPI. Untuk dataset kustom (kelas sendiri, bukan COCO) — pelatihan melalui Ultralytics HUB pada 50–500 gambar per kelas. RT-DETR (Real-Time Detection Transformer) — alternatif pada arsitektur Transformer, 48% mAP pada 60 FPS di NVIDIA Jetson, tetapi untuk perangkat mobile masih kalah dari YOLOv8-Nano dalam hal kecepatan.

# Ekspor YOLOv8 ke TFLite
from ultralytics import YOLO

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

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

YOLO vs ML Kit pada perangkat mobile: ML Kit Object Detection lebih sederhana dalam integrasi (10 baris kode), tidak memerlukan keahlian ML, tetapi terbatas pada kelas standar (fashion, food, home, places). YOLOv8-Nano memerlukan ekspor kustom, tetapi memberikan kontrol penuh: kelas apa pun, ukuran input, arsitektur. Untuk pembuatan prototipe cepat — ML Kit. Untuk produksi dengan objek non-standar — YOLOv8-Nano. Untuk iOS: YOLOv8-Core ML melalui ekspor model dari Ultralytics + VNCoreMLRequest.

SSD dan arsitektur on-device lainnya

SSD (Single Shot Multibox Detector) — arsitektur one-stage klasik untuk perangkat mobile. SSD MobileNetV2 — standar de facto pada 2020–2023: 22% mAP@0.5:0.95 pada COCO, 15–40 ms pada Pixel 6. SSD menggunakan feature pyramid (lapisan MobileNet yang berbeda untuk deteksi objek dengan ukuran berbeda) dan default boxes (anchor boxes) untuk setiap sel feature map. Kelebihan: kecepatan maksimum untuk zamannya. Kekurangan: akurasi rendah pada objek kecil (10–30 px).

EfficientDet-Lite — keluarga dari Google (2020+), dioptimalkan untuk TFLite. EfficientDet-Lite0: 3.9M parameter, 35% mAP, 20–50 ms. EfficientDet-Lite2: 8.1M, 42% mAP, 40–80 ms. EfficientDet menggunakan BiFPN (Bidirectional Feature Pyramid Network) untuk multi-scale feature fusion — ini memberikan peningkatan 2–4% mAP tanpa meningkatkan latensi. Untuk pengembangan mobile, Google merekomendasikan EfficientDet-Lite sebagai detektor utama untuk TFLite Task Vision.

MediaPipe Object Detector — implementasi siap pakai berdasarkan EfficientDet-Lite dalam MediaPipe Tasks Vision. Menyediakan API terpadu untuk Android, iOS, Python, Web. MediaPipe Object Detector mendukung kelas COCO (80 kelas), model kustom, mode streaming, dan delegasi CPU/GPU. Untuk integrasi cepat Object Detection dalam proyek lintas platform, MediaPipe — pilihan optimal: satu kode untuk semua platform.

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

Pemilihan arsitektur untuk aplikasi mobile: untuk > 30 FPS pada perangkat menengah — YOLOv8-Nano (INT8) atau SSD MobileNetV2. Untuk akurasi > 40% mAP — YOLOv8-Small (11.2M) atau EfficientDet-Lite2 (8.1M). Untuk lintas platform — MediaPipe Object Detector. Untuk kesederhanaan — ML Kit. Untuk iOS-first — Core ML + YOLOv8 .mlpackage. Untuk Android-first — TFLite Task Vision (ObjectDetector API). Pelatihan: Roboflow (dataset) + Ultralytics YOLOv8 (training) + ekspor ke TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — API terpadu dari Google untuk menjalankan model Object Detection di Android dan iOS. Task API secara otomatis menangani pra-pemrosesan gambar (penskalaan, normalisasi, konversi ruang warna) dan pasca-pemrosesan (NMS, thresholding). Pengembang perlu mengirimkan model .tflite dan menerima daftar Detections dengan bounding box + category + score. Task API mendukung model yang kompatibel dengan COCO (80 kelas).

Konversi model kustom ke Task API: Model TFLite harus memiliki input [1, height, width, 3] (float32/uint8) dan output: detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1]. Ekspor dari TensorFlow Object Detection API dengan operasi pasca-pemrosesan yang disertakan (SSD Postprocess). Untuk YOLOv8 — ekspor TFLite dengan NMS melalui ops-compat. Task API di iOS menggunakan Core ML Delegate untuk percepatan di 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
    )
}

Kinerja Task API: GPU Delegate di Android memberikan percepatan 3–5x dibandingkan CPU (XNNPACK). NNAPI Delegate — tambahan 1.5–2x pada perangkat dengan NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — hingga 10x pada akselerator DSP. Untuk iOS Core ML Delegate — 4–6x dibandingkan CPU. Task API secara otomatis memilih akselerator perangkat keras yang tersedia, tetapi delegasi dapat dipaksakan melalui DetectorOptions.

Penerapan Object Detection dalam aplikasi mobile

Menghitung orang dan objek — analitik ritel: deteksi pengunjung di toko, menghitung antrian, menentukan kepenuhan rak dengan barang. Penghitung Object Detection dalam frame memungkinkan evaluasi lalu lintas dan konversi. ML Kit Object Detector memberikan hingga 30 FPS — cukup untuk penghitungan real-time. Untuk melintasi garis (zone crossing) — kombinasi Object Detection + pelacakan ByteTrack. Akurasi penghitungan: 92–95% dalam pencahayaan yang baik.

Deteksi cacat dalam produksi — Object Detection mengidentifikasi cacat di jalur produksi: goresan, serpihan, retakan, perakitan yang salah. Model kustom YOLOv8-Nano (INT8) berjalan di tablet Android yang terhubung ke kamera USB. Latensi: 20–40 ms per frame (25–50 FPS). Untuk cacat kompleks (retakan mikro) — tingkatkan resolusi input menjadi 640x640 (latensi 40–80 ms). Pelatihan: Roboflow — dataset 200–1000 gambar cacat + Ultralytics YOLOv8.

Penandaan objek AR secara real-time — ARCore (Android) dan ARKit (iOS) menggunakan Object Detection untuk mengenali permukaan datar, bidang vertikal, dan objek 3D. ML Kit Object Detection + ARCore Scene Semantics memberikan segmentasi objek: dinding, lantai, langit-langit, furnitur. Untuk penandaan AR kustom (misalnya, mengenali model sofa tertentu dan menempatkan informasi AR) — YOLOv8-Nano + SceneKit/SceneForm. Persyaratan 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))
    }
}

Pencitraan medis — Object Detection untuk analisis sinar-X, MRI, CT. Deteksi tumor, patah tulang, patologi pada perangkat mobile dokter. YOLOv8-Nano di tablet Android mendeteksi nodul paru dalam 15–30 ms dengan sensitivitas 89% dan spesifisitas 93% (data NIH ChestX-ray14). Persyaratan: kuantisasi INT8 (privasi data), high recall (melewatkan patologi lebih berbahaya daripada alarm palsu), penggunaan ambang confidence < 0.4. Pemrosesan pada perangkat menjamin privasi data medis.