Object Detection: o que é, algoritmos e como funciona

O que é Object Detection: princípio de funcionamento

Object Detection resolve duas tarefas simultaneamente: o que está na imagem (classificação) e onde (regressão de coordenadas). O modelo divide a imagem em uma grade, prevê uma bounding box (x, y, largura, altura) e probabilidades de classe para cada célula. A Non-Maximum Suppression (NMS) remove caixas duplicadas para um único objeto, mantendo a previsão mais confiante. As arquiteturas modernas são divididas em two-stage (Faster R-CNN — primeiro propostas de região, depois classificação) e one-stage (YOLO, SSD — tudo de uma vez).

Métricas de avaliação: mAP (mean Average Precision) — a principal métrica de qualidade do Object Detection. mAP@0.5 — precisão no limiar IoU de 0.5, mAP@0.5:0.95 — média entre limiares de 0.5 a 0.95. FPS — quadros por segundo (velocidade de inferência). Para aplicativos móveis, o equilíbrio mAP/FPS é crítico: YOLOv8-Nano oferece 42% mAP@0.5:0.95 a 50+ FPS, SSD MobileNet — 22% mAP a 60+ FPS. Para tempo real > 20 FPS, para uso interativo 5–15 FPS.

IoU (Intersection over Union) — uma métrica de sobreposição entre a bounding box prevista e a real. IoU = área de interseção / área de união. O limiar de IoU para NMS é tipicamente 0.5–0.7. Para rastreamento de objetos entre quadros (reidentificação), use Deep SORT ou ByteTrack com correspondência IoU. Para contagem de objetos em vídeo, o BoT-SORT fornece 85% MOTA (Multiple Object Tracking Accuracy).

Anchor Boxes — formatos predefinidos de bounding box que o modelo ajusta. O YOLOv8 usa detecção sem âncoras (anchor-free), o que simplifica o treinamento e acelera a inferência. SSD e YOLO antigos exigem ajuste de âncoras para cada conjunto de dados. Para desenvolvimento mobile, arquiteturas anchor-free (YOLOv8, FCOS) são preferíveis — não dependem do tamanho dos objetos e são mais fáceis de personalizar.

ML Kit Object Detection e Tracking

ML Kit Object Detection and Tracking — a biblioteca do Google para detecção e rastreamento de objetos no dispositivo. Suporta dois modos: detector de imagem única (para fotos) e detector de streaming (para vídeo). O modo Streaming rastreia automaticamente objetos entre quadros usando fluxo óptico, reduzindo a latência para 5–10 ms entre quadros após a detecção inicial. Categorias: fashion, food, home, places — 10–20 classes cada.

API do ML Kit: ObjectDetector (opções: detectorMode, enableClassification, enableMultipleObjects) → InputImage → DetectedObject (trackingId, boundingBox, classificationCategory, classificationConfidence). O trackingId permite rastrear o mesmo objeto entre quadros. MultipleObjects = true — detecta até 5 objetos por quadro. Classification — ativa o reconhecimento de categoria do objeto (padrão false para velocidade). O modo Streaming é recomendado para tempo real: 20–30 FPS no 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: após detectar um objeto no primeiro quadro, o ML Kit o rastreia pelo fluxo de vídeo sem redetecção (baseado em fluxo óptico + rastreamento de características). Isso reduz a carga de CPU/GPU: detecção inicial 30–60 ms, quadros de rastreamento subsequentes 2–5 ms. Se o objeto sair do quadro ou girar > 30°, o rastreador é reiniciado e requer redetecção. O trackingId persiste enquanto o objeto estiver no quadro. Para contar objetos únicos, use trackingId como identificador.

YOLO: You Only Look Once em dispositivos móveis

YOLOv8-Nano — a menor versão do YOLOv8 (Ultralytics) para dispositivos de borda. 2.6M parâmetros, 5.9 MB (FP16), 42% mAP@0.5:0.95 no COCO. O YOLOv8 usa detecção anchor-free + backbone C2f + TaskAlignedAssigner para correspondência de previsões. Para desenvolvimento mobile, a exportação está disponível para TFLite (INT8 — 2.0 MB, latência 8–20 ms) e Core ML (4.5 MB, latência 5–15 ms no iPhone 15 Pro). O YOLOv8-Nano é a melhor escolha para Object Detection em tempo real no dispositivo.

Exportação do YOLOv8 para TFLite: a Ultralytics fornece CLI: yolo export model=yolov8n.pt format=tflite int8. A saída é um modelo TFLite INT8 otimizado para GPU Delegate via NNAPI. Para conjuntos de dados personalizados (suas próprias classes, não COCO) — treinamento via Ultralytics HUB em 50–500 imagens por classe. RT-DETR (Real-Time Detection Transformer) — uma alternativa baseada na arquitetura Transformer, 48% mAP a 60 FPS no NVIDIA Jetson, mas para dispositivos móveis ainda fica atrás do YOLOv8-Nano em velocidade.

# 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 em dispositivos móveis: o ML Kit Object Detection é mais fácil de integrar (10 linhas de código), não requer experiência em ML, mas é limitado a classes padrão (fashion, food, home, places). O YOLOv8-Nano requer exportação personalizada, mas fornece controle total: qualquer classe, tamanho de entrada, arquitetura. Para prototipagem rápida — ML Kit. Para produção com objetos não padronizados — YOLOv8-Nano. Para iOS: YOLOv8-Core ML via exportação de modelo da Ultralytics + VNCoreMLRequest.

SSD e outras arquiteturas no dispositivo

SSD (Single Shot Multibox Detector) — uma arquitetura one-stage clássica para dispositivos móveis. SSD MobileNetV2 — o padrão de facto em 2020–2023: 22% mAP@0.5:0.95 no COCO, 15–40 ms no Pixel 6. O SSD usa uma pirâmide de características (diferentes camadas do MobileNet para detectar objetos de vários tamanhos) e default boxes (anchor boxes) para cada célula do mapa de características. Vantagens: velocidade máxima para sua época. Desvantagens: baixa precisão em objetos pequenos (10–30 px).

EfficientDet-Lite — uma família do Google (2020+), otimizada para TFLite. EfficientDet-Lite0: 3.9M parâmetros, 35% mAP, 20–50 ms. EfficientDet-Lite2: 8.1M, 42% mAP, 40–80 ms. O EfficientDet usa BiFPN (Bidirectional Feature Pyramid Network) para fusão de características multiescala — isso proporciona um ganho de 2–4% mAP sem aumentar a latência. Para desenvolvimento mobile, o Google recomenda o EfficientDet-Lite como detector principal para TFLite Task Vision.

MediaPipe Object Detector — uma implementação pronta baseada em EfficientDet-Lite como parte do MediaPipe Tasks Vision. Fornece uma API unificada para Android, iOS, Python, Web. O MediaPipe Object Detector suporta classes COCO (80 classes), modelos personalizados, modo streaming e delegados CPU/GPU. Para integração rápida de Object Detection em um projeto multiplataforma, o MediaPipe é a escolha ideal: um código para todas as 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()
}

Escolhendo uma arquitetura para um aplicativo móvel: para > 30 FPS em dispositivos de gama média — YOLOv8-Nano (INT8) ou SSD MobileNetV2. Para precisão > 40% mAP — YOLOv8-Small (11.2M) ou EfficientDet-Lite2 (8.1M). Para multiplataforma — MediaPipe Object Detector. Para simplicidade — ML Kit. Para iOS-first — Core ML + YOLOv8 .mlpackage. Para Android-first — TFLite Task Vision (ObjectDetector API). Treinamento: Roboflow (conjunto de dados) + Ultralytics YOLOv8 (treinamento) + exportação para TFLite/Core ML.

TensorFlow Lite Task Vision API

TFLite Task Vision ObjectDetector — uma API unificada do Google para executar modelos de Object Detection no Android e iOS. A Task API lida automaticamente com o pré-processamento de imagem (dimensionamento, normalização, conversão de espaço de cor) e pós-processamento (NMS, limiarização). O desenvolvedor só precisa passar um modelo .tflite e receber uma lista de Detections com bounding box + categoria + pontuação. A Task API suporta modelos compatíveis com COCO (80 classes).

Convertendo um modelo personalizado para a Task API: o modelo TFLite deve ter entrada [1, height, width, 3] (float32/uint8) e saída: detection_boxes[1,N,4], detection_classes[1,N], detection_scores[1,N], num_detections[1]. Exportação da TensorFlow Object Detection API com operações de pós-processamento incluídas (SSD Postprocess). Para YOLOv8 — exportação TFLite com NMS via ops-compat. A Task API no iOS usa o Core ML Delegate para aceleração 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
    )
}

Desempenho da Task API: o GPU Delegate no Android fornece aceleração de 3–5x em comparação com a CPU (XNNPACK). O NNAPI Delegate — mais 1.5–2x em dispositivos com NPU (Pixel 8, Snapdragon 8 Gen 3, Dimensity 9300). Hexagon, DSP — até 10x em aceleradores DSP. Para iOS, o Core ML Delegate — 4–6x contra CPU. A Task API seleciona automaticamente o acelerador de hardware disponível, mas é possível forçar um delegado via DetectorOptions.

Aplicações de Object Detection em aplicativos móveis

Contagem de pessoas e objetos — análise de varejo: detecção de visitantes em uma loja, contagem de filas, determinação de níveis de estoque em prateleiras. Um contador de pessoas Object Detection em um quadro ajuda a estimar o tráfego de pedestres e a conversão. O ML Kit Object Detector oferece até 30 FPS — suficiente para contagem em tempo real. Para cruzamento de zonas — uma combinação de Object Detection + rastreamento ByteTrack. Precisão de contagem: 92–95% em boas condições de iluminação.

Detecção de defeitos na fabricação — o Object Detection identifica defeitos em uma esteira: arranhões, lascas, rachaduras, montagem incorreta. Um modelo YOLOv8-Nano (INT8) personalizado é executado em um tablet Android conectado a uma câmera USB. Latência: 20–40 ms por quadro (25–50 FPS). Para defeitos complexos (microtrincas) — aumente a resolução de entrada para 640x640 (latência 40–80 ms). Treinamento: Roboflow — conjunto de dados de 200–1000 imagens de defeitos + Ultralytics YOLOv8.

Marcação AR de objetos em tempo real — ARCore (Android) e ARKit (iOS) usam Object Detection para reconhecer superfícies planas, planos verticais e objetos 3D. ML Kit Object Detection + ARCore Scene Semantics fornece segmentação de objetos: parede, piso, teto, móveis. Para marcação AR personalizada (por exemplo, reconhecer um modelo específico de sofá e sobrepor informações AR) — YOLOv8-Nano + SceneKit/SceneForm. Requisito de tempo 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))
    }
}

Imagens médicas — Object Detection para analisar radiografias, ressonâncias magnéticas, tomografias computadorizadas. Detecção de tumores, fraturas, patologias no dispositivo móvel de um médico. O YOLOv8-Nano em um tablet Android detecta nódulos pulmonares em 15–30 ms com 89% de sensibilidade e 93% de especificidade (dados NIH ChestX-ray14). Requisitos: quantização INT8 (privacidade de dados), alta revocação (perder uma patologia é mais perigoso que um falso positivo), limite de confiança < 0.4. O processamento no dispositivo garante a privacidade dos dados médicos.