Object Detection: qué es, algoritmos y cómo funciona

Qué es Object Detection: principio de funcionamiento

Object Detection resuelve dos tareas simultáneamente: qué hay en la imagen (clasificación) y dónde (regresión de coordenadas). El modelo divide la imagen en una cuadrícula, predice un bounding box (x, y, ancho, alto) y probabilidades de clase para cada celda. Non-Maximum Suppression (NMS) elimina los cuadros duplicados para un solo objeto, manteniendo la predicción más segura. Las arquitecturas modernas se dividen en two-stage (Faster R-CNN — primero propuestas de región, luego clasificación) y one-stage (YOLO, SSD — todo a la vez).

Métricas de evaluación: mAP (mean Average Precision) — la métrica principal de calidad de Object Detection. mAP@0.5 — precisión con umbral IoU de 0.5, mAP@0.5:0.95 — promedio en umbrales de 0.5 a 0.95. FPS — fotogramas por segundo (velocidad de inferencia). Para aplicaciones móviles, el equilibrio mAP/FPS es crítico: YOLOv8-Nano ofrece 42% mAP@0.5:0.95 a 50+ FPS, SSD MobileNet — 22% mAP a 60+ FPS. Para tiempo real > 20 FPS, para uso interactivo 5–15 FPS.

IoU (Intersection over Union) — una métrica de superposición entre el bounding box predicho y el real. IoU = área de intersección / área de unión. El umbral de IoU para NMS es típicamente 0.5–0.7. Para el seguimiento de objetos entre fotogramas (re-identificación), use Deep SORT o ByteTrack con emparejamiento IoU. Para contar objetos en video, BoT-SORT proporciona 85% MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — formas predefinidas de bounding box que el modelo ajusta. YOLOv8 utiliza detección sin anclas (anchor-free), lo que simplifica el entrenamiento y acelera la inferencia. SSD y YOLO antiguos requieren ajuste de anclas para cada conjunto de datos. Para el desarrollo móvil, las arquitecturas anchor-free (YOLOv8, FCOS) son preferibles — no dependen del tamaño de los objetos y son más fáciles de personalizar.

ML Kit Object Detection y Tracking

ML Kit Object Detection and Tracking — la biblioteca de Google para detección y seguimiento de objetos en el dispositivo. Admite dos modos: detector de imagen única (para fotos) y detector de streaming (para video). El modo Streaming rastrea automáticamente objetos entre fotogramas utilizando flujo óptico, reduciendo la latencia a 5–10 ms entre fotogramas después de la detección inicial. Categorías: fashion, food, home, places — 10–20 clases cada una.

API de ML Kit: ObjectDetector (opciones: detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). TrackingId permite rastrear el mismo objeto entre fotogramas. MultipleObjects = true — detecta hasta 5 objetos por fotograma. Classification — activa el reconocimiento de categoría de objeto (por defecto false para velocidad). El modo Streaming se recomienda para tiempo real: 20–30 FPS en 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: después de detectar un objeto en el primer fotograma, ML Kit lo rastrea a través del flujo de video sin redetección (basado en flujo óptico + seguimiento de características). Esto reduce la carga de CPU/GPU: detección inicial 30–60 ms, fotogramas de seguimiento posteriores 2–5 ms. Si el objeto sale del fotograma o gira > 30°, el rastreador se reinicia y requiere redetección. TrackingId persiste mientras el objeto esté en el fotograma. Para contar objetos únicos, use trackingId como identificador.

YOLO: You Only Look Once en dispositivos móviles

YOLOv8-Nano — la versión más pequeña de YOLOv8 (Ultralytics) para dispositivos periféricos. 2.6M parámetros, 5.9 MB (FP16), 42% mAP@0.5:0.95 en COCO. YOLOv8 utiliza detección anchor-free + backbone C2f + TaskAlignedAssigner para emparejamiento de predicciones. Para el desarrollo móvil, está disponible la exportación a TFLite (INT8 — 2.0 MB, latencia 8–20 ms) y Core ML (4.5 MB, latencia 5–15 ms en iPhone 15 Pro). YOLOv8-Nano es la mejor opción para Object Detection en tiempo real en el dispositivo.

Exportación de YOLOv8 a TFLite: Ultralytics proporciona CLI: yolo export model=yolov8n.pt format=tflite int8. El resultado es un modelo TFLite INT8 optimizado para GPU Delegate a través de NNAPI. Para conjuntos de datos personalizados (clases propias, no COCO) — entrenamiento a través de Ultralytics HUB en 50–500 imágenes por clase. RT-DETR (Real-Time Detection Transformer) — una alternativa basada en arquitectura Transformer, 48% mAP a 60 FPS en NVIDIA Jetson, pero para dispositivos móviles todavía va por detrás de YOLOv8-Nano en velocidad.

# 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 en dispositivos móviles: ML Kit Object Detection es más fácil de integrar (10 líneas de código), no requiere experiencia en ML, pero está limitado a clases estándar (fashion, food, home, places). YOLOv8-Nano requiere exportación personalizada pero proporciona control total: cualquier clase, tamaño de entrada, arquitectura. Para prototipado rápido — ML Kit. Para producción con objetos no estándar — YOLOv8-Nano. Para iOS: YOLOv8-Core ML mediante exportación de modelo desde Ultralytics + VNCoreMLRequest.

SSD y otras arquitecturas en el dispositivo

SSD (Single Shot Multibox Detector) — una arquitectura one-stage clásica para dispositivos móviles. SSD MobileNetV2 — el estándar de facto en 2020–2023: 22% mAP@0.5:0.95 en COCO, 15–40 ms en Pixel 6. SSD utiliza una pirámide de características (diferentes capas de MobileNet para detectar objetos de varios tamaños) y default boxes (anchor boxes) para cada celda del mapa de características. Ventajas: velocidad máxima para su época. Desventajas: baja precisión en objetos pequeños (10–30 px).

EfficientDet-Lite — una familia de Google (2020+), optimizada para TFLite. EfficientDet-Lite0: 3.9M parámetros, 35% mAP, 20–50 ms. EfficientDet-Lite2: 8.1M, 42% mAP, 40–80 ms. EfficientDet utiliza BiFPN (Bidirectional Feature Pyramid Network) para fusión de características multiescala — esto proporciona una ganancia del 2–4% mAP sin aumentar la latencia. Para el desarrollo móvil, Google recomienda EfficientDet-Lite como detector principal para TFLite Task Vision.

MediaPipe Object Detector — una implementación lista para usar basada en EfficientDet-Lite como parte de MediaPipe Tasks Vision. Proporciona una API unificada para Android, iOS, Python, Web. MediaPipe Object Detector admite clases COCO (80 clases), modelos personalizados, modo streaming y delegados de CPU/GPU. Para la integración rápida de Object Detection en un proyecto multiplataforma, MediaPipe es la opción óptima: un código para todas las plataformas.

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

Elección de arquitectura para una aplicación móvil: para > 30 FPS en dispositivos de gama media — YOLOv8-Nano (INT8) o SSD MobileNetV2. Para precisión > 40% mAP — YOLOv8-Small (11.2M) o EfficientDet-Lite2 (8.1M). Para multiplataforma — MediaPipe Object Detector. Para simplicidad — ML Kit. Para iOS-first — Core ML + YOLOv8 .mlpackage. Para Android-first — TFLite Task Vision (ObjectDetector API). Entrenamiento: Roboflow (conjunto de datos) + Ultralytics YOLOv8 (entrenamiento) + exportación a TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — una API unificada de Google para ejecutar modelos de Object Detection en Android e iOS. Task API maneja automáticamente el preprocesamiento de imágenes (escalado, normalización, conversión de espacio de color) y el posprocesamiento (NMS, umbralización). El desarrollador solo necesita pasar un modelo .tflite y recibir una lista de Detections con bounding box + categoría + puntuación. Task API admite modelos compatibles con COCO (80 clases).

Conversión de un modelo personalizado a Task API: el modelo TFLite debe tener entrada [1, height, width, 3] (float32/uint8) y salida: detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1]. Exportación desde TensorFlow Object Detection API con operaciones de posprocesamiento incluidas (SSD Postprocess). Para YOLOv8 — exportación TFLite con NMS mediante ops-compat. Task API en iOS utiliza Core ML Delegate para aceleración en 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
    )
}

Rendimiento de Task API: GPU Delegate en Android proporciona una aceleración de 3–5x en comparación con CPU (XNNPACK). NNAPI Delegate — otros 1.5–2x en dispositivos con NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — hasta 10x en aceleradores DSP. Para iOS, Core ML Delegate — 4–6x frente a CPU. Task API selecciona automáticamente el acelerador de hardware disponible, pero se puede forzar un delegado a través de DetectorOptions.

Aplicaciones de Object Detection en aplicaciones móviles

Conteo de personas y objetos — análisis minorista: detección de visitantes en una tienda, conteo de colas, determinación de niveles de existencias en estantes. Un contador de personas Object Detection en un fotograma ayuda a estimar el tráfico peatonal y la conversión. ML Kit Object Detector ofrece hasta 30 FPS — suficiente para conteo en tiempo real. Para cruce de zonas — una combinación de Object Detection + seguimiento ByteTrack. Precisión de conteo: 92–95% en buenas condiciones de iluminación.

Detección de defectos en fabricación — Object Detection identifica defectos en una cinta transportadora: rayones, astillas, grietas, ensamblaje incorrecto. Un modelo YOLOv8-Nano (INT8) personalizado se ejecuta en una tableta Android conectada a una cámara USB. Latencia: 20–40 ms por fotograma (25–50 FPS). Para defectos complejos (microgrietas) — aumente la resolución de entrada a 640x640 (latencia 40–80 ms). Entrenamiento: Roboflow — conjunto de datos de 200–1000 imágenes de defectos + Ultralytics YOLOv8.

Marcado de objetos AR en tiempo real — ARCore (Android) y ARKit (iOS) utilizan Object Detection para reconocer superficies planas, planos verticales y objetos 3D. ML Kit Object Detection + ARCore Scene Semantics proporciona segmentación de objetos: pared, suelo, techo, muebles. Para marcado AR personalizado (por ejemplo, reconocer un modelo específico de sofá y superponer información AR) — YOLOv8-Nano + SceneKit/SceneForm. Requisito de tiempo real: > 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))
    }
}

Imágenes médicas — Object Detection para analizar radiografías, resonancias magnéticas, tomografías computarizadas. Detección de tumores, fracturas, patologías en el dispositivo móvil de un médico. YOLOv8-Nano en una tableta Android detecta nódulos pulmonares en 15–30 ms con una sensibilidad del 89% y una especificidad del 93% (datos de NIH ChestX-ray14). Requisitos: cuantificación INT8 (privacidad de datos), high recall (omitir una patología es más peligroso que un falso positivo), umbral de confianza < 0.4. El procesamiento en el dispositivo garantiza la privacidad de los datos médicos.