Inizia

Guida rapida: Raspberry Pi con Ultralytics YOLO26

Raspberry Pi è un computer piccolo ed economico che esegue Ultralytics YOLO26 per il rilevamento di oggetti in tempo reale all'edge, senza bisogno di una GPU. Questa guida ti accompagna nella distribuzione di YOLO26 su Raspberry Pi 4 e 5: installazione del sistema operativo, installazione di Ultralytics, esportazione in NCNN per ottenere l'inferenza più rapida su ARM ed esecuzione di predizioni su un flusso video in diretta dalla videocamera. Include anche benchmark delle prestazioni per otto formati di esportazione, così puoi scegliere il compromesso migliore tra velocità e precisione per il tuo hardware.

Vai a configurare Ultralytics, esportare in NCNN ed eseguire l'inferenza, consultare i benchmark o eseguire l'inferenza dalla videocamera.



Guarda: Aggiornamenti e miglioramenti per Raspberry Pi 5.
Nota

Questa guida è stata testata con Raspberry Pi 4 e Raspberry Pi 5 con l'ultima versione di Raspberry Pi OS Bookworm (Debian 12). La guida dovrebbe funzionare anche sui dispositivi Raspberry Pi meno recenti, come Raspberry Pi 3, purché sia installata la stessa versione di Raspberry Pi OS Bookworm.

Che cos'è Raspberry Pi?#

Raspberry Pi è un computer a scheda singola, piccolo ed economico. È diventato popolare per una vasta gamma di progetti e applicazioni, dalla domotica amatoriale agli usi industriali. Le schede Raspberry Pi possono eseguire diversi sistemi operativi e offrono pin GPIO (ingresso/uscita per uso generale) che consentono una facile integrazione con sensori, attuatori e altri componenti hardware. Sono disponibili in diversi modelli con specifiche differenti, ma condividono tutti la stessa filosofia progettuale di base: essere economici, compatti e versatili.

Confronto tra le serie Raspberry Pi#

Raspberry Pi 3Raspberry Pi 4Raspberry Pi 5
CPUSoC Broadcom BCM2837, Cortex-A53 a 64 bitSoC Broadcom BCM2711, Cortex-A72 a 64 bitSoC Broadcom BCM2712, Cortex-A76 a 64 bit
Frequenza massima della CPU1.4GHz1.8GHz2.4GHz
GPUVideoCore IVVideoCore VIVideoCore VII
Frequenza massima della GPU400MHz500MHz800MHz
Memoria1GB LPDDR2 SDRAM1GB, 2GB, 4GB, 8GB LPDDR4-3200 SDRAM2GB, 4GB, 8GB, 16GB LPDDR4X-4267 SDRAM
PCIeN/DN/DInterfaccia PCIe 2.0 1x
Consumo massimo2.5A@5V3A@5V5A@5V (PD abilitato)

Che cos'è Raspberry Pi OS?#

Raspberry Pi OS (precedentemente noto come Raspbian) è un sistema operativo simile a Unix basato sulla distribuzione GNU/Linux Debian per la famiglia Raspberry Pi di computer compatti a scheda singola distribuiti dalla Raspberry Pi Foundation. Raspberry Pi OS è altamente ottimizzato per Raspberry Pi con CPU ARM e utilizza un ambiente desktop leggero che, per impostazione predefinita, gira su Wayland su Raspberry Pi 4 e 5. Raspberry Pi OS è in costante sviluppo, con l'obiettivo di migliorare la stabilità e le prestazioni del maggior numero possibile di pacchetti Debian su Raspberry Pi.

Installa Raspberry Pi OS su Raspberry Pi#

La prima cosa da fare dopo aver acquistato un Raspberry Pi è eseguire il flashing di una scheda micro-SD con Raspberry Pi OS, inserirla nel dispositivo e avviare il sistema operativo. Segui la documentazione introduttiva di Raspberry Pi per preparare il dispositivo al primo utilizzo.

Configura Ultralytics#

Puoi configurare il pacchetto Ultralytics su Raspberry Pi in due modi per il tuo prossimo progetto di visione artificiale:

Inizia con Docker#

Il modo più rapido per iniziare a usare Ultralytics YOLO26 su Raspberry Pi è eseguire un'immagine Docker precompilata per Raspberry Pi.

Esegui il comando seguente per scaricare il container Docker ed eseguirlo su Raspberry Pi. Si basa sull'immagine ufficiale di Python 3.13-slim, che esegue Python 3.13 sull'ultima versione di Debian.

t=ultralytics/ultralytics:latest-arm64
sudo docker pull $t && sudo docker run -it --ipc=host $t

L'immagine Docker include già Ultralytics, quindi puoi passare direttamente all'esportazione del tuo modello in NCNN.

Inizia senza Docker#

Installa il pacchetto Ultralytics#

Qui installeremo il pacchetto Ultralytics su Raspberry Pi. Le dipendenze di esportazione per formati come NCNN vengono installate automaticamente la prima volta che esporti un modello PyTorch, quindi qui è sufficiente il pacchetto di base.

  1. Aggiorna l'elenco dei pacchetti, installa pip e aggiorna pip all'ultima versione

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
  2. Installa il pacchetto pip ultralytics

    pip install ultralytics
  3. Riavvia il dispositivo

    sudo reboot

Usa NCNN su Raspberry Pi#

Tra tutti i formati di esportazione dei modelli supportati da Ultralytics, NCNN offre le migliori prestazioni di inferenza sui dispositivi Raspberry Pi perché è altamente ottimizzato per piattaforme mobili ed embedded come ARM. Converti il tuo modello YOLO26n PyTorch in NCNN, quindi esegui l'inferenza con il modello esportato:

Esempio
from ultralytics import YOLO

# Carica un modello YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Esporta il modello nel formato NCNN
model.export(format="ncnn")  # creates 'yolo26n_ncnn_model'

# Carica il modello esportato in NCNN
ncnn_model = YOLO("yolo26n_ncnn_model")

# Esegui l'inferenza
results = ncnn_model("https://ultralytics.com/images/bus.jpg")
Suggerimento

Per maggiori dettagli sulle opzioni di esportazione supportate, consulta la guida alle opzioni di distribuzione dei modelli.

Miglioramenti delle prestazioni di YOLO26 rispetto a YOLO11#

YOLO26 è progettato appositamente per funzionare su dispositivi con risorse hardware limitate, come Raspberry Pi 5. Rispetto a YOLO11n, YOLO26n offre un aumento di ~15% degli FPS (6.79 → 7.79) e una mAP superiore (40.1 contro 39.5), con dimensione di input 640 e modelli esportati in ONNX su Raspberry Pi 5. La tabella e il grafico seguenti illustrano il confronto.

YOLO26 benchmarks on RPi 5
Testato con Ultralytics 8.4.14
Prestazioni
ModellomAP50-95(B)Tempo di inferenza (ms/im)
YOLO26n40.1128.42
YOLO26s47.8352.84
YOLO26m52.5993.78
YOLO26l54.41259.46
YOLO26x56.92636.26

Test eseguiti con Ultralytics 8.4.14.

Benchmark di YOLO26 su Raspberry Pi 5#

Il team Ultralytics ha eseguito i benchmark di YOLO26 su otto formati di modello diversi, misurando velocità e precisione: PyTorch, TorchScript, ONNX, OpenVINO, LiteRT, MNN, NCNN, ExecuTorch. I benchmark sono stati eseguiti su Raspberry Pi 5 a precisione FP32 e con la dimensione predefinita dell'immagine di input pari a 640.

Grafico di confronto#

Sono inclusi solo YOLO26n e YOLO26s, perché i modelli più grandi sono troppo lenti per essere utilizzati concretamente su Raspberry Pi.

YOLO26 benchmarks on RPi 5
Testato con Ultralytics 8.4.108

Tabella di confronto dettagliata#

La tabella seguente mostra i risultati dei benchmark per due diversi modelli (YOLO26n, YOLO26s) in otto formati diversi (PyTorch, TorchScript, ONNX, OpenVINO, LiteRT, MNN, NCNN, ExecuTorch), eseguiti su Raspberry Pi 5, indicando lo stato, le dimensioni, la metrica mAP50-95(B) e il tempo di inferenza per ogni combinazione.

Prestazioni
FormatoStatoDimensioni su disco (MB)mAP50-95(B)Tempo di inferenza (ms/im)
PyTorch✅5.30.4760299.09
TorchScript✅9.80.4734353.20
ONNX✅9.50.4734125.99
OpenVINO✅9.60.4734104.55
LiteRT✅9.80.4730123.30
MNN✅9.40.474991.87
NCNN✅9.40.478467.03
ExecuTorch✅9.40.4772144.83

Test eseguiti con Ultralytics 8.4.108

Nota

Il tempo di inferenza non include la pre/post-elaborazione.

Riproduci i nostri risultati#

Per riprodurre i benchmark Ultralytics precedenti in tutti i formati di esportazione, esegui questo codice:

Esempio
from ultralytics import YOLO

# Carica un modello YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Esegui il benchmark di velocità e accuratezza di YOLO26n sul dataset COCO128 per tutti i formati di esportazione
results = model.benchmark(data="coco128.yaml", imgsz=640)

I risultati dei benchmark possono variare in base alla configurazione hardware e software esatta del sistema e al carico di lavoro del sistema al momento dell'esecuzione dei benchmark. Per ottenere risultati più affidabili, usa un dataset con un numero elevato di immagini, ad es. data='coco.yaml' (5000 immagini di convalida).

L'esportazione LiteRT viene eseguita fuori dal dispositivo

L'esportazione format=litert (tramite litert-torch) è supportata solo su Linux x86_64 e macOS, non direttamente su Raspberry Pi. Esporta il modello .tflite su un computer Linux x86_64 o un Mac, copialo su Raspberry Pi e usa il Pi per l'inferenza.

Usa la fotocamera Raspberry Pi#

I progetti di visione artificiale su Raspberry Pi richiedono spesso flussi video in tempo reale per l'inferenza. Il connettore MIPI CSI integrato di Raspberry Pi permette di collegare i moduli videocamera ufficiali Raspberry Pi. In questa guida abbiamo usato un Raspberry Pi Camera Module 3 per acquisire i flussi video ed eseguire l'inferenza con i modelli YOLO26.

Suggerimento
Nota

Raspberry Pi 5 usa connettori CSI più piccoli rispetto a Raspberry Pi 4 (22 pin contro 15), quindi per collegare una fotocamera Raspberry Pi ti serve un cavo adattatore da 15 a 22 pin.

Verifica la fotocamera#

Dopo aver collegato la videocamera a Raspberry Pi, esegui il comando rpicam-hello seguente. Dovresti vedere il flusso video in diretta della videocamera per circa 5 secondi.

rpicam-hello

Inferenza con la fotocamera#

Esistono due metodi per usare la fotocamera Raspberry Pi ed eseguire l'inferenza sui modelli YOLO26.

Esegui l'inferenza con la fotocamera Raspberry Pi

Usa picamera2, preinstallato con Raspberry Pi OS, per accedere alla videocamera ed eseguire l'inferenza con i modelli YOLO26.

Esempio
import cv2
from picamera2 import Picamera2

from ultralytics import YOLO

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

# Carica il modello YOLO26
model = YOLO("yolo26n.pt")

while True:
    # Acquisisci fotogramma per fotogramma
    frame = picam2.capture_array()

    # Esegui l'inferenza YOLO26 sul fotogramma
    results = model(frame)

    # Visualizza i risultati sul fotogramma
    annotated_frame = results[0].plot()

    # Visualizza il fotogramma risultante
    cv2.imshow("Camera", annotated_frame)

    # Interrompi il ciclo se viene premuto 'q'
    if cv2.waitKey(1) == ord("q"):
        break

# Rilascia le risorse e chiudi le finestre
cv2.destroyAllWindows()

Procedure consigliate per l'uso di Raspberry Pi#

Segui queste best practice per ottenere le massime prestazioni da YOLO26 su Raspberry Pi.

  1. Usa un SSD

    Per il funzionamento continuo 24/7, usa un SSD per il sistema, perché una scheda SD può usurarsi o guastarsi a causa delle scritture continue. Grazie al connettore PCIe integrato in Raspberry Pi 5, puoi collegare SSD usando un adattatore come NVMe Base for Raspberry Pi 5.

  2. Installa senza interfaccia grafica

    Quando installi Raspberry Pi OS, puoi scegliere di non installare l'ambiente desktop (Raspberry Pi OS Lite), risparmiando così un po' di RAM sul dispositivo e lasciando più risorse per l'elaborazione della visione artificiale.

  3. Overclock di Raspberry Pi

    Se vuoi migliorare leggermente le prestazioni durante l'esecuzione dei modelli Ultralytics YOLO26 su Raspberry Pi 5, puoi aumentare la frequenza della CPU dai 2.4GHz di base a 3.0GHz e quella della GPU da 800MHz a 1GHz. Se il sistema diventa instabile o si blocca, riduci i valori di overclock con incrementi di 100MHz. Assicurati che il raffreddamento sia adeguato, poiché l'overclock aumenta il calore generato e può causare thermal throttling.

    a. Aggiorna il software

    sudo apt update && sudo apt dist-upgrade

    b. Apri il file di configurazione per modificarlo

    sudo nano /boot/firmware/config.txt

    c. Aggiungi le righe seguenti in fondo

    arm_freq=3000
    gpu_freq=1000
    force_turbo=1

    d. Salva ed esci premendo CTRL + X, poi Y e infine INVIO

    e. Riavvia Raspberry Pi

Prossimi passaggi#

Hai configurato correttamente YOLO26 su Raspberry Pi. Per approfondire, esplora la modalità Predict per altre opzioni di inferenza, la modalità Export per ulteriori formati di distribuzione oppure la guida a NVIDIA Jetson se hai bisogno di maggiore potenza di calcolo edge. Per consultare la documentazione completa, visita la documentazione di Ultralytics YOLO26.

Ringraziamenti e citazioni#

Questa guida è stata creata inizialmente da Daan Eeltink per Kashmir World Foundation, un'organizzazione impegnata nell'uso di YOLO per la conservazione delle specie in via di estinzione. Riconosciamo il loro lavoro pionieristico e il loro impegno educativo nel campo delle tecnologie di rilevamento degli oggetti.

Per maggiori informazioni sulle attività di Kashmir World Foundation, puoi visitare il loro sito web.

Domande frequenti#

  • Per configurare Ultralytics YOLO26 su Raspberry Pi senza Docker, segui questi passaggi:

    1. Aggiorna l'elenco dei pacchetti e installa pip:
      sudo apt update
      sudo apt install python3-pip -y
      pip install -U pip
    2. Installa il pacchetto Ultralytics:
      pip install ultralytics
    3. Riavvia il dispositivo per applicare le modifiche:
      sudo reboot

    Per istruzioni dettagliate, consulta la sezione Inizia senza Docker.

  • NCNN è altamente ottimizzato per piattaforme mobili e integrate, il che lo rende un'ottima scelta per eseguire YOLO26 sui dispositivi Raspberry Pi. I suoi kernel ottimizzati per ARM garantiscono sul Pi un'inferenza più rapida rispetto agli altri formati di esportazione nei benchmark qui sopra.

  • Puoi convertire un modello PyTorch YOLO26 nel formato NCNN usando Python o i comandi CLI:

    Esempio
    from ultralytics import YOLO
    
    # Carica un modello YOLO26n PyTorch
    model = YOLO("yolo26n.pt")
    
    # Esporta il modello nel formato NCNN
    model.export(format="ncnn")  # creates 'yolo26n_ncnn_model'
    
    # Carica il modello esportato in NCNN
    ncnn_model = YOLO("yolo26n_ncnn_model")
    
    # Esegui l'inferenza
    results = ncnn_model("https://ultralytics.com/images/bus.jpg")

    Per maggiori dettagli, consulta la sezione Usa NCNN su Raspberry Pi.

  • Le differenze principali includono:

    • CPU: Raspberry Pi 4 usa il SoC Broadcom BCM2711 Cortex-A72 a 64 bit, mentre Raspberry Pi 5 usa il SoC Broadcom BCM2712 Cortex-A76 a 64 bit.
    • Frequenza massima della CPU: Raspberry Pi 4 ha una frequenza massima di 1.8GHz, mentre Raspberry Pi 5 raggiunge 2.4GHz.
    • Memoria: Raspberry Pi 4 offre fino a 8 GB di SDRAM LPDDR4-3200, mentre Raspberry Pi 5 dispone di SDRAM LPDDR4X-4267, disponibile nei tagli da 2 GB, 4 GB, 8 GB e 16 GB.

    Questi miglioramenti contribuiscono a ottenere benchmark prestazionali migliori per i modelli YOLO26 su Raspberry Pi 5 rispetto a Raspberry Pi 4. Consulta la tabella Confronto tra le serie Raspberry Pi per maggiori dettagli.

  • Esistono due metodi per configurare una fotocamera Raspberry Pi per l'inferenza con YOLO26:

    1. Usando picamera2:

      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.pt")
      
      while True:
          frame = picam2.capture_array()
          results = model(frame)
          annotated_frame = results[0].plot()
          cv2.imshow("Camera", annotated_frame)
      
          if cv2.waitKey(1) == ord("q"):
              break
      
      cv2.destroyAllWindows()
    2. Usando uno stream TCP:

      rpicam-vid -n -t 0 --inline --listen -o tcp://127.0.0.1:8888
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      results = model("tcp://127.0.0.1:8888")

    Per istruzioni dettagliate sulla configurazione, visita la sezione Inferenza con fotocamera.

Commenti134

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

    1. Glenn JocherUltralytics(modificato)

      Hi there!

      Thank you for your feedback and for sharing your positive experience on the Raspberry Pi 5! 😊

      Creating a tutorial for the AI kit that comes with the Raspberry Pi 5 is a fantastic idea. In the meantime, you can refer to our comprehensive Quick Start Guide for Raspberry Pi with Ultralytics YOLO26, which provides detailed instructions on setting up and running YOLO on Raspberry Pi devices, including performance benchmarks.

      For those interested in using the AI kit, the setup process should be quite similar. Here’s a quick overview to get you started:

      1. Flash Raspberry Pi OS: Ensure you have the latest Raspberry Pi OS Bookworm (Debian 12) installed. Follow the Getting Started Documentation by Raspberry Pi to prepare your device.

      2. Set Up Ultralytics:

        • With Docker:
          t=ultralytics/ultralytics:latest-arm64 && sudo docker pull $t && sudo docker run -it --ipc=host $t
        • Without Docker:
          sudo apt update
          sudo apt install python3-pip -y
          pip install -U pip
          pip install ultralytics[export]
          sudo reboot
      3. Use NCNN for Best Performance: Convert your YOLO26 model to NCNN format for optimal performance on Raspberry Pi:

        from ultralytics import YOLO
        
        # Load a YOLO26n PyTorch model
        model = YOLO("yolo26n.pt")
        
        # Export the model to NCNN format
        model.export(format="ncnn")  # creates 'yolo26n_ncnn_model'
        
        # Load the exported NCNN model
        ncnn_model = YOLO("yolo26n_ncnn_model")
        
        # Run inference
        results = ncnn_model("https://ultralytics.com/images/bus.jpg")
      4. Using the Raspberry Pi Camera: For real-time video feeds, you can use the picamera2 library or set up a TCP stream:

        • Using picamera2:

          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.pt")
          
          while True:
              frame = picam2.capture_array()
              results = model(frame)
              annotated_frame = results[0].plot()
              cv2.imshow("Camera", annotated_frame)
              if cv2.waitKey(1) == ord("q"):
                  break
          
          cv2.destroyAllWindows()
        • Using TCP Stream:

          rpicam-vid -n -t 0 --inline --listen -o tcp://127.0.0.1:8888
          from ultralytics import YOLO
          
          model = YOLO("yolo26n.pt")
          results = model("tcp://127.0.0.1:8888")

      We hope this helps you get started with the AI kit on your Raspberry Pi 5. For more detailed instructions and additional resources, please visit our Raspberry Pi Guide.

      Happy coding! 🚀

  1. wnelisGitHub

    Today I've installed module ultralytics on a Raspberry Pi 4 with 4 [GiB] memory running Trixie. Some remarks about what I've learned: . Use the 64-bit variant of Raspberry OS; . Use an microSD card of at least 32 [GiB]; . Disable /tmp becoming a file system in memory (tmpfs): sudo systemctl mask tmp.mount; . OpenCV is installed using apt, module ultralytics is installed in a virtual Python environment: 'python -m venv --system-site-packages `.

    It is found that YOLO runs into a hardware error: "Illegal instruction". This can be reproduced by using the Python script shown above to export the model in NCNN format. The output is:

    Downloading https://github.com/ultralyti…: 100% ━━━━━━━━━━━━ 5.3MB 1.4MB/s 3.8s Ultralytics 8.4.191 🚀 Python-3.13.5 torch-2.14.1+cu130 CPU (aarch64) Illegal instruction

    How can this issue be solved?

    1. Paula DerrengerUltralytics

      @wnelis the most likely cause is a native PyTorch binary using instructions unsupported by the Pi 4’s CPU, rather than faulty hardware; similar crashes are documented in Ultralytics #19091 and upstream PyTorch, although your exact version is not confirmed affected. (github.com) Your log shows a CUDA build (+cu130); first replace it with the matching official CPU-only packages inside your activated virtual environment, then retry the export: (pytorch.org)

      python -m pip install --force-reinstall torch==2.14.1 torchvision==0.29.1 --index-url https://download.pytorch.org/whl/cpu

      If it still crashes, please share the text output of yolo checks and python -m pip show torch torchvision from that same environment so we can identify package/path conflicts.

  2. hm-zerooneGitHub(modificato)

    "We haven’t validated Orbit OS yet, but if it supports tflite or onnx runtimes you should be able to deploy an exported Ultralytics YOLO26 model there using Export mode and the deployment options guide; if you try it, please share the exact device, export format, and any text error logs here in Discussions so the Ultralytics team can take a look."

    Hi @glenn-jocher,

    I added a new feature to my Orbit OS app to test YOLO models directly on edge devices, in this case a Raspberry Pi. The app now allows adding new models, and by default includes YOLO v8, v11 and v26.

    We also introduced a benchmark mode, where you can select an image and run all models to compare performance and results.

    localhost_9005_ (1)

    In the example shown in the image, YOLOv8 achieved the highest number of correct object detections by time.

    This demo video shows the remote deployment, no SSH, no Docker, of the app in action on Raspberry Pi 5 vs Arduino UNO Q and a comparison (“VS”) between the RPi 5 and UNO Q running YOLO v8. https://youtu.be/aiFJmosYVAI?si=v3Jo_TbswU3n-sZU

    1. Glenn JocherUltralytics

      Thanks for sharing the Orbit OS benchmark; for a fair cross-model comparison please include the exact export/runtime backend, imgsz, confidence/IoU thresholds, and per-image latency/FPS, since on Raspberry Pi CPU deployments NCNN is usually the best baseline for YOLO26.

    2. hm-zerooneGitHub(modificato)

      Hey! Thanks for the feedback. All models were tested under the same conditions — TFlite runtime, same image, same thresholds (conf=0.50, IoU=0.45), same imgsz 640×640 with letterbox preprocessing.

      Everything runs through the OrbitOS SDK which currently has TFLite and ONNX embedded. NCNN is something we'll look into adding in a future release.

      Quick question — for RPi deployments, would you recommend INT8 or float16 as the default export format?

      Orbit OS SDK 26.0.1 Inference example.

      Orbit OS is multi-language — For now only Go SDK is available, Python, Java and C++ SDKs are coming soon.

      image

      
      model, _ := device.AIManager.UploadAndLoadModel(
          "yolo8n",
          "models/yolo26n_float16.tflite",
          aiv26.ModelBackend_TFLITE,
          aiv26.ExecutionMode_EXEC_HIGH_THREADS,
      )
      
      resp, _ := model.Infer(ctx, tensor.Data, tensor.Shape, tensor.Dtype)
      
      fmt.Println(resp.GetOutputShape())  // [1 84 8400]
      fmt.Println(resp.GetLatencyUs())    // e.g. 528000
    3. Glenn JocherUltralytics(modificato)

      For plain Raspberry Pi CPU deployment with LiteRT (.tflite), I’d usually default to INT8 for the best speed and memory savings, and use float16 only if quantization hurts accuracy too much or your runtime performs better with FP kernels; if you benchmark both, the LiteRT export guide is the right reference, while our Raspberry Pi guide shows NCNN as the strongest baseline once you add that backend.

      1
  3. safdarhamid64-cpuGitHub

    when i write in raspberry pi terminal : from ultralytics import yolo error msg illegal instruction pops up , i have trained model and even i have first created environment and installed pip install ultralytics but still i am not able to run model yolo11n on my Raspberry Pi 4 , Guide me plzz

    1. Glenn JocherUltralytics

      That Illegal instruction on Raspberry Pi usually means an incompatible binary wheel (most often torch/numpy pulled for the wrong arch/OS), and also note the correct import is from ultralytics import YOLO (capitalized), not yolo; please paste the text output of yolo checks plus the full traceback here in this discussion, and confirm uname -m + whether you’re on Raspberry Pi OS Bookworm 64-bit as in the Raspberry Pi YOLO26 guide; as a quick way to rule out env issues you can also try our ARM64 Docker flow from that guide:```bash t=ultralytics/ultralytics:latest-arm64 sudo docker pull $t && sudo docker run -it --ipc=host $t python -c "from ultralytics import YOLO; YOLO('yolo11n.pt')"

  4. inuropixGitHub

    Hi.. I get an error when implement botsort with reid is True and the model is ncnn(exported from yolo26n-cls.pt)

    Here’s the full traceback from the error:

        self.tracks = self.model.track(
                      ^^^^^^^^^^^^^^^^^
     File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/engine/model.py", line 579, in track
        return self.predict(source=source, stream=stream, **kwargs)
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/engine/model.py", line 536, in predict
        return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream)
                                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/engine/predictor.py", line 225, in __call__
        return list(self.stream_inference(source, model, *args, **kwargs))  # merge list of Results into one
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/home/sbr/people_counting/lib/python3.11/site-packages/torch/utils/_contextlib.py", line 40, in generator_context
        response = gen.send(None)
                   ^^^^^^^^^^^^^^
      File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/engine/predictor.py", line 338, in stream_inference
        self.run_callbacks("on_predict_postprocess_end")
      File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/engine/predictor.py", line 509, in run_callbacks
        callback(self)
      File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/trackers/track.py", line 93, in on_predict_postprocess_end
        tracks = tracker.update(det, result.orig_img, getattr(result, "feats", None))
                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/trackers/byte_tracker.py", line 361, in update
        dists = self.get_dists(unconfirmed, detections)
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/trackers/bot_sort.py", line 220, in get_dists
        emb_dists = matching.embedding_distance(tracks, detections) / 2.0
                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/home/sbr/people_counting/lib/python3.11/site-packages/ultralytics/trackers/utils/matching.py", line 128, in embedding_distance
        cost_matrix = np.maximum(0.0, cdist(track_features, det_features, metric))  # Normalized features
                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
      File "/home/sbr/people_counting/lib/python3.11/site-packages/scipy/spatial/distance.py", line 2903, in cdist
        raise ValueError('XA must be a 2-dimensional array.')
    ValueError: XA must be a 2-dimensional array.

    Any idea?

    1. Glenn JocherUltralytics

      That traceback usually means BoT-SORT didn’t get valid (2D) ReID embeddings; also note that .track() should run with a Detect/Seg/Pose model, while yolo26n-cls is only meant to be the ReID feature extractor configured inside botsort.yaml (via with_reid/model). (docs.ultralytics.com)

      yolo track model=yolo26n.pt source=path/to/video.mp4 tracker="botsort.yaml"
      # in a copy of botsort.yaml
      with_reid: True
      model: yolo26n-cls.pt  # first confirm this works before swapping to an exported backend

      If you just need stable tracking on Raspberry Pi, try tracker="bytetrack.yaml" (no ReID); if you still hit this, please paste your botsort.yaml and the output of yolo checks so we can reproduce from the same environment. (docs.ultralytics.com)

  5. hananabuzainabGitHub

    I can't install ultralytics on rasspbery pi 5...with python 3.11 version,why??

    I used: pip install ultralytics

    How can i fix this problem ??

    1. Glenn JocherUltralytics

      Can you paste the full pip install ultralytics error text (as text, not a screenshot) and the output of python3 -V here so we can pinpoint what’s failing? On Raspberry Pi 5 this is most often a Python/pip mismatch or non-Bookworm/32-bit setup—please also confirm you’re on Raspberry Pi OS Bookworm 64-bit as in the Raspberry Pi with Ultralytics YOLO26 guide.

      python3 -V
      python3 -m pip install -U pip setuptools wheel
      python3 -m venv .venv
      source .venv/bin/activate
      python -m pip install -U pip
      python -m pip install ultralytics
  6. avasanjeshGitHub

    Hi,

    I want to use python version of raspberry pi 32 bit OS. can you please tell me if i can export yolo detection model in 32 bit raspberry pi?

  7. Edward-YSGitHub

    Hello,I'm wondering if there is Benchmarking Results of Two Different Models (YOLO8n, YOLO8s) Across Ten Formats: PyTorch, TF, ONNX, OpenVINO, TF SavedModel, TF GraphDef, TF Lite, PaddlePaddle, MNN, NCNN.

  8. zyt2011GitHub

    Installing a single Hailo-5 is sufficient.


    发件人: Beautifulboy111 @.> 发送时间: 2025年4月22日 14:24 收件人: ultralytics/ultralytics @.> 抄送: zyt2011 @.>; Mention @.> 主题: Re: [ultralytics/ultralytics] zh/guides/raspberry-pi/ (Discussion #19489)

    Why does my Raspberry Pi 5 have a high inference latency of 150ms when using NCNN for video recognition, even after overclocking? How can I reduce the inference time?

    ― Reply to this email directly, view it on GitHubhttps://github.com/orgs/ultralytics/discussions/19489#discussioncomment-12906311, or unsubscribehttps://github.com/notifications/unsubscribe-auth/BJ7DFR53TAD7QVJNO3TTXJL22XOAJAVCNFSM6AAAAABYEEJCHCVHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTEOJQGYZTCMI. You are receiving this because you were mentioned.Message ID: @.***>

    1. Glenn JocherUltralytics(modificato)

      @Beautifulboy111 150ms inference latency with NCNN on Raspberry Pi 5 is higher than expected. Here are some steps to reduce it:

      1. Use a smaller YOLO26 model - our benchmarks show YOLO26n is significantly faster than YOLO26s with NCNN on Pi 5 (67ms vs 173ms)

      2. Reduce input resolution - try 320x320 instead of 640x640, which can cut inference time by up to 70%

      3. Optimize memory allocation by running without GUI (Raspberry Pi OS Lite)

      4. Ensure you're using proper cooling for sustained performance when overclocked

      5. Consider processing at lower FPS if your application allows it

      Regarding @zyt2011's suggestion, while accelerators like Hailo can boost performance, they're a separate investment. I'd recommend optimizing your current setup first using the techniques in our Raspberry Pi guide.

      What's your specific use case? This would help us provide more targeted optimization advice.

  9. Beautifulboy111GitHub

    Why does my Raspberry Pi 5 have a high inference latency of 150ms when using NCNN for video recognition, even after overclocking? How can I reduce the inference time?