🔍 Detectar objetos con YOLO26

Un detector de objetos recibe una imagen y devuelve una lista: para cada cosa que reconoció, una caja (dónde está), una clase (qué es) y una confianza (de 0 a 1, cuánto cree el modelo en eso). YOLO ("you only look once") hace esto mirando la imagen una sola vez; por eso es lo bastante rápido para los robots. Los modelos listos de Ultralytics ya reconocen las 80 clases del conjunto COCO, como persona, auto, perro, botella y silla.

Cómo leer: cada caja de color es un objeto encontrado, con la etiqueta "clase confianza". El recuadro morado de la derecha es lo que llega a tu programa para la persona: solo números. La botella tiene menor confianza (0,67) porque es pequeña y está parcialmente oscura; ahí es donde aparecen los errores (tema 6).

Por qué aprender

La máscara de color falla con objetos de colores comunes o cuando cambia la luz. El detector reconoce la forma, así que sigue a una persona con una camiseta de cualquier color. A cambio, requiere mucho más procesamiento. Saber qué significa cada salida es lo que te permite usarla para controlar el robot.

Conceptos clave

O YOLO26 es la generación actual de la familia YOLO de Ultralytics, sucesora de YOLO11. Aún circulan tutoriales con versiones antiguas, pero hoy se usa el paquete ultralytics con los pesos yolo26n.pt. Viene en tamaños n, s, m, l e x: cada nivel mejora un poco la precisión y funciona mucho más lento. En Pi 5, empieza siempre por el n. En PyTorch, con una imagen de 640 px, tarda alrededor de 130 ms por cuadro; es decir, como máximo, cerca de 7 cuadros por segundo.

Cómo leer: cada nivel corresponde a un tamaño de YOLO26. La "n", resaltada, es la única que permite que el robot reaccione a tiempo usando solo el procesador de la Pi. Los tamaños mayores sirven para hacer comparaciones en la PC o para ejecutarlos con un acelerador.

Objetivo: instalar Ultralytics en el venv y detectar objetos en vivo con la cámara, mostrando la clase, la confianza y el tiempo de cada cuadro. La instalación descarga bastantes cosas: usa una tarjeta con espacio libre y ten paciencia.

source ~/robo-venv/bin/activate
pip install ultralytics                        # instala también PyTorch para ARM
yolo predict model=yolo26n.pt source="https://ultralytics.com/images/bus.jpg"   # prueba rápida

# YOLO26 en vivo con Camera Module 3: muestra lo que ve y el tiempo de cada cuadro
import sys, time
from picamera2 import Picamera2
from ultralytics import YOLO

MODELO = sys.argv[1] if len(sys.argv) > 1 else "yolo26n.pt"   # cámbialo por NCNN en el tema 3
modelo = YOLO(MODELO)

picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(main={"size": (640, 480), "format": "RGB888"}))
picam2.start(); time.sleep(1)
print(f"Modelo {MODELO} cargado. Ctrl+C para salir.")
try:
    while True:
        quadro = picam2.capture_array()                 # BGR, como lo espera Ultralytics
        t0 = time.perf_counter()
        r = modelo(quadro, imgsz=640, conf=0.5, verbose=False)[0]
        ms = (time.perf_counter() - t0) * 1000
        achados = [f"{r.names[int(c)]} {float(p):.2f}" for c, p in zip(r.boxes.cls, r.boxes.conf)]
        print(f"{ms:6.0f} ms | {1000 / ms:4.1f} FPS | {', '.join(achados) or 'nada'}")
except KeyboardInterrupt:
    picam2.stop()

Por qué aprender

Con unas veinte líneas tienes un robot que reconoce personas y objetos cotidianos. Ese mismo ciclo (capturar, inferir, leer las cajas) es la base del proyecto 3.6 y vuelve a aparecer en la Trilha 5, cuando el brazo necesita encontrar el objeto antes de recogerlo.

Conceptos clave

El formato .pt es excelente para entrenar, pero no es el más rápido para ejecutarse en un procesador ARM. Ultralytics exporta el mismo modelo a otros formatos; según la guía oficial para Raspberry Pi, NCNN es el más rápido en la CPU de la Pi. Las cajas y las clases siguen siendo las mismas; solo cambia el "motor" que hace los cálculos. La otra opción es cambiar el tamaño de entrada: imgsz=320 procesa una cuarta parte de los píxeles que 640 y pierde precisión con objetos pequeños.

Cómo leer: solo la barra superior tiene un número de referencia (la guía de Ultralytics para Pi 5). Las demás muestran la dirección de la mejora; para saber el valor exacto, ejecuta el script de abajo en tu Pi, con tu cooler y tu cámara.

Objetivo: exportar yolo26n a NCNN y comparar los dos formatos en la misma imagen, con números.

cd ~/robo && source ~/robo-venv/bin/activate
yolo export model=yolo26n.pt format=ncnn       # crea la carpeta yolo26n_ncnn_model/
python yolo_camera.py yolo26n_ncnn_model       # el mismo script del tema 2, ahora con NCNN

# Compara PyTorch x NCNN (640 y 320) en la misma imagen: promedio de 20 inferencias
import time
from ultralytics import YOLO

IMAGEM = "https://ultralytics.com/images/bus.jpg"   # o la ruta de una foto tuya
testes = [("yolo26n.pt", 640), ("yolo26n_ncnn_model", 640), ("yolo26n_ncnn_model", 320)]

for caminho, tamanho in testes:
    modelo = YOLO(caminho, task="detect")
    for _ in range(3):                              # calentamiento: no cuenta
        modelo(IMAGEM, imgsz=tamanho, verbose=False)
    tempos = []
    for _ in range(20):
        r = modelo(IMAGEM, imgsz=tamanho, verbose=False)[0]
        tempos.append(r.speed["inference"])           # ms, solo la red
    media = sum(tempos) / len(tempos)
    print(f"{caminho:22s} imgsz={tamanho}: {media:6.1f} ms  ({1000 / media:4.1f} FPS)  objetos={len(r.boxes)}")

Por qué aprender

Duplicar los FPS sin gastar nada marca la diferencia entre un robot que sigue a la persona y uno que la pierde en cada curva. Y el hábito de medir antes y después sirve para cualquier optimización que hagas de aquí en adelante.

Conceptos clave

Cuando NCNN e imgsz no son suficientes, el siguiente paso es sacar la red neuronal del procesador. La AI HAT+ es una placa que se coloca sobre la Pi 5 y se conecta mediante el conector PCIe; lleva un chip Hailo diseñado exclusivamente para inferencia. Hay dos generaciones: AI HAT+ con Hailo-8L (13 TOPS) o Hailo-8 (26 TOPS), orientado a la visión, y AI HAT+ 2 con Hailo-10H (40 TOPS en INT4) y 8 GB de memoria propia, que también ejecuta modelos pequeños de lenguaje y de visión-lenguaje. Ambos funcionan solo con Pi 5; el antiguo «AI Kit» dejó de fabricarse.

Cómo leer: a la izquierda, la CPU realiza las tres tareas y la del medio (roja) domina. A la derecha, la parte pesada se envía a la NPU por PCIe y solo vuelve el resultado. La CPU queda libre para el resto del robot: servidor de video, comunicación con el ESP32, registros.

Paso a paso (visión general)

lspci | grep -i hailo        # ¿aparece la placa en el bus PCIe?
vcgencmd get_throttled       # 0x0: la fuente de alimentación puede con el conjunto Pi + HAT + cámara

Por qué aprender

El acelerador no es obligatorio para esta ruta: el proyecto 3.6 funciona con CPU y NCNN. Pero entender cuándo conviene (muchos objetos, FPS alto, IA de lenguaje en el mismo robot) evita comprarlo demasiado pronto o insistir demasiado tiempo con la CPU.

Conceptos clave

COCO no tiene «mi taza», «cono naranja de la pista» o «pieza de la competencia». Para eso, haces un ajuste fino: partes de yolo26n, que ya sabe reconocer formas, y le muestras unos cientos de fotos tuyas con las cajas marcadas. El entrenamiento se ejecuta en una PC con GPU NVIDIA o en Google Colab (GPU gratuita en el navegador); la Pi solo recibe el resultado listo. Entrenar en la Pi funciona, pero es demasiado lento como para que valga la pena.

Cómo leer: los pasos morados ocurren fuera del robot; el cian es el robot usando el modelo. El retorno con línea discontinua es el secreto: el primer modelo siempre se equivoca en algún caso, y cada error fotografiado y etiquetado mejora el siguiente entrenamiento.

Paso a paso

Objetivo: describir el dataset y entrenar un detector de dos clases a partir de yolo26n. Cambia la ruta y los nombres de las clases por los tuyos.

# Estructura esperada:
#   mi_dataset/images/train/*.jpg   mi_dataset/labels/train/*.txt
#   mi_dataset/images/val/*.jpg     mi_dataset/labels/val/*.txt
path: /caminho/para/meu_dataset
train: images/train
val: images/val
names:
  0: caneca
  1: cone

pip install ultralytics
yolo detect train data=meu_dataset/data.yaml model=yolo26n.pt epochs=100 imgsz=640 batch=16
# al final: runs/detect/train/weights/best.pt  (el mejor modelo en la validación)
yolo detect val model=runs/detect/train/weights/best.pt data=meu_dataset/data.yaml

# después, en el Pi:
# scp best.pt <tu_usuario>@robo.local:~/robo/
# yolo export model=best.pt format=ncnn   →   python yolo_camera.py best_ncnn_model

Por qué aprender

Aquí es donde la visión del robot empieza a servir a tu proyecto, y no al revés: competencias, separación de piezas, un robot que busca un objeto específico. Y el proceso (recopilar, etiquetar, entrenar, probar, volver) es el mismo que usas en la Ruta 5 para enseñar el brazo mediante demostraciones.

Conceptos clave

Un detector no "ve" como tú: hace una predicción estadística en cada cuadro. Con poca luz, el objeto se ve oscuro y borroso; de lejos, ocupa pocos píxeles después del redimensionamiento; y a veces una mochila se convierte en "persona" durante un cuadro. El umbral de confianza es el botón que controlas: si está demasiado alto, el robot pierde el objetivo; si está demasiado bajo, persigue fantasmas. Por eso el código del robot nunca reacciona a un solo cuadro.

Cómo leer: la escala es el valor de conf. A la izquierda (rojo), el robot reacciona a todo; a la derecha (cian), solo a objetos muy nítidos. El marco morado es un punto de partida razonable, que se vuelve mucho más estable cuando exiges que el objeto aparezca en algunos cuadros seguidos.

Objetivo: convertir las detecciones sin procesar en una decisión estable: solo la clase que interesa, solo cajas lo bastante grandes y solo después de 3 cuadros seguidos. El resultado es el error horizontal, igual que el del módulo 3.2.

# Decisión estable a partir de YOLO26: clase, tamaño mínimo y persistencia
import time
from picamera2 import Picamera2
from ultralytics import YOLO

ALVO = "person"          # nombre de la clase en el modelo (COCO usa nombres en inglés)
CONF_MIN = 0.5
AREA_MIN = 0.02          # la caja ocupa al menos el 2% de la imagen
QUADROS_SEGUIDOS = 3
LARGURA, ALTURA = 640, 480

modelo = YOLO("yolo26n_ncnn_model", task="detect")
picam2 = Picamera2()
picam2.configure(picam2.create_preview_configuration(main={"size": (LARGURA, ALTURA), "format": "RGB888"}))
picam2.start(); time.sleep(1)
contador = 0
try:
    while True:
        r = modelo(picam2.capture_array(), imgsz=640, conf=CONF_MIN, verbose=False)[0]
        melhor = None
        for (x1, y1, x2, y2), c in zip(r.boxes.xyxy.tolist(), r.boxes.cls.tolist()):
            area = (x2 - x1) * (y2 - y1) / (LARGURA * ALTURA)
            if r.names[int(c)] == ALVO and area >= AREA_MIN:
                if melhor is None or area > melhor[1]:
                    melhor = ((x1 + x2) / 2, area)          # centro x y tamaño
        contador = contador + 1 if melhor else 0
        if contador >= QUADROS_SEGUIDOS:
            cx, area = melhor
            print(f"OBJETIVO firme  error={cx - LARGURA / 2:+5.0f}  tamaño={area:.2f}")
        else:
            print(f"sin objetivo firme ({contador}/{QUADROS_SEGUIDOS}) → robot detenido")
except KeyboardInterrupt:
    picam2.stop()

Por qué aprender

El robot que sigue a una persona es el proyecto de la ruta, y solo es seguro si sabes dónde falla la visión. El umbral, el tamaño mínimo, la persistencia y la detención cuando se pierde el objetivo son las cuatro protecciones que separan una demostración bonita de un robot confiable.

Conceptos clave