Visão Computacional com YOLOv8 em Edge: Tutorial 2026

Treinar uma rede neural do zero exige dezenas de milhares de imagens rotuladas e dias de GPU. Para startups, pesquisadores ou projetos com orçamento apertado, isso é um luxo.

A detecção de objetos em tempo real em dispositivos edge — como Raspberry Pi, Jetson Nano ou câmeras inteligentes — é um dos maiores desafios da visão computacional moderna. Modelos pesados como YOLOv8x exigem GPUs potentes, mas versões otimizadas como YOLOv8nano conseguem rodar a 30 FPS em hardware modesto.

Neste tutorial, você vai aprender a implementar detecção de objetos com YOLOv8 em dispositivos edge. Vamos cobrir desde a instalação do ambiente até a otimização para inferência em tempo real, incluindo técnicas como quantização e poda de rede.

Por que YOLOv8 domina detecção em dispositivos edge

YOLO (You Only Look Once) é uma família de modelos de detecção de objetos que processa a imagem inteira em uma única passada pela rede neural. Isso a torna extremamente rápida em comparação com abordagens baseadas em regiões propostas, como Faster R-CNN.

A versão 8, lançada pela Ultralytics em 2023, introduziu melhorias significativas: backbone baseado em CSPDarknet, neck com PAN-FPN e head de detecção sem âncoras. O resultado é um modelo que atinge 53.9% de mAP no COCO com a versão grande (YOLOv8x) e 37.3% com a versão nano (YOLOv8n), conforme documentado no paper oficial da Ultralytics (2023).

Para dispositivos edge, o YOLOv8n é o padrão ouro. Com apenas 3.2 milhões de parâmetros e 8.7 GFLOPs, ele roda a 30 FPS em um Jetson Nano e a 15 FPS em um Raspberry Pi 4 com aceleração OpenCV, de acordo com benchmarks da comunidade Ultralytics.

A chave está na arquitetura eficiente: o backbone extrai features em múltiplas escalas, o neck combina essas features para detectar objetos de diferentes tamanhos, e o head produz as bounding boxes e classes sem a necessidade de âncoras pré-definidas.

Configurando o ambiente no dispositivo edge

Antes de começar, você precisa preparar o dispositivo. Vamos usar um Raspberry Pi 4 com 4GB de RAM e uma câmera USB. Instale as dependências:

sudo apt update
sudo apt install python3-pip libopencv-dev
pip3 install ultralytics opencv-python numpy

Para Jetson Nano, use o JetPack SDK da NVIDIA, que já inclui CUDA e TensorRT. Instale a versão otimizada do YOLOv8:

pip3 install ultralytics
sudo apt install nvidia-tensorrt

Agora, carregue o modelo YOLOv8n pré-treinado no COCO. O parâmetro model aceita o nome do modelo ou o caminho para um arquivo .pt.

from ultralytics import YOLO

modelo = YOLO('yolov8n.pt') print(modelo)

A saída mostra a arquitetura completa. Repare que o modelo já está pronto para detectar 80 classes do COCO (pessoa, carro, cachorro, etc.). Para sua tarefa específica, você precisa fine-tuning com seu próprio dataset.

Fine-tuning do YOLOv8 para seu dataset

Suponha que você quer detectar placas de trânsito em tempo real. Você tem um dataset com 500 imagens rotuladas no formato YOLO (arquivos .txt com classe, x_center, y_center, width, height normalizados).

Crie um arquivo dataset.yaml:

train: /caminho/dataset/train
val: /caminho/dataset/val
nc: 5
names: ['pare', 'siga', 'cuidado', 'limite_velocidade', 'pedestre']

Agora, faça o fine-tuning. Use o modelo pré-treinado como ponto de partida:

modelo = YOLO('yolov8n.pt')
resultados = modelo.train(data='dataset.yaml', epochs=50, imgsz=640, batch=16, device='cpu')

Para dispositivos edge, use device='cpu' ou device='cuda' se tiver GPU. O treino pode levar algumas horas no Raspberry Pi, mas você pode fazer em um computador mais potente e depois transferir o modelo.

Otimização para inferência em tempo real

O modelo treinado tem cerca de 6 MB. Para rodar em tempo real no edge, você precisa otimizar. Três técnicas principais:

Quantização para INT8

A quantização reduz a precisão dos pesos de FP32 para INT8, cortando o tamanho do modelo em 4x e acelerando a inferência em 2-3x. Use o TensorRT no Jetson Nano:

from ultralytics import YOLO

modelo = YOLO('modelo_treinado.pt') modelo.export(format='engine', device=0) # Exporta para TensorRT

No Raspberry Pi, use OpenCV com o backend ONNX:

modelo.export(format='onnx', imgsz=640)
# Depois carregue com OpenCV
import cv2
net = cv2.dnn.readNet('modelo_treinado.onnx')
net.setPreferableBackend(cv2.dnn.DNN_BACKEND_OPENCV)
net.setPreferableTarget(cv2.dnn.DNN_TARGET_CPU)

Poda de rede (pruning)

Remova neurônios com pesos próximos de zero. A Ultralytics oferece suporte nativo:

from ultralytics import YOLO

modelo = YOLO('modelo_treinado.pt') modelo.prune(0.3) # Remove 30% dos pesos menos importantes modelo.export(format='onnx')

A poda reduz o tamanho do modelo em até 50% com perda mínima de precisão (menos de 1% de mAP).

Redução da resolução de entrada

Diminua o imgsz de 640 para 320. Isso reduz o tempo de inferência em 4x, mas também reduz a precisão em objetos pequenos. Teste com seu dataset:

resultados = modelo.predict(frame, imgsz=320)

A tabela abaixo compara as estratégias em um Raspberry Pi 4:

Implementando a inferência em tempo real

Com o modelo otimizado, implemente o loop de inferência. Use OpenCV para capturar frames da câmera e YOLO para detectar objetos.

import cv2
from ultralytics import YOLO

modelo = YOLO('modelo_otimizado.engine') # TensorRT cap = cv2.VideoCapture(0) # Câmera USB

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

resultados = modelo(frame, imgsz=640, conf=0.5)

# Desenha as bounding boxes
for r in resultados:
    for box in r.boxes:
        x1, y1, x2, y2 = map(int, box.xyxy[0])
        conf = box.conf[0].item()
        cls = int(box.cls[0].item())
        label = f'{modelo.names[cls]} {conf:.2f}'
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 2)
        cv2.putText(frame, label, (x1, y1-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imshow('Detecção em Tempo Real', frame)
if cv2.waitKey(1) & 0xFF == ord('q'):
    break

cap.release() cv2.destroyAllWindows()

Para dispositivos com pouca memória, processe frames em resolução reduzida e use um buffer de frames para evitar quedas de FPS.

Avaliação de desempenho no dispositivo edge

Após a implementação, avalie o desempenho em termos de FPS, latência e precisão. Use um dataset de teste com 100 imagens e meça:

import time

total_fps = 0 num_frames = 100

for i in range(num_frames): ret, frame = cap.read() if not ret: break

inicio = time.time()
resultados = modelo(frame)
fim = time.time()

fps = 1 / (fim - inicio)
total_fps += fps

print(f'FPS médio: {total_fps / num_frames:.2f}')

Para precisão, compare as detecções com as ground truths usando métricas como mAP e recall. Ferramentas como o ultralytics.yolo.utils.metrics podem automatizar essa análise.

Conclusão

Neste tutorial, você aprendeu a implementar detecção de objetos com YOLOv8 em dispositivos edge, desde a configuração do ambiente até a otimização para inferência em tempo real. As técnicas de quantização, poda e redução de resolução permitem rodar modelos eficientes em hardware modesto, como Raspberry Pi e Jetson Nano.

Como próximos passos, explore o fine-tuning com datasets personalizados para aplicações específicas, como vigilância ou automação industrial. Acompanhe as atualizações da Ultralytics para novas versões do YOLO e integrações com TensorRT para desempenho ainda maior.

Artigos Relacionados

• A Grande Reforma do Transformer: Maio de 2026 Está Reescrevendo as Regras do ML
• O Fim dos Pilotos de ML: Como as 'AI Factories' Estão Industrializando o Machine Learning nas Empresas em 2026
• AlphaEvolve: 11 Recordes que Provam que o ML Já Está se Redesenhando