Licenciar o YOLO
Guias

Deteção de objetos no Raspberry Pi: YOLO26 no CPU de um Pi 5, sem acelerador

O YOLO26n executa a 67,03 ms por imagem com NCNN no CPU de um Raspberry Pi 5, e o runtime de código aberto da Arm regista 36,60 ms no seu próprio teste. Vê como executar ambos.

Onuralp SezerOnuralp Sezer13 min de leitura
Lista de exportação da Ultralytics Platform com a linha NCNN realçada acima de MNN, o formato recomendado para executar YOLO26 no CPU de um Raspberry Pi 5

Um Raspberry Pi 5 consegue executar deteção de objetos apenas no CPU, sem AI HAT nem acelerador USB? Sim. No nosso benchmark, o Ultralytics YOLO26n exportado para NCNN demora 67,03 ms de inferência por imagem nos quatro núcleos Arm Cortex-A76 do Pi 5, cerca de 15 fotogramas de inferência por segundo. A Arm também lançou um runtime de código aberto criado para este modelo e esta placa, que, segundo as medições da própria Arm, demora 36,60 ms por imagem no seu teste, cerca de 27 FPS de inferência.

Este artigo separa as condições por trás de cada número e explica o que cada um revela. Depois, mostra passo a passo como executar YOLO26n no CPU de um Raspberry Pi 5, desde a instalação até à câmara em direto, explica como executar o runtime da Arm na mesma placa e aborda em que situações continua a valer a pena adicionar um acelerador.

Se ainda não conheces a tarefa em si, começa por o que é a deteção de objetos. Esta página explica como a executar num Pi.

O runtime da Arm executa YOLO26n no CPU de um Raspberry Pi 5 a 36,60 ms por imagem#

O repositório Optimized-Runtimes da Arm reúne runtimes de inferência otimizados para Arm, destinados a modelos e plataformas específicos. O runtime atualmente listado executa a deteção de objetos YOLO26n num Raspberry Pi 5. Cada runtime tem o seu próprio diretório, com a compilação, a conversão, exemplos, benchmarks, testes e documentação de lançamento.

O percurso de aprendizagem da Arm compara o seu runtime com NCNN num teste: 36,60 ms por imagem para o runtime da Arm, contra 67,20 ms para NCNN, ambos com YOLO26n a 640 x 640, lote 1, no conjunto de dados coco-128-by-sa da Arm, com 128 imagens. A precisão foi semelhante: 0,4863 mAP50-95 para o runtime da Arm e 0,4902 para NCNN. Estes tempos correspondem a cerca de 27 FPS de inferência contra cerca de 15, ou seja, aproximadamente 84% mais débito para o runtime da Arm nesse teste. A Arm refere que o seu modelo NCNN usou pesos FP32 com aritmética FP16 ativada.

Para uma equipa que desenvolve numa placa com limitações de custo e potência, reduzir o tempo de inferência quase para metade deixa mais margem em cada fotograma para a captura, o rastreamento e o resto da aplicação. Estes valores são apenas tempos de inferência; a captura, o pré-processamento, o desenho e a apresentação acrescentam tempo a cada fotograma, por isso mede o pipeline completo da câmara no dispositivo. Este runtime dá continuidade a uma colaboração que abordámos no Arm Create 2026, onde o Ultralytics YOLO foi incluído no Arm AI Portal como modelo pré-otimizado aquando do lançamento.

O nosso benchmark NCNN regista 67,03 ms por imagem para YOLO26n num Raspberry Pi 5#

A equipa da Ultralytics comparou YOLO26 no Raspberry Pi 5 com oito formatos de exportação para o guia do Raspberry Pi. As condições: modelos exportados com precisão FP32, entrada predefinida de 640 píxeis, Ultralytics 8.4.108, precisão avaliada em COCO128 e apenas tempo de inferência, sem pré-processamento nem pós-processamento. O nosso benchmark usou uma exportação FP32. O teste NCNN independente da Arm ativou a aritmética FP16. Os dois tempos de NCNN, 67,03 ms e 67,20 ms, não são diretamente comparáveis.

NCNN foi, com uma margem clara, o formato de exportação mais rápido da Ultralytics:

Formato YOLO26nTempo de inferência (ms/imagem)mAP50-95(B), COCO128
PyTorch299.090.4760
ONNX125.990.4734
LiteRT123.300.4730
OpenVINO104.550.4734
MNN91.870.4749
NCNN67.030.4784

O NCNN é cerca de 4,5 vezes mais rápido do que os pesos PyTorch (67,03 ms contra 299,09 ms) e obteve 0,4784 mAP50-95 em COCO128, contra 0,4760 para PyTorch. O modelo maior YOLO26s demora 172,88 ms com NCNN, por isso, se procuras a maior taxa de fotogramas no CPU de um Pi, começa pelo modelo nano.

YOLO26 também supera o seu antecessor nesta placa. Num benchmark ONNX separado, a 640 píxeis, YOLO26n executa a 7,79 FPS, contra 6,79 FPS para YOLO11n, cerca de 15% mais rápido, e obtém 40,1% mAP50-95 na validação COCO, contra 39,5% (Ultralytics 8.4.14). YOLO26 também pode executar sem supressão não máxima quando é exportado com nms=False para formatos compatíveis, como ONNX e OpenVINO; o NCNN recorre ao cabeçalho padrão com NMS, conforme explica o guia de deteção de ponta a ponta.

Compara os valores do Raspberry Pi apenas em condições equivalentes#

O teste da Arm é útil porque mantém fixos o modelo, o tamanho da entrada, o lote e o conjunto de dados ao comparar runtimes. A maioria dos benchmarks para Pi que encontras na Internet não o faz. Três definições afetam os resultados mais do que qualquer outra coisa: a precisão (FP32, FP16 ou INT8), o tamanho da entrada e o que o cronómetro inclui: apenas a passagem direta do modelo ou todo o percurso, da imagem às caixas finais.

A precisão exige o mesmo cuidado. O nosso mAP é calculado com COCO128, uma amostra de 128 imagens, por isso verifica a precisão com as tuas próprias imagens de validação antes de implementar qualquer modelo, sobretudo um modelo quantizado.

Executa YOLO26n no CPU de um Raspberry Pi 5 em cinco passos#

Eis o percurso compatível mais rápido com o pacote Python da Ultralytics. Pressupõe um Raspberry Pi 5 com o Raspberry Pi OS de 64 bits; o guia do Raspberry Pi explica como gravar o sistema operativo e configurar o Docker.

  1. Instala a Ultralytics num ambiente virtual. Atualmente, o Raspberry Pi OS bloqueia as instalações de pip no Python do sistema, por isso cria um ambiente que continue a ter acesso à biblioteca de câmara do sistema:
sudo apt update
sudo apt install -y python3-venv python3-picamera2 rpicam-apps
python3 -m venv --system-site-packages ~/yolo
source ~/yolo/bin/activate
pip install ultralytics
  1. Exporta YOLO26n para NCNN e testa-o. O modo de exportação cria uma pasta yolo26n_ncnn_model que carregas como qualquer outro modelo:
from ultralytics import YOLO

# Exporta uma vez no Pi; cria a pasta 'yolo26n_ncnn_model'
model = YOLO("yolo26n.pt")
model.export(format="ncnn")

# Carrega o modelo NCNN e executa-o no CPU
ncnn_model = YOLO("yolo26n_ncnn_model")
results = ncnn_model("https://ultralytics.com/images/bus.jpg")
print(results[0].speed)  # tempos de pré-processamento, inferência e pós-processamento em ms

Modelo YOLO26n NCNN a detetar um autocarro e quatro pessoas numa rua da cidade

YOLO26n exportado para NCNN e executado na imagem de teste bus.jpg do passo 2: foi detetado um autocarro e quatro pessoas. Registado num CPU de computador de secretária; as caixas e pontuações num Pi podem diferir ligeiramente.

  1. Liga uma câmara. Verifica a transmissão com rpicam-hello. O Pi 5 tem dois conectores de câmara/ecrã de 22 pinos, pelo que os módulos de câmara de 15 pinos precisam de um cabo adaptador.
  2. Executa a deteção em direto. picamera2 envia os fotogramas diretamente para o modelo. A janela cv2.imshow precisa de uma sessão de ambiente de trabalho; num Pi sem interface gráfica, remove as linhas de apresentação e usa os resultados diretamente no código:
import cv2
from picamera2 import Picamera2

from ultralytics import YOLO

picam2 = Picamera2()
picam2.preview_configuration.main.size = (1280, 720)
picam2.preview_configuration.main.format = "RGB888"
picam2.preview_configuration.align()
picam2.configure("preview")
picam2.start()

model = YOLO("yolo26n_ncnn_model")

while True:
    frame = picam2.capture_array()
    results = model(frame)
    cv2.imshow("Camera", results[0].plot())
    if cv2.waitKey(1) == ord("q"):
        break

cv2.destroyAllWindows()
  1. Compara o desempenho na tua placa. yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640 tenta cada formato de exportação no teu próprio Pi, para veres o desempenho proporcionado pelo teu sistema de arrefecimento, imagem do sistema operativo e fonte de alimentação. Alguns formatos não podem ser exportados no próprio Pi: por exemplo, LiteRT só pode ser exportado em Linux x86_64 ou macOS, por isso exporta-o aí, copia o ficheiro para o Pi e valida-o em separado. Para obter valores de precisão mais estáveis, usa um conjunto de validação maior, como data=coco.yaml.

Executa o runtime da Arm juntamente com NCNN no mesmo Pi#

O runtime da Arm é um projeto independente, não um formato de exportação da Ultralytics, e os seus passos de configuração destinam-se ao Raspberry Pi OS Trixie de 64 bits com Python 3.13. Para o experimentares e comparares com NCNN:

  1. Clona arm/Optimized-Runtimes, abre o diretório yolo26-raspberry-pi-5, segue os pré-requisitos e compila o runtime com make runtime.
  2. Executa make example-video para ver as deteções num vídeo de amostra.
  3. Executa make ultralytics-benchmark para comparar o desempenho do runtime da Arm na tua placa.
  4. Exporta YOLO26n para NCNN como no passo 2 acima e, em seguida, valida-o no mesmo conjunto de dados coco-128-by-sa gerado, usando o ambiente, o ponto de verificação e os comandos da página de comparação da Arm, para que ambos os runtimes processem as mesmas imagens com o mesmo tamanho de entrada.
  5. Para o teu próprio modelo, converte um ponto de verificação YOLO26n compatível e ajustado com make model CHECKPOINT=/path/to/checkpoint.pt, conforme descrito no cartão do modelo do runtime, e compara a precisão no teu próprio conjunto de validação, além da velocidade.

Na comparação da Arm, o seu runtime foi a opção mais rápida no CPU para a deteção com YOLO26n. A exportação NCNN da Ultralytics abrange as restantes opções: outros tamanhos e tarefas YOLO26, incluindo segmentação e pose, a partir das mesmas duas linhas de código, dentro dos limites indicados no guia NCNN.

O arrefecimento, o overclock e um sistema operativo mais leve permitem ganhar fotogramas extra#

Quando o modelo está a funcionar, é a placa que define o limite. As boas práticas do guia do Raspberry Pi indicam o que pode ajudar:

  • Arrefece a placa. A inferência contínua aquece o CPU e o estrangulamento térmico reduz a frequência de relógio considerada no benchmark. Um dissipador e uma ventoinha mantêm os tempos por fotograma estáveis.
  • Faz overclock se conseguires arrefecê-la. Algumas placas Pi 5 conseguem executar o CPU a 3,0 GHz em vez da frequência base de 2,4 GHz, usando arm_freq=3000 e force_turbo=1 em /boot/firmware/config.txt, seguidos de um reinício. A estabilidade varia de placa para placa, por isso, se o sistema ficar instável, reduz a frequência em 100 MHz.
  • Dispensa o ambiente de trabalho. O Raspberry Pi OS Lite deixa mais RAM disponível para tarefas de visão.
  • Usa um SSD para execuções 24/7. Um cartão SD pode desgastar-se com escritas contínuas; o conector PCIe do Pi 5 aceita um adaptador NVMe.
  • Reduz o tamanho da entrada quando os objetos são grandes. Um imgsz mais pequeno significa menos píxeis por fotograma. Mede as alterações de velocidade e precisão nas tuas próprias gravações, pois os objetos pequenos ou distantes são os primeiros a ser afetados. O nosso guia sobre FPS em visão computacional explica como definir um orçamento de taxa de fotogramas.

Adiciona um acelerador quando o CPU de um Pi não for suficiente#

Um Pi 5 apenas com CPU é adequado para uma câmara com taxas de fotogramas moderadas. Para várias transmissões, modelos maiores ou mais margem para outro software, um acelerador transfere o modelo para fora do CPU. Os nossos tempos medidos de inferência YOLO26n num Raspberry Pi 5 (apenas inferência, COCO128), obtidos em testes separados com modelos quantizados e diferentes versões da Ultralytics:

  • Hailo-8 no AI HAT+: 21,7 ms a 0,455 mAP50-95, Ultralytics 8.4.174.
  • Módulo DEEPX DX-M1 M.2: 34,6 ms a 0,4660 mAP50-95, Ultralytics 8.4.48.
  • Coral Edge TPU: uma opção USB com o seu próprio processo de exportação; os tempos desse guia foram registados com modelos YOLOv8.

Cada opção acrescenta hardware, consumo de energia e uma etapa de compilação do modelo; além disso, os modelos acelerados são executados quantizados, por isso verifica a precisão depois da exportação. Para uma perspetiva mais abrangente, consulta como escolher o dispositivo de edge certo e o guia NVIDIA Jetson se precisares de mais capacidade de computação do que a oferecida por um Pi.

Treina um detetor personalizado e, em seguida, implementa-o da mesma forma#

As 80 classes do COCO são um ponto de partida. A maioria dos projetos com Pi precisa de detetar objetos próprios: uma peça numa linha de produção, um produto numa prateleira, uma praga numa folha. A Ultralytics Platform trata de tudo, do início ao fim: carrega e anota um conjunto de dados, treina na nuvem a partir do ponto de verificação YOLO26n e, em seguida, exporta para NCNN e copia a pasta para o Pi.

Começa pelo modelo nano, valida a precisão e mede a velocidade do teu modelo personalizado com gravações representativas da câmara que vais utilizar. As nossas sugestões para treinar modelos e a lição da Academy sobre como escolher um destino de implementação explicam o resto.

Quem deve executar YOLO26 no CPU de um Raspberry Pi 5#

Executa YOLO26n no CPU do Pi 5 se tiveres uma câmara, conseguires trabalhar dentro da taxa de fotogramas medida de ponta a ponta no dispositivo e quiseres a lista de materiais mais simples: um Raspberry Pi, uma câmara, uma ventoinha e uma fonte de alimentação. Contadores de retalho, câmaras domésticas e de vida selvagem, contagem em tapetes transportadores e protótipos robóticos são todos casos adequados.

Usa o runtime da Arm quando a deteção YOLO26n for toda a tua carga de trabalho e cada milissegundo contar. Adiciona um acelerador se precisares de várias câmaras, modelos maiores ou tempo de CPU disponível para o resto da aplicação.

O Ultralytics YOLO está disponível ao abrigo da AGPL-3.0 ou de uma Licença Empresarial da Ultralytics. Consulta as opções de licenciamento da Ultralytics para saberes qual se adequa à tua implementação.

Perguntas frequentes

  • Sim, para tarefas com uma só câmara e taxas de fotogramas moderadas. No benchmark da Ultralytics, YOLO26n exportado para NCNN demora 67,03 ms de inferência por imagem no CPU de um Raspberry Pi 5 (exportação FP32, entrada de 640 píxeis), cerca de 15 FPS de inferência. Separadamente, a Arm mediu 36,60 ms para YOLO26n com o seu runtime de código aberto, numa comparação própria; trata-se de um teste diferente, não de uma aceleração face ao nosso resultado de 67,03 ms. A captura da câmara e o desenho acrescentam tempo, por isso mede o pipeline completo.

  • No teste de comparação da Arm, o seu runtime YOLO26n Optimized-Runtimes foi o mais rápido, com 36,60 ms por imagem, contra 67,20 ms para NCNN. No nosso benchmark separado dos formatos de exportação da Ultralytics, NCNN foi o mais rápido, com 67,03 ms, à frente de MNN, com 91,87 ms, e de OpenVINO, com 104,55 ms. Estes benchmarks são independentes e usam conjuntos de dados diferentes, COCO128 e coco-128-by-sa da Arm, pelo que os tempos não demonstram uma aceleração entre testes.

  • Sim. Num benchmark ONNX separado, a 640 píxeis num Raspberry Pi 5, YOLO26n executa a 7,79 FPS, contra 6,79 FPS para YOLO11n, cerca de 15% mais rápido, e obtém 40,1% mAP50-95 na validação COCO, contra 39,5%.

  • Não, para uma câmara com taxas de fotogramas moderadas. Um acelerador compensa quando tens várias transmissões ou modelos maiores: nos nossos testes, YOLO26n quantizado num Hailo-8 AI HAT+ demorou 21,7 ms de inferência por imagem, contra 67,03 ms para a exportação NCNN FP32 no CPU. Estes valores provêm de testes separados, com versões e precisões diferentes.

  • Sim. Treina o teu modelo em Python ou na Ultralytics Platform, exporta-o com format="ncnn", copia a pasta _ncnn_model para o Pi e carrega-a com YOLO("your_model_ncnn_model"). Atualiza o caminho do modelo no código da câmara e compara o desempenho com o teu próprio YAML de conjunto de dados e as tuas classes. O runtime da Arm também converte pontos de verificação YOLO26n compatíveis e ajustados.

Escrito por

Onuralp Sezer
Onuralp Sezer

Engenheiro sênior de machine learning · Ultralytics

Onuralp Sezer é engenheiro sênior de aprendizado de máquina na Ultralytics, onde trabalha para avançar as tecnologias de visão computacional, como YOLO, e contribui para o desenvolvimento de código aberto. Organizador de longa data do Google Developer Group (GDG) e colaborador de projetos de código aberto, ele participa ativamente da comunidade de desenvolvedores como palestrante com foco em aprendizado de máquina e visão computacional e já contribuiu para o Fedora Project.

Comentários

Faça uma pergunta, compartilhe seus resultados ou ajude alguém.

Explore as soluções

Visão computacional no desporto

Visão computacional no desporto

Descubra como o Ultralytics YOLO impulsiona a visão computacional no esporte com rastreamento de jogadores e bolas, análise de desempenho, insights para treinadores e reabilitação de atletas.
Saiba mais
Visão computacional para imagens aéreas

Visão computacional para imagens aéreas

Transforma imagens de drones e aéreas em informações em tempo real para a agricultura, a aquacultura, a conservação e a análise geoespacial com Ultralytics YOLO.
Saiba mais
Visão computacional no setor aeroespacial

Visão computacional no setor aeroespacial

Aplica visão computacional na indústria aeroespacial com Ultralytics YOLO para inspecionar aeronaves, detetar objetos estranhos na pista (FOD), apoiar operações aeroportuárias em terra e detetar defeitos em materiais compósitos.
Saiba mais
Visão computacional na segurança

Visão computacional na segurança

Protege todas as instalações com os modelos Ultralytics YOLO. A IA visual permite monitorizar perímetros, detetar ameaças, reconhecer matrículas e melhorar a segurança no local de trabalho.
Saiba mais
Visão computacional na robótica

Visão computacional na robótica

Potencia máquinas mais inteligentes com os modelos Ultralytics YOLO. A IA visual na robótica permite navegação autónoma, perceção, rastreamento de objetos e controlo em tempo real.
Saiba mais
Visão computacional na logística

Visão computacional na logística

Otimize a logística com os modelos Ultralytics YOLO. A IA de visão permite inspecionar pacotes, fazer triagem, rastrear veículos e monitorar a segurança em tempo real nos armazéns.
Saiba mais
Visão computacional no varejo

Visão computacional no varejo

Reinvente o varejo com os modelos Ultralytics YOLO. A IA de visão permite rastrear o estoque, monitorar prateleiras, gerenciar filas e obter insights mais inteligentes sobre clientes.
Saiba mais
Visão computacional na área da saúde

Visão computacional na área da saúde

Desenvolva soluções de saúde com os modelos Ultralytics YOLO. A IA de visão na área da saúde permite obter imagens médicas mais rapidamente, diagnósticos mais inteligentes e monitoramento de pacientes.
Saiba mais
Visão computacional na manufatura

Visão computacional na manufatura

Otimize a manufatura com modelos Ultralytics YOLO. A IA visual impulsiona o controle de qualidade, a detecção de defeitos, a conformidade com o uso de EPI e a automação da linha de montagem.
Saiba mais
Visão computacional no setor automotivo

Visão computacional no setor automotivo

Aplique visão computacional no setor automotivo com modelos Ultralytics YOLO. A IA visual aumenta a segurança viária, aprimora a assistência ao condutor e viabiliza a automação de veículos para estradas mais inteligentes.
Saiba mais
Visão computacional na agricultura

Visão computacional na agricultura

Leve a IA de visão à agricultura inteligente com os modelos Ultralytics YOLO. Aprimore o monitoramento de plantações, o rastreamento de animais e a agricultura de precisão para obter safras maiores e mais inteligentes.
Saiba mais

Vamos construir juntos o futuro da IA!

Comece sua jornada rumo ao futuro do aprendizado de máquina