🔍 Detectar objetos com YOLO26

Um detector de objetos recebe uma imagem e devolve uma lista: para cada coisa que reconheceu, uma caixa (onde está), uma classe (o que é) e uma confiança (de 0 a 1, o quanto o modelo acredita naquilo). O YOLO ("you only look once") faz isso olhando a imagem uma vez só, por isso é rápido o bastante para robôs. Os modelos prontos da Ultralytics já reconhecem as 80 classes do conjunto COCO, como pessoa, carro, cachorro, garrafa e cadeira.

Como ler: cada caixa colorida é um objeto encontrado, com a etiqueta "classe confiança". O quadro roxo à direita é o que chega ao seu programa para a pessoa: só números. A garrafa tem confiança menor (0,67) porque está pequena e parcialmente escura; é aí que surgem os erros (tópico 6).

Por que aprender

A máscara de cor falha com objetos de cor comum ou quando a luz muda. O detector reconhece a forma, então segue uma pessoa de camiseta de qualquer cor. Em troca, gasta muito mais processamento. Saber o que cada saída significa é o que permite usá-la no controle do robô.

Conceitos-chave

O YOLO26 é a geração atual da família YOLO da Ultralytics, sucessora do YOLO11. Tutoriais com versões antigas ainda circulam, mas o caminho de hoje é o pacote ultralytics com os pesos yolo26n.pt. Ele vem em tamanhos n, s, m, l e x: cada degrau acerta um pouco mais e roda bem mais devagar. No Pi 5, comece sempre pelo n. Em PyTorch, com imagem de 640 px, ele leva na ordem de 130 ms por quadro, ou seja, perto de 7 quadros por segundo no máximo.

Como ler: cada degrau é um tamanho do YOLO26. O "n", em destaque, é o único que mantém o robô reagindo em tempo útil só com o processador do Pi. Os maiores servem para treinar comparações no PC ou para rodar com acelerador.

Objetivo: instalar a Ultralytics no venv e detectar objetos ao vivo pela câmera, imprimindo classe, confiança e tempo de cada quadro. A instalação baixa bastante coisa: use cartão com espaço livre e paciência.

source ~/robo-venv/bin/activate
pip install ultralytics                        # instala também o PyTorch para ARM
yolo predict model=yolo26n.pt source="https://ultralytics.com/images/bus.jpg"   # teste rápido

# YOLO26 ao vivo na Camera Module 3: imprime o que vê e o tempo de cada quadro
import sys, time
from picamera2 import Picamera2
from ultralytics import YOLO

MODELO = sys.argv[1] if len(sys.argv) > 1 else "yolo26n.pt"   # troque pelo NCNN no tópico 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} carregado. Ctrl+C para sair.")
try:
    while True:
        quadro = picam2.capture_array()                 # BGR, como a Ultralytics espera
        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 que aprender

Com umas vinte linhas você tem um robô que reconhece pessoas e objetos do dia a dia. Esse mesmo laço (capturar, inferir, ler as caixas) é a base do projeto 3.6 e reaparece na Trilha 5, quando o braço precisa achar o objeto antes de pegar.

Conceitos-chave

O formato .pt é ótimo para treinar, mas não é o mais rápido para rodar num processador ARM. A Ultralytics exporta o mesmo modelo para outros formatos; segundo o guia oficial para Raspberry Pi, o NCNN é o mais rápido na CPU do Pi. As caixas e classes continuam as mesmas; muda só o "motor" que faz as contas. A outra alavanca é o tamanho de entrada: imgsz=320 processa um quarto dos pixels de 640, e perde precisão em objetos pequenos.

Como ler: só a barra de cima tem número de referência (o guia da Ultralytics para o Pi 5). As outras mostram a direção do ganho; o tamanho exato você descobre rodando o script abaixo no seu Pi, com o seu cooler e a sua câmera.

Objetivo: exportar o yolo26n para NCNN e comparar os dois formatos na mesma imagem, com números.

cd ~/robo && source ~/robo-venv/bin/activate
yolo export model=yolo26n.pt format=ncnn       # cria a pasta yolo26n_ncnn_model/
python yolo_camera.py yolo26n_ncnn_model       # o mesmo script do tópico 2, agora com NCNN

# Compara PyTorch x NCNN (640 e 320) na mesma imagem: média de 20 inferências
import time
from ultralytics import YOLO

IMAGEM = "https://ultralytics.com/images/bus.jpg"   # ou o caminho de uma foto sua
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):                              # aquecimento: não conta
        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, só a rede
    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 que aprender

Dobrar o FPS sem gastar nada é a diferença entre um robô que segue a pessoa e um que perde ela a cada curva. E o hábito de medir antes e depois vale para qualquer otimização que você fizer daqui em diante.

Conceitos-chave

Quando NCNN e imgsz não bastam, o próximo passo é tirar a rede neural do processador. O AI HAT+ é uma placa que encaixa sobre o Pi 5 e se liga pelo conector PCIe; ela leva um chip Hailo feito só para inferência. Existem duas gerações: o AI HAT+ com Hailo-8L (13 TOPS) ou Hailo-8 (26 TOPS), voltado à visão, e o AI HAT+ 2 com Hailo-10H (40 TOPS em INT4) e 8 GB de memória própria, que também roda modelos de linguagem e de visão-linguagem pequenos. Os dois funcionam só no Pi 5; o antigo "AI Kit" saiu de linha.

Como ler: à esquerda, a CPU faz as três tarefas e a do meio (vermelha) domina. À direita, a parte pesada vai para a NPU pelo PCIe e volta só o resultado. A CPU fica livre para o resto do robô: servidor de vídeo, comunicação com o ESP32, logs.

Passo a passo (visão geral)

lspci | grep -i hailo        # a placa aparece no barramento PCIe?
vcgencmd get_throttled       # 0x0: a fonte aguenta o conjunto Pi + HAT + câmera

Por que aprender

O acelerador não é obrigatório para esta trilha: o projeto 3.6 funciona com CPU e NCNN. Mas entender quando ele vale (muitos objetos, FPS alto, IA de linguagem no mesmo robô) evita comprar cedo demais ou insistir tarde demais na CPU.

Conceitos-chave

O COCO não tem "minha caneca", "cone laranja da pista" ou "peça da competição". Para isso você faz um ajuste fino: parte do yolo26n, que já sabe ver formas, e mostra algumas centenas de fotos suas com as caixas marcadas. O treino roda num PC com GPU NVIDIA ou no Google Colab (GPU gratuita no navegador); o Pi só recebe o resultado pronto. Treinar no Pi até funciona, mas é lento demais para valer a pena.

Como ler: os passos roxos acontecem fora do robô; o ciano é o robô usando o modelo. A volta tracejada é o segredo: o primeiro modelo sempre erra em algum caso, e cada erro fotografado e rotulado melhora o próximo treino.

Passo a passo

Objetivo: descrever o dataset e treinar um detector de duas classes a partir do yolo26n. Troque o caminho e os nomes das classes pelos seus.

# Estrutura esperada:
#   meu_dataset/images/train/*.jpg   meu_dataset/labels/train/*.txt
#   meu_dataset/images/val/*.jpg     meu_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
# ao final: runs/detect/train/weights/best.pt  (o melhor modelo na validação)
yolo detect val model=runs/detect/train/weights/best.pt data=meu_dataset/data.yaml

# depois, no Pi:
# scp best.pt <seu_usuario>@robo.local:~/robo/
# yolo export model=best.pt format=ncnn   →   python yolo_camera.py best_ncnn_model

Por que aprender

É aqui que a visão do robô passa a servir ao seu projeto, e não ao contrário: competição, separação de peças, robô que busca um objeto específico. E o processo (coletar, rotular, treinar, testar, voltar) é o mesmo que você usa na Trilha 5 para ensinar o braço por demonstração.

Conceitos-chave

Um detector não "vê" como você: ele dá um palpite estatístico a cada quadro. Com pouca luz, o objeto fica escuro e borrado; longe, ocupa poucos pixels depois do redimensionamento; e às vezes uma mochila vira "pessoa" por um quadro. O limiar de confiança é o botão que você controla: alto demais e o robô perde o alvo; baixo demais e ele persegue fantasmas. Por isso o código do robô nunca reage a um quadro só.

Como ler: a régua é o valor de conf. À esquerda (vermelho) o robô reage a tudo; à direita (ciano) só a objetos muito nítidos. A moldura roxa é um ponto de partida razoável, que fica muito mais estável quando você exige que o objeto apareça em alguns quadros seguidos.

Objetivo: transformar as detecções brutas numa decisão estável: só a classe que interessa, só caixas grandes o bastante e só depois de 3 quadros seguidos. O resultado é o erro horizontal, igual ao do módulo 3.2.

# Decisão estável a partir do YOLO26: classe, tamanho mínimo e persistência
import time
from picamera2 import Picamera2
from ultralytics import YOLO

ALVO = "person"          # nome da classe no modelo (COCO usa nomes em inglês)
CONF_MIN = 0.5
AREA_MIN = 0.02          # caixa ocupa pelo menos 2% da imagem
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 e tamanho
        contador = contador + 1 if melhor else 0
        if contador >= QUADROS_SEGUIDOS:
            cx, area = melhor
            print(f"ALVO firme  erro={cx - LARGURA / 2:+5.0f}  tamanho={area:.2f}")
        else:
            print(f"sem alvo firme ({contador}/{QUADROS_SEGUIDOS}) → robô parado")
except KeyboardInterrupt:
    picam2.stop()

Por que aprender

Robô que segue pessoa é o projeto da trilha, e ele só é seguro se você souber onde a visão falha. Limiar, tamanho mínimo, persistência e parada ao perder o alvo são as quatro proteções que separam uma demonstração bonita de um robô em que dá para confiar.

Conceitos-chave