Detección

🎯 ¿Qué es la detección de objetos?

La detección de objetos va un paso más allá de la clasificación. Mientras que un clasificador responde «¿qué hay en la imagen?», un detector responde «¿qué hay y dónde está?». Para cada objeto relevante en la imagen, el modelo produce:

• Una clase (persona, coche, perro…).
• Un bounding box — un rectángulo que enmarca al objeto.
• Una confianza (confidence score) de la predicción.

📦 Bounding boxes y representaciones

Un bounding box (bbox) se puede representar de varias formas. Las dos más comunes son:

Todos los valores suelen estar normalizados entre 0 y 1 respecto al tamaño de la imagen, facilitando el aprendizaje y la generalización a distintas resoluciones.

Anchor boxes

Muchos detectores (YOLO, SSD, Faster R-CNN) no predicen bounding boxes «desde cero». En su lugar, parten de anchor boxes: un conjunto de recuadros predefinidos con distintas proporciones (aspect ratios) distribuidos en una grid sobre la imagen. El modelo aprende a ajustar estos anchors — predice offsets (Δx, Δy, Δw, Δh) respecto al anchor más cercano.

Donde (c_x, c_y) es la posición de la celda de la grid, (p_w, p_h) son las dimensiones del anchor, y (t_x, t_y, t_w, t_h) son las predicciones del modelo.

📐 IoU y métricas de detección

Intersection over Union (IoU)

La métrica fundamental para evaluar la calidad de un bounding box es el IoU (también llamado Jaccard index): la razón entre el área de intersección y el área de unión de la predicción y el ground truth.

Non-Maximum Suppression (NMS)

Un detector suele generar múltiples bounding boxes solapados para el mismo objeto. NMS filtra los duplicados manteniendo solo la predicción con mayor confianza:

Métricas: Precision, Recall y mAP

Para evaluar un detector se usa la curva Precision-Recall y su área bajo la curva:

⚙️ Pipeline general de detección

Independientemente del modelo concreto, todo detector sigue un pipeline con tres etapas principales:

Componentes del pipeline

Two-stage vs. One-stage

Históricamente, los detectores se dividen en dos grandes familias según cómo generan las predicciones:

⚡ YOLO: You Only Look Once

YOLO (Redmon et al., 2016) revolucionó la detección de objetos con una idea radical: en lugar de recorrer la imagen múltiples veces buscando objetos, mirar la imagen completa una sola vez y predecir simultáneamente todas las bounding boxes y clases. Esto convirtió la detección en un problema de regresión directa, logrando velocidades de tiempo real por primera vez.

La idea fundamental

YOLO divide la imagen en una grid de S×S celdas. Cada celda es responsable de detectar los objetos cuyo centro cae dentro de ella. Para cada celda, el modelo predice:

• B bounding boxes, cada una con 5 valores: (x, y, w, h, \text{confidence})
• C probabilidades de clase condicionales

📈 Evolución de YOLO

Desde el YOLO original (v1, 2016) hasta las versiones actuales de Ultralytics, la familia YOLO ha atravesado una evolución extraordinaria, incorporando innovaciones de toda la comunidad:

🏗️ Arquitectura de YOLO moderno

Las versiones modernas de YOLO (v8, v11) comparten una arquitectura de tres componentes que ha convergido como el estándar de los detectores one-stage:

Innovaciones clave de YOLO moderno

Familia de modelos Ultralytics

🔄 Otras arquitecturas one-stage

Aunque YOLO domina el ecosistema, existen otros detectores one-stage relevantes con ideas complementarias:

SSD (Single Shot MultiBox Detector)

SSD (Liu et al., 2016) fue contemporáneo de YOLO y pionero en la detección multi-escala: aplica heads de detección en múltiples capas de features del backbone, cada una con resolución diferente. Los objetos grandes se detectan en capas profundas (baja resolución) y los pequeños en capas tempranas (alta resolución).

RetinaNet y Focal Loss

RetinaNet (Lin et al., 2017) identificó que el principal problema de los detectores one-stage no era la arquitectura sino el desbalance de clases: en una grid de detección, la inmensa mayoría de celdas son background (negativos fáciles) que dominan la loss. Su solución fue la Focal Loss:

El factor (1 - p_t)^\gamma reduce el peso de los ejemplos fáciles (alta p_t), concentrando el aprendizaje en los casos difíciles. Con \gamma = 2, RetinaNet superó a Faster R-CNN por primera vez desde un detector one-stage.

📍 Detección de landmarks y keypoints

Mientras que la detección de objetos localiza qué hay y dónde (bounding box), la detección de landmarks (o keypoints) va un paso más allá: identifica puntos anatómicos o estructurales precisos dentro del objeto — articulaciones del cuerpo, rasgos faciales, puntos de la mano, etc.

Dos enfoques principales

🤖 MediaPipe: detección en tiempo real

MediaPipe (Google) es un framework de ML para procesamiento de medios en tiempo real, diseñado para ejecutarse de forma eficiente en dispositivos móviles, navegadores y edge devices. Su suite de solutions incluye modelos de landmarks preentrenados de alto rendimiento.

Soluciones de landmarks de MediaPipe

Arquitectura de MediaPipe Pose

MediaPipe sigue un pipeline de dos etapas para lograr velocidad en tiempo real:

Otros frameworks de landmarks

🔬 Detectores two-stage (R-CNN family)

Antes de YOLO, la detección de objetos estaba dominada por los detectores two-stage: primero generan propuestas de regiones candidatas, y después clasifican y refinan cada propuesta individualmente. Aunque más lentos, durante años lograron la mayor precisión.

Evolución de la familia R-CNN

🎯 Detectores anchor-free

Los anchor boxes (cajas predefinidas de referencia) fueron centrales en los primeros detectores modernos, pero introducen hiperparámetros difíciles de ajustar. Los detectores anchor-free eliminan esta dependencia, prediciendo las bounding boxes de formas más directas.

CenterNet: detección como detección de puntos

CenterNet (Zhou et al., 2019) reformula la detección como un problema de detección del punto central del objeto. El modelo predice un heatmap de centros (como en landmark detection) y luego regresa el tamaño del bbox desde cada centro detectado:

• Sin anchors, sin NMS (el heatmap produce centros directamente)
• Simple y elegante — un solo backbone + 3 heads (heatmap, size, offset)
• Extensible a 3D detection, pose, tracking

FCOS: Fully Convolutional One-Stage detector

FCOS (Tian et al., 2019) predice, para cada posición del feature map, las 4 distancias al borde del bbox (l, t, r, b) más un score de centerness que indica qué tan centrado está el punto respecto al objeto:

El centerness penaliza predicciones lejos del centro del objeto, reduciendo detecciones de baja calidad sin necesidad de heurísticas complejas.

🔮 Detección con Transformers

Los transformers, originados en NLP, han revolucionado también la detección de objetos. El concepto clave es usar atención para modelar relaciones globales entre las features de la imagen y un conjunto de queries que aprenden a detectar objetos.

DETR: DEtection TRansformer

DETR (Carion et al., 2020, Meta AI) fue el primer detector basado en transformers. Su innovación radical: eliminar completamente anchors, NMS y todo el post-procesado heurístico, reemplazándolo con un enfoque puramente basado en conjuntos.

Evolución de DETR

Comparativa de paradigmas

💻 Código: Detección con Ultralytics YOLO

El ecosistema Ultralytics ofrece la API más sencilla para detección de objetos con modelos YOLO. A continuación, los casos de uso más comunes.

Instalación

# Instalación
pip install ultralytics

# Verificar instalación
yolo checks

Inferencia básica (detección de objetos)

from ultralytics import YOLO

# Cargar modelo preentrenado (descarga automática)
model = YOLO("yolo11n.pt")   # nano: rápido, ligero
# model = YOLO("yolo11s.pt") # small: balance
# model = YOLO("yolo11m.pt") # medium: producción

# Inferencia en una imagen
results = model("imagen.jpg")

# Procesar resultados
for result in results:
    boxes = result.boxes          # Bounding boxes
    for box in boxes:
        xyxy = box.xyxy[0]        # Coordenadas [x1, y1, x2, y2]
        conf = box.conf[0]        # Confianza
        cls  = box.cls[0]         # Índice de clase
        name = model.names[int(cls)]  # Nombre de clase

        print(f"{name}: {conf:.2f} en ({xyxy[0]:.0f}, {xyxy[1]:.0f}) → "
              f"({xyxy[2]:.0f}, {xyxy[3]:.0f})")

# Guardar imagen anotada
result.save("resultado.jpg")

Detección en vídeo y webcam

from ultralytics import YOLO

model = YOLO("yolo11n.pt")

# Detección en vídeo
results = model("video.mp4", stream=True)  # stream=True para uso eficiente de memoria
for result in results:
    annotated = result.plot()  # Frame con anotaciones dibujadas
    # cv2.imshow("YOLO", annotated)

# Detección en webcam (fuente 0)
results = model(source=0, show=True)

# Detección en stream RTSP
results = model("rtsp://192.168.1.100:554/stream")

Entrenamiento con dataset personalizado

from ultralytics import YOLO

# Cargar modelo preentrenado como base
model = YOLO("yolo11n.pt")

# Entrenar con dataset personalizado
# El archivo data.yaml define clases, paths de train/val
results = model.train(
    data="mi_dataset/data.yaml",
    epochs=100,
    imgsz=640,
    batch=16,
    patience=20,          # Early stopping
    lr0=0.01,             # Learning rate inicial
    augment=True,         # Augmentación automática
    device="cuda",        # GPU (o "cpu", "mps")
    project="runs/detect",
    name="mi_experimento"
)

# Evaluar en validation set
metrics = model.val()
print(f"mAP@50: {metrics.box.map50:.3f}")
print(f"mAP@50:95: {metrics.box.map:.3f}")

# mi_dataset/data.yaml
path: /ruta/a/mi_dataset
train: images/train
val: images/val
test: images/test

names:
  0: gato
  1: perro
  2: pajaro

Exportación del modelo

from ultralytics import YOLO

model = YOLO("runs/detect/mi_experimento/weights/best.pt")

# Exportar a diferentes formatos
model.export(format="onnx")       # ONNX (multiplataforma)
model.export(format="torchscript")# TorchScript (C++ deployment)
model.export(format="engine")     # TensorRT (NVIDIA, máxima velocidad)
model.export(format="coreml")     # CoreML (Apple)
model.export(format="tflite")     # TFLite (Android, Edge TPU)

# Inferencia con modelo exportado
onnx_model = YOLO("best.onnx")
results = onnx_model("imagen.jpg")

🤖 Código: Landmarks con MediaPipe

MediaPipe ofrece detección de landmarks ligera y eficiente. A continuación se muestran ejemplos para las tres tareas principales.

Instalación

pip install mediapipe opencv-python

Detección de pose (33 landmarks)

import cv2
import mediapipe as mp

mp_pose = mp.solutions.pose
mp_draw = mp.solutions.drawing_utils

# Inicializar detector de pose
with mp_pose.Pose(
    static_image_mode=False,        # False para vídeo (tracking)
    model_complexity=1,             # 0=lite, 1=full, 2=heavy
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5
) as pose:

    cap = cv2.VideoCapture(0)  # Webcam

    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        # Convertir BGR → RGB (MediaPipe usa RGB)
        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = pose.process(rgb)

        if results.pose_landmarks:
            # Dibujar landmarks y conexiones
            mp_draw.draw_landmarks(
                frame,
                results.pose_landmarks,
                mp_pose.POSE_CONNECTIONS
            )

            # Acceder a landmarks individuales
            landmarks = results.pose_landmarks.landmark
            nariz = landmarks[mp_pose.PoseLandmark.NOSE]
            print(f"Nariz: x={nariz.x:.3f}, y={nariz.y:.3f}, "
                  f"z={nariz.z:.3f}, vis={nariz.visibility:.2f}")

        cv2.imshow("Pose", frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()

Detección de manos (21 landmarks)

import cv2
import mediapipe as mp

mp_hands = mp.solutions.hands
mp_draw  = mp.solutions.drawing_utils

with mp_hands.Hands(
    static_image_mode=False,
    max_num_hands=2,
    min_detection_confidence=0.7,
    min_tracking_confidence=0.5
) as hands:

    cap = cv2.VideoCapture(0)
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = hands.process(rgb)

        if results.multi_hand_landmarks:
            for hand_landmarks in results.multi_hand_landmarks:
                # Dibujar landmarks
                mp_draw.draw_landmarks(
                    frame, hand_landmarks, mp_hands.HAND_CONNECTIONS
                )

                # Ejemplo: posición de la punta del índice
                index_tip = hand_landmarks.landmark[
                    mp_hands.HandLandmark.INDEX_FINGER_TIP
                ]
                h, w, _ = frame.shape
                px = int(index_tip.x * w)
                py = int(index_tip.y * h)
                cv2.circle(frame, (px, py), 8, (0, 255, 0), -1)

        cv2.imshow("Hands", frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    cap.release()

Face Mesh (478 landmarks)

import cv2
import mediapipe as mp

mp_face = mp.solutions.face_mesh
mp_draw = mp.solutions.drawing_utils
mp_styles = mp.solutions.drawing_styles

with mp_face.FaceMesh(
    static_image_mode=False,
    max_num_faces=1,
    refine_landmarks=True,    # Incluye iris (478 en total)
    min_detection_confidence=0.5,
    min_tracking_confidence=0.5
) as face_mesh:

    cap = cv2.VideoCapture(0)
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break

        rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = face_mesh.process(rgb)

        if results.multi_face_landmarks:
            for face_landmarks in results.multi_face_landmarks:
                # Dibujar malla facial
                mp_draw.draw_landmarks(
                    image=frame,
                    landmark_list=face_landmarks,
                    connections=mp_face.FACEMESH_TESSELATION,
                    landmark_drawing_spec=None,
                    connection_drawing_spec=mp_styles
                        .get_default_face_mesh_tesselation_style()
                )

        cv2.imshow("Face Mesh", frame)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    cap.release()

🔧 Detección con PyTorch y TensorFlow

Aunque Ultralytics y MediaPipe son las opciones más prácticas, entender cómo usar los frameworks base es valioso para proyectos personalizados.

PyTorch: detección con torchvision

import torch
import torchvision
from torchvision.models.detection import fasterrcnn_resnet50_fpn_v2
from torchvision.transforms import functional as F
from PIL import Image

# Cargar modelo preentrenado
model = fasterrcnn_resnet50_fpn_v2(
    weights=torchvision.models.detection
        .FasterRCNN_ResNet50_FPN_V2_Weights.DEFAULT
)
model.eval()

# Preprocesar imagen
image = Image.open("imagen.jpg")
tensor = F.to_tensor(image).unsqueeze(0)

# Inferencia
with torch.no_grad():
    predictions = model(tensor)[0]

# Filtrar por confianza
threshold = 0.5
for i, score in enumerate(predictions["scores"]):
    if score >= threshold:
        box   = predictions["boxes"][i].tolist()
        label = predictions["labels"][i].item()
        print(f"Clase {label}: {score:.2f} → {box}")

TensorFlow: TF Hub Object Detection

import tensorflow as tf
import tensorflow_hub as hub
import numpy as np
from PIL import Image

# Cargar modelo desde TF Hub
model = hub.load(
    "https://tfhub.dev/tensorflow/efficientdet/d0/1"
)

# Cargar y preprocesar imagen
image = Image.open("imagen.jpg")
image_np = np.array(image)
input_tensor = tf.convert_to_tensor(image_np)[tf.newaxis, ...]

# Inferencia
results = model(input_tensor)

# Extraer resultados
boxes  = results["detection_boxes"][0].numpy()    # [y1,x1,y2,x2] normalizado
scores = results["detection_scores"][0].numpy()
classes = results["detection_classes"][0].numpy().astype(int)

# Filtrar por confianza
threshold = 0.5
for i, score in enumerate(scores):
    if score >= threshold:
        y1, x1, y2, x2 = boxes[i]
        h, w = image_np.shape[:2]
        print(f"Clase {classes[i]}: {score:.2f} → "
              f"({int(x1*w)}, {int(y1*h)}) → ({int(x2*w)}, {int(y2*h)})")