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 Sezer13 min de leitura
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 YOLO26n | Tempo de inferência (ms/imagem) | mAP50-95(B), COCO128 |
|---|---|---|
| PyTorch | 299.09 | 0.4760 |
| ONNX | 125.99 | 0.4734 |
| LiteRT | 123.30 | 0.4730 |
| OpenVINO | 104.55 | 0.4734 |
| MNN | 91.87 | 0.4749 |
| NCNN | 67.03 | 0.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.
- Instala a Ultralytics num ambiente virtual. Atualmente, o Raspberry Pi OS bloqueia as instalações de
pipno 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- Exporta YOLO26n para NCNN e testa-o. O modo de exportação cria uma pasta
yolo26n_ncnn_modelque 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
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.
- 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. - Executa a deteção em direto.
picamera2envia os fotogramas diretamente para o modelo. A janelacv2.imshowprecisa 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()- Compara o desempenho na tua placa.
yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640tenta 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, comodata=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:
- Clona arm/Optimized-Runtimes, abre o diretório
yolo26-raspberry-pi-5, segue os pré-requisitos e compila o runtime commake runtime. - Executa
make example-videopara ver as deteções num vídeo de amostra. - Executa
make ultralytics-benchmarkpara comparar o desempenho do runtime da Arm na tua placa. - Exporta YOLO26n para NCNN como no passo 2 acima e, em seguida, valida-o no mesmo conjunto de dados
coco-128-by-sagerado, 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. - 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=3000eforce_turbo=1em/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
imgszmais 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_modelpara o Pi e carrega-a comYOLO("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
Comentários
Faça uma pergunta, compartilhe seus resultados ou ajude alguém.










