Licenza YOLO
Guide

Rilevamento di oggetti su Raspberry Pi: YOLO26 su una CPU Pi 5, senza acceleratore

YOLO26n impiega 67.03 ms per immagine con NCNN su una CPU Raspberry Pi 5; il runtime open source di Arm registra 36.60 ms nel proprio test. Ecco come eseguire entrambi.

Onuralp SezerOnuralp Sezer12 min di lettura
Elenco dei formati di esportazione di Ultralytics Platform con la riga NCNN evidenziata sopra MNN, il formato consigliato per eseguire YOLO26 su una CPU Raspberry Pi 5

È possibile eseguire il rilevamento di oggetti su una Raspberry Pi 5 usando solo la CPU, senza AI HAT o acceleratore USB? Sì. Nel nostro benchmark, Ultralytics YOLO26n esportato in NCNN impiega 67.03 ms per l'inferenza di ogni immagine sui quattro core Arm Cortex-A76 della Pi 5, circa 15 fotogrammi al secondo in inferenza. Arm ha rilasciato anche un runtime open source realizzato per questo modello e questa scheda, che nel proprio test impiega 36.60 ms per immagine, circa 27 FPS in inferenza.

Questo articolo distingue le condizioni alla base di ciascun risultato e spiega cosa indica ognuno. Poi mostra passo passo come eseguire YOLO26n su una CPU Raspberry Pi 5, dall'installazione alla videocamera in diretta, spiega come eseguire il runtime di Arm sulla stessa scheda e illustra quando vale ancora la pena aggiungere un acceleratore.

Se non conosci ancora il compito in sé, inizia da cos'è il rilevamento di oggetti. Questa pagina spiega come eseguirlo su una Pi.

Il runtime di Arm esegue YOLO26n su una CPU Raspberry Pi 5 in 36.60 ms per immagine#

Il repository Optimized-Runtimes di Arm raccoglie runtime di inferenza ottimizzati per Arm, dedicati a modelli e piattaforme specifici. Il runtime attualmente elencato esegue il rilevamento di oggetti con YOLO26n su una Raspberry Pi 5. Ogni runtime si trova nella propria directory, con documentazione relativa a compilazione, conversione, esempi, benchmark, test e release.

Il percorso di apprendimento di Arm confronta il suo runtime con NCNN in un test: 36.60 ms per immagine per il runtime di Arm contro 67.20 ms per NCNN, entrambi con YOLO26n a 640 x 640, batch 1, sul dataset coco-128-by-sa di Arm, composto da 128 immagini. L'accuratezza era simile: 0.4863 mAP50-95 per il runtime di Arm e 0.4902 per NCNN. Questi tempi corrispondono a circa 27 FPS in inferenza contro circa 15, ossia un throughput superiore di circa l'84% per il runtime di Arm in quel test. Arm specifica che il modello NCNN usava pesi FP32 con aritmetica FP16 abilitata.

Per un team che sviluppa su una scheda con limiti di costo e consumo energetico, quasi dimezzare il tempo di inferenza lascia più margine per ogni fotogramma, da dedicare all'acquisizione, al tracking e al resto dell'applicazione. Si tratta solo dei tempi di inferenza: l'acquisizione, il pre-processing, il disegno e la visualizzazione aggiungono tempo a ogni fotogramma, quindi misura l'intera pipeline della videocamera sul dispositivo. Il runtime porta avanti anche una collaborazione di cui abbiamo parlato da Arm Create 2026, dove al lancio Ultralytics YOLO è stato aggiunto all'Arm AI Portal come modello pre-ottimizzato.

Il nostro benchmark NCNN registra 67.03 ms per immagine per YOLO26n su una Raspberry Pi 5#

Il team Ultralytics ha eseguito benchmark di YOLO26 su una Raspberry Pi 5 con otto formati di esportazione per la guida a Raspberry Pi. Condizioni: modelli esportati con precisione FP32, input predefinito di 640 pixel, Ultralytics 8.4.108, accuratezza misurata su COCO128 e solo tempo di inferenza, esclusi pre-processing e post-processing. Il nostro benchmark ha usato un'esportazione FP32. Il test NCNN separato di Arm ha abilitato l'aritmetica FP16. I due tempi di NCNN, 67.03 ms e 67.20 ms, non sono direttamente confrontabili.

NCNN è stato nettamente il formato di esportazione Ultralytics più veloce:

Formato di YOLO26nTempo di inferenza (ms/immagine)mAP50-95(B), COCO128
PyTorch299.090.4760
ONNX125.990.4734
LiteRT123.300.4730
OpenVINO104.550.4734
MNN91.870.4749
NCNN67.030.4784

NCNN è circa 4.5 volte più veloce dei pesi PyTorch (67.03 ms contro 299.09 ms) e su COCO128 ha ottenuto 0.4784 mAP50-95 contro 0.4760 per PyTorch. Il modello più grande YOLO26s impiega 172.88 ms con NCNN, quindi per ottenere il massimo frame rate su una CPU Pi, il modello nano è quello da cui iniziare.

Anche su questa scheda YOLO26 supera il suo predecessore. In un benchmark ONNX separato a 640 pixel, YOLO26n raggiunge 7.79 FPS contro i 6.79 FPS di YOLO11n, circa il 15% in più, ottenendo al contempo 40.1% mAP50-95 sulla validazione COCO contro 39.5% (Ultralytics 8.4.14). YOLO26 può essere eseguito anche senza soppressione non massima se esportato con nms=False in formati che la supportano, come ONNX e OpenVINO; NCNN ripiega sulla head standard con NMS, come spiega la guida al rilevamento end-to-end.

Confronta i risultati su Raspberry Pi solo a parità di condizioni#

Il test di Arm è utile perché mantiene invariati modello, dimensioni dell'input, batch e dataset tra i diversi runtime. La maggior parte dei benchmark per Pi disponibili online non lo fa. Tre impostazioni influenzano i risultati più di ogni altra: la precisione (FP32, FP16 o INT8), le dimensioni dell'input e cosa include il tempo misurato: solo il forward pass del modello o l'intero percorso dall'immagine ai riquadri finali.

Anche l'accuratezza richiede attenzione. Il nostro mAP è calcolato su COCO128, un campione di 128 immagini, quindi verifica l'accuratezza sui tuoi dati di validazione prima di distribuire qualsiasi modello, soprattutto se quantizzato.

Esegui YOLO26n su una CPU Raspberry Pi 5 in cinque passaggi#

Ecco il percorso supportato più rapido con il pacchetto Python di Ultralytics. Presuppone l'uso di una Raspberry Pi 5 con Raspberry Pi OS a 64 bit; la guida a Raspberry Pi illustra come installare il sistema operativo e configurare Docker.

  1. Installa Ultralytics in un ambiente virtuale. Le versioni attuali di Raspberry Pi OS bloccano le installazioni di pip nel Python di sistema, quindi crea un ambiente che possa comunque accedere alla libreria di sistema della videocamera:
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. Esporta YOLO26n in NCNN e provalo. La modalità di esportazione crea una cartella yolo26n_ncnn_model da caricare come qualsiasi altro modello:
from ultralytics import YOLO

# Esporta una volta sulla Pi; crea la cartella 'yolo26n_ncnn_model'
model = YOLO("yolo26n.pt")
model.export(format="ncnn")

# Carica il modello NCNN ed eseguilo sulla CPU
ncnn_model = YOLO("yolo26n_ncnn_model")
results = ncnn_model("https://ultralytics.com/images/bus.jpg")
print(results[0].speed)  # tempi di preprocessing, inferenza e postprocessing in ms

Modello YOLO26n NCNN che rileva un autobus e quattro persone su una strada cittadina

YOLO26n esportato in NCNN ed eseguito sull'immagine di test bus.jpg del passaggio 2: rilevati un autobus e quattro persone. Risultato registrato su una CPU desktop; i riquadri e i punteggi possono variare leggermente su una Pi.

  1. Collega una videocamera. Controlla il flusso con rpicam-hello. La Pi 5 ha due connettori per videocamera/display a 22 pin, quindi i moduli per videocamera a 15 pin richiedono un cavo adattatore.
  2. Esegui il rilevamento in diretta. picamera2 passa i fotogrammi direttamente al modello. La finestra cv2.imshow richiede una sessione desktop; su una Pi senza interfaccia grafica, rimuovi le righe per la visualizzazione e usa invece i risultati nel codice:
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. Esegui il benchmark sulla tua scheda. yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640 prova ciascun formato di esportazione sulla tua Pi, così puoi vedere le prestazioni offerte dal tuo sistema di raffreddamento, dall'immagine del sistema operativo e dall'alimentatore. Alcuni formati non possono essere esportati direttamente sulla Pi: LiteRT, ad esempio, consente l'esportazione solo su Linux x86_64 o macOS, quindi esportalo lì, copia il file sulla Pi e convalidalo separatamente. Per ottenere risultati di accuratezza più stabili, usa un set di validazione più ampio, come data=coco.yaml.

Esegui il runtime di Arm accanto a NCNN sulla stessa Pi#

Il runtime di Arm è un progetto separato, non un formato di esportazione Ultralytics, e le sue istruzioni di configurazione sono pensate per Raspberry Pi OS Trixie a 64 bit con Python 3.13. Per provarlo e confrontarlo con NCNN:

  1. Clona arm/Optimized-Runtimes, apri la directory yolo26-raspberry-pi-5, segui i prerequisiti e compila il runtime con make runtime.
  2. Esegui make example-video per visualizzare i rilevamenti su un video di esempio.
  3. Esegui make ultralytics-benchmark per eseguire il benchmark del runtime di Arm sulla tua scheda.
  4. Esporta YOLO26n in NCNN come descritto sopra al passaggio 2, poi convalidalo sullo stesso dataset coco-128-by-sa generato, usando l'ambiente, il checkpoint e i comandi indicati nella pagina di confronto di Arm, così entrambi i runtime elaborano le stesse immagini con le stesse dimensioni di input.
  5. Per il tuo modello, converti un checkpoint YOLO26n compatibile e ottimizzato con fine-tuning tramite make model CHECKPOINT=/path/to/checkpoint.pt, come descritto nella scheda del modello del runtime, e confronta sia l'accuratezza sul tuo set di validazione sia la velocità.

Nel confronto di Arm, il suo runtime è stato il percorso CPU più veloce per il rilevamento con YOLO26n. L'esportazione Ultralytics NCNN copre il resto: altre dimensioni e attività di YOLO26, inclusi segmentazione e pose, a partire dalle stesse due righe di codice, nei limiti indicati nella guida a NCNN.

Raffreddamento, overclock e un sistema operativo più leggero aumentano i fotogrammi#

Una volta avviato il modello, è la scheda a stabilire il limite. Le procedure consigliate nella guida a Raspberry Pi indicano cosa può aiutare:

  • Raffredda la scheda. L'inferenza prolungata riscalda la CPU e il throttling termico riduce la frequenza di clock prevista dal benchmark. Un dissipatore e una ventola mantengono stabili i tempi per fotogramma.
  • Esegui l'overclock se puoi raffreddare la scheda. Alcune schede Pi 5 funzionano a 3.0 GHz invece che alla frequenza base di 2.4 GHz, impostando arm_freq=3000 e force_turbo=1 in /boot/firmware/config.txt e riavviando. La stabilità varia da una scheda all'altra, quindi, se il sistema diventa instabile, riduci la frequenza di 100 MHz.
  • Evita l'ambiente desktop. Raspberry Pi OS Lite lascia più RAM disponibile per le attività di visione artificiale.
  • Usa un SSD per l'esecuzione 24/7. Una scheda SD può usurarsi con scritture continue; il connettore PCIe della Pi 5 supporta un adattatore NVMe.
  • Riduci le dimensioni dell'input quando gli oggetti sono grandi. Un imgsz più piccolo comporta meno pixel per fotogramma. Misura le variazioni di velocità e accuratezza sui tuoi filmati, perché gli oggetti piccoli o lontani sono i primi a risentirne. La nostra guida agli FPS nella visione artificiale spiega come definire un budget di frame rate.

Aggiungi un acceleratore quando la CPU di una Pi non basta#

Una Pi 5 con la sola CPU è adatta a una videocamera con frame rate moderati. Per più flussi, modelli più grandi o per lasciare risorse ad altro software, un acceleratore sposta il modello fuori dalla CPU. I nostri tempi di inferenza misurati per YOLO26n su una Raspberry Pi 5 (solo inferenza, COCO128) provengono da test separati con modelli quantizzati e versioni diverse di Ultralytics:

  • Hailo-8 su AI HAT+: 21.7 ms con 0.455 mAP50-95, Ultralytics 8.4.174.
  • Modulo M.2 DEEPX DX-M1: 34.6 ms con 0.4660 mAP50-95, Ultralytics 8.4.48.
  • Coral Edge TPU: un'opzione USB con un proprio percorso di esportazione; i tempi riportati in quella guida sono stati registrati con modelli YOLOv8.

Ognuno richiede hardware, alimentazione e una fase di compilazione del modello, e i modelli accelerati vengono eseguiti in forma quantizzata, quindi verifica l'accuratezza dopo l'esportazione. Per una panoramica più ampia, consulta come scegliere il dispositivo edge più adatto e la guida a NVIDIA Jetson se ti serve più capacità di calcolo di quella offerta da una Pi.

Addestra un rilevatore personalizzato e distribuiscilo allo stesso modo#

Le 80 classi di COCO sono un punto di partenza. La maggior parte dei progetti su Pi ha bisogno di oggetti personalizzati: un componente su una linea, un prodotto su uno scaffale, un parassita su una foglia. Ultralytics Platform gestisce l'intero processo: carica e annota un dataset, addestra nel cloud a partire dal checkpoint YOLO26n, poi esporta in NCNN e copia la cartella sul Pi.

Inizia con il modello nano, poi convalida l'accuratezza e misura la velocità del tuo modello personalizzato su filmati rappresentativi della videocamera che userai. I nostri consigli per l'addestramento dei modelli e la lezione dell'Academy su come scegliere la destinazione di deployment trattano gli altri aspetti.

Chi dovrebbe eseguire YOLO26 su una CPU Raspberry Pi 5#

Esegui YOLO26n sulla CPU della Pi 5 se usi una videocamera, puoi lavorare entro il frame rate misurato sull'intero dispositivo e vuoi ridurre al minimo i componenti necessari: una Raspberry Pi, una videocamera, una ventola e un alimentatore. Sono adatti anche i sistemi di cassa, le videocamere domestiche e per l'osservazione della fauna selvatica, il conteggio su nastri trasportatori e i prototipi di robotica.

Usa il runtime di Arm quando il rilevamento con YOLO26n è l'intero carico di lavoro e ogni millisecondo conta. Aggiungi un acceleratore se ti servono più videocamere, modelli più grandi o risorse CPU da riservare al resto dell'applicazione.

Ultralytics YOLO è disponibile con licenza AGPL-3.0 o con una Ultralytics Enterprise License. Consulta le opzioni di licenza di Ultralytics per scegliere quella adatta al tuo deployment.

Domande frequenti

  • Sì, per attività con una sola videocamera e frame rate moderati. Nel benchmark Ultralytics, YOLO26n esportato in NCNN impiega 67.03 ms per immagine nell'inferenza su una CPU Raspberry Pi 5 (esportazione FP32, input di 640 pixel), circa 15 FPS in inferenza. Separatamente, nel proprio confronto Arm ha misurato 36.60 ms per YOLO26n con il suo runtime open source: si tratta di un test diverso, non di un miglioramento rispetto al nostro risultato di 67.03 ms. L'acquisizione dalla videocamera e il disegno aggiungono tempo, quindi misura l'intera pipeline.

  • Nel test di confronto di Arm, il runtime YOLO26n di Optimized-Runtimes è stato il più veloce, con 36.60 ms per immagine contro 67.20 ms per NCNN. Nel nostro benchmark separato dei formati di esportazione Ultralytics, NCNN è stato il più veloce con 67.03 ms, davanti a MNN con 91.87 ms e OpenVINO con 104.55 ms. Si tratta di benchmark distinti, basati su dataset diversi, COCO128 e coco-128-by-sa di Arm, quindi i tempi non dimostrano un miglioramento della velocità tra i due test.

  • Sì. In un benchmark ONNX separato a 640 pixel su una Raspberry Pi 5, YOLO26n raggiunge 7.79 FPS contro i 6.79 FPS di YOLO11n, circa il 15% in più, ottenendo al contempo 40.1% mAP50-95 sulla validazione COCO contro 39.5%.

  • Non per una videocamera con frame rate moderati. Un acceleratore è utile con più flussi o modelli più grandi: nei nostri test, YOLO26n quantizzato su Hailo-8 AI HAT+ ha impiegato 21.7 ms per immagine nell'inferenza, contro 67.03 ms per l'esportazione NCNN FP32 sulla CPU. I risultati provengono da test distinti, con versioni e precisioni diverse.

  • Sì. Addestra il tuo modello in Python o su Ultralytics Platform, esportalo con format="ncnn", copia la cartella _ncnn_model sulla Pi e caricalo con YOLO("your_model_ncnn_model"). Aggiorna il percorso del modello nel codice della videocamera ed esegui un benchmark usando il tuo YAML del dataset e le tue classi. Il runtime di Arm converte anche checkpoint YOLO26n compatibili e ottimizzati con fine-tuning.

Scritto da

Onuralp Sezer
Onuralp Sezer

Senior Machine Learning Engineer · Ultralytics

Onuralp Sezer è Senior Machine Learning Engineer presso Ultralytics, dove lavora per far progredire le tecnologie di computer vision come YOLO e contribuisce allo sviluppo open source. Organizzatore di lunga data del Google Developer Group (GDG) e collaboratore open source, è attivo nella community di sviluppatori come relatore sui temi del machine learning e della computer vision e ha contribuito in precedenza al Fedora Project.

Commenti

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

Esplora le soluzioni

La visione artificiale nello sport

La visione artificiale nello sport

Scopri come Ultralytics YOLO alimenta la computer vision nello sport con il tracciamento di giocatori e palloni, l'analisi delle prestazioni, gli approfondimenti per gli allenatori e la riabilitazione degli atleti.
Scopri di più
Computer vision per immagini aeree

Computer vision per immagini aeree

Trasforma immagini aeree e riprese da drone in informazioni utili in tempo reale per agricoltura, acquacoltura, conservazione e analisi geospaziale con Ultralytics YOLO.
Scopri di più
Computer vision nel settore aerospaziale

Computer vision nel settore aerospaziale

Applica la visione artificiale nel settore aerospaziale con Ultralytics YOLO per l'ispezione degli aeromobili, il rilevamento di FOD sulle piste, le operazioni di terra aeroportuali e il rilevamento di difetti nei materiali compositi.
Scopri di più
Visione artificiale nella sicurezza

Visione artificiale nella sicurezza

Proteggi ogni sito con i modelli Ultralytics YOLO. L'IA visiva alimenta il monitoraggio perimetrale, il rilevamento delle minacce, il riconoscimento delle targhe e la sicurezza sul lavoro.
Scopri di più
Visione artificiale nella robotica

Visione artificiale nella robotica

Dai più potenza alle macchine intelligenti con i modelli Ultralytics YOLO. Nell'ambito della robotica, l'IA visiva alimenta la navigazione autonoma, la percezione, il tracciamento degli oggetti e il controllo in tempo reale.
Scopri di più
Visione artificiale nella logistica

Visione artificiale nella logistica

Semplifica la logistica con i modelli Ultralytics YOLO. L'IA per la visione consente l'ispezione dei pacchi, la selezione, il tracciamento dei veicoli e il monitoraggio della sicurezza nei magazzini in tempo reale.
Scopri di più
Visione artificiale nel commercio al dettaglio

Visione artificiale nel commercio al dettaglio

Ripensa il commercio al dettaglio con i modelli Ultralytics YOLO. L'IA per la visione consente di tracciare le scorte, monitorare gli scaffali, gestire le code e ottenere informazioni più approfondite sui clienti.
Scopri di più
Visione artificiale in ambito sanitario

Visione artificiale in ambito sanitario

Crea soluzioni sanitarie con i modelli Ultralytics YOLO. In ambito sanitario, l'IA per la visione consente di elaborare più rapidamente le immagini mediche, migliorare la diagnostica e monitorare i pazienti.
Scopri di più
Computer vision nella produzione

Computer vision nella produzione

Ottimizza la produzione con i modelli Ultralytics YOLO. La visione basata sull'IA migliora il controllo qualità, il rilevamento dei difetti, la conformità ai requisiti sui DPI e l'automazione delle linee di assemblaggio.
Scopri di più
Computer vision nel settore automobilistico

Computer vision nel settore automobilistico

Applica la computer vision al settore automobilistico con i modelli Ultralytics YOLO. La visione basata sull'IA migliora la sicurezza stradale, i sistemi di assistenza alla guida e l'automazione dei veicoli, per strade più intelligenti.
Scopri di più
Visione artificiale in agricoltura

Visione artificiale in agricoltura

Porta l'IA visiva nell'agricoltura intelligente con i modelli Ultralytics YOLO. Gestisci il monitoraggio delle colture, il tracciamento del bestiame e l'agricoltura di precisione per ottenere raccolti più abbondanti e intelligenti.
Scopri di più

Costruiamo insieme il futuro dell'IA!

Inizia il tuo percorso verso il futuro del machine learning