YOLO Vision 2026 :

Guide de démarrage rapide : Raspberry Pi avec Ultralytics YOLO26#

Raspberry Pi est un ordinateur petit et abordable qui fait tourner Ultralytics YOLO26 pour la détection d'objets en temps réel à la périphérie (edge), sans besoin de GPU. Ce guide t'accompagne dans le déploiement de YOLO26 sur Raspberry Pi 4 et 5 : flashage du système d'exploitation, installation d'Ultralytics, export vers NCNN pour l'inférence la plus rapide sur ARM, et exécution de prédictions sur un flux de caméra en direct. Il inclut également des benchmarks de performance sur huit formats d'exportation pour t'aider à choisir le meilleur compromis entre vitesse et précision pour ton matériel.

Passe directement à la configuration d'Ultralytics, à l'export vers NCNN et à l'exécution de l'inférence, aux benchmarks ou à l'inférence par caméra.



Watch: Raspberry Pi 5 updates and improvements.
Remarque

Ce guide a été testé avec les Raspberry Pi 4 et Raspberry Pi 5 exécutant la dernière version de Raspberry Pi OS Bookworm (Debian 12). L'utilisation de ce guide pour des appareils Raspberry Pi plus anciens, tels que le Raspberry Pi 3, devrait fonctionner tant que le même Raspberry Pi OS Bookworm est installé.

Qu'est-ce qu'un Raspberry Pi ?#

Raspberry Pi est un petit ordinateur monocarte abordable. Il est devenu populaire pour une large gamme de projets et d'applications, de la domotique amateur aux utilisations industrielles. Les cartes Raspberry Pi sont capables d'exécuter une variété de systèmes d'exploitation et offrent des broches GPIO (General Purpose Input/Output) qui permettent une intégration facile avec des capteurs, des actionneurs et d'autres composants matériels. Ils sont disponibles en différents modèles avec des spécifications variées, mais ils partagent tous la même philosophie de conception de base : être peu coûteux, compact et polyvalent.

Comparaison de la série Raspberry Pi#

Raspberry Pi 3Raspberry Pi 4Raspberry Pi 5
CPUBroadcom BCM2837, SoC Cortex-A53 64 bitsBroadcom BCM2711, SoC Cortex-A72 64 bitsBroadcom BCM2712, SoC Cortex-A76 64 bits
Fréquence max CPU1.4GHz1.8GHz2.4GHz
GPUVideocore IVVideocore VIVideoCore VII
Fréquence max GPU400Mhz500Mhz800Mhz
Mémoire1 Go LPDDR2 SDRAM1 Go, 2 Go, 4 Go, 8 Go LPDDR4-3200 SDRAM4 Go, 8 Go LPDDR4X-4267 SDRAM
PCIeN/AN/AInterface 1xPCIe 2.0
Consommation d'énergie max2,5 A@5V3 A@5V5 A@5V (PD activé)

Qu'est-ce que Raspberry Pi OS ?#

Raspberry Pi OS (anciennement connu sous le nom de Raspbian) est un système d'exploitation de type Unix basé sur la distribution Debian GNU/Linux pour la famille d'ordinateurs compacts monocarte Raspberry Pi distribuée par la Raspberry Pi Foundation. Raspberry Pi OS est hautement optimisé pour le Raspberry Pi doté de processeurs ARM et utilise un environnement de bureau LXDE modifié avec le gestionnaire de fenêtres empilé Openbox. Raspberry Pi OS fait l'objet d'un développement actif, en mettant l'accent sur l'amélioration de la stabilité et des performances du plus grand nombre possible de paquets Debian sur Raspberry Pi.

Flasher Raspberry Pi OS sur Raspberry Pi#

La première chose à faire après avoir pris en main un Raspberry Pi est de flasher une carte micro-SD avec Raspberry Pi OS, de l'insérer dans l'appareil et de démarrer le système d'exploitation. Suis la documentation de prise en main détaillée par Raspberry Pi pour préparer ton appareil lors de sa première utilisation.

Configurer Ultralytics#

Tu peux configurer le paquet Ultralytics sur Raspberry Pi de deux manières pour ton prochain projet de Computer Vision :

Démarrer avec Docker#

Le moyen le plus rapide de commencer avec Ultralytics YOLO26 sur Raspberry Pi est d'utiliser une image Docker pré-construite pour Raspberry Pi.

Exécute la commande ci-dessous pour récupérer le conteneur Docker et l'exécuter sur Raspberry Pi. Cela repose sur l'image Docker arm64v8/ubuntu, qui exécute Ubuntu 24.04 dans un environnement Python3.

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

L'image Docker inclut déjà Ultralytics, tu peux donc passer directement à l'export de ton modèle vers NCNN.

Démarrer sans Docker#

Installer le package Ultralytics#

Nous allons installer ici le paquet Ultralytics sur le Raspberry Pi avec des dépendances optionnelles afin de pouvoir exporter les modèles PyTorch vers d'autres formats.

  1. Mettre à jour la liste des packages, installer pip et mettre à niveau vers la dernière version

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
  2. Installer le package pip ultralytics avec les dépendances optionnelles

    pip install ultralytics[export]
  3. Redémarrer l'appareil

    sudo reboot

Utiliser NCNN sur Raspberry Pi#

Parmi tous les formats d'exportation de modèles pris en charge par Ultralytics, NCNN offre les meilleures performances d'inférence sur les appareils Raspberry Pi car il est hautement optimisé pour les plateformes mobiles/embarquées telles que l'architecture ARM. Convertis ton modèle PyTorch YOLO26n en NCNN, puis exécute l'inférence avec le modèle exporté :

Exemple
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")
Astuce

Pour plus de détails sur les options d'exportation prises en charge, consulte le guide des options de déploiement de modèles.

Améliorations des performances de YOLO26 par rapport à YOLO11#

YOLO26 est spécifiquement conçu pour fonctionner sur des appareils aux ressources matérielles limitées comme le Raspberry Pi 5. Comparé à YOLO11n, YOLO26n obtient une augmentation d'environ 15 % du nombre d'images par seconde (6,79 → 7,79) tout en offrant un mAP plus élevé (40,1 contre 39,5) avec une taille d'entrée de 640 pour les modèles exportés en ONNX sur Raspberry Pi 5. Le tableau et le graphique ci-dessous présentent cette comparaison.

YOLO26 benchmarks on RPi 5
Benchmarked with Ultralytics 8.4.14
Performance
ModèlemAP50-95(B)Temps d'inférence (ms/im)
YOLO26n40.1128.42
YOLO26s47.8352.84
YOLO26m52.5993.78
YOLO26l54.41259.46
YOLO26x56.92636.26

Benchmark réalisé avec Ultralytics 8.4.14.

Benchmarks YOLO26 sur Raspberry Pi 5#

Les benchmarks de YOLO26 ont été exécutés par l'équipe d'Ultralytics sur huit formats de modèles différents mesurant la vitesse et la précision : PyTorch, TorchScript, ONNX, OpenVINO, MNN, NCNN, ExecuTorch, LiteRT. Les benchmarks ont été exécutés sur un Raspberry Pi 5 en précision FP32 avec une taille d'image d'entrée par défaut de 640.

Tableau de comparaison#

Nous avons seulement inclus les benchmarks pour les modèles YOLO26n et YOLO26s car les autres tailles de modèles sont trop grandes pour fonctionner sur les Raspberry Pi et n'offrent pas de performances décentes.

YOLO26 benchmarks on RPi 5
Benchmarked with Ultralytics 8.4.108

Tableau de comparaison détaillé#

Le tableau ci-dessous représente les résultats des benchmarks pour deux modèles différents (YOLO26n, YOLO26s) sur huit formats différents (PyTorch, TorchScript, ONNX, OpenVINO, MNN, NCNN, ExecuTorch, LiteRT), exécutés sur un Raspberry Pi 5, en indiquant le statut, la taille, la métrique mAP50-95(B) et le temps d'inférence pour chaque combinaison.

Performance
FormatStatutTaille sur le disque (MB)mAP50-95(B)Temps d'inférence (ms/im)
PyTorch5.30.4760299.09
TorchScript9.80.4734353.20
ONNX9.50.4734125.99
OpenVINO9.60.4734104.55
MNN9.40.474991.87
NCNN9.40.478467.03
ExecuTorch9.40.4772144.83
LiteRT9.80.4730123.30

Testé avec Ultralytics 8.4.108

Remarque

Le temps d'inférence n'inclut pas le pré/post-traitement.

Reproduis nos résultats#

Pour reproduire les benchmarks Ultralytics ci-dessus sur tous les formats d'exportation, exécute ce code :

Exemple
from ultralytics import YOLO

# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")

# Benchmark YOLO26n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml", imgsz=640)

Note que les résultats des benchmarks peuvent varier en fonction de la configuration matérielle et logicielle exacte d'un système, ainsi que de la charge de travail actuelle du système au moment où les benchmarks sont exécutés. Pour obtenir les résultats les plus fiables, utilise un grand jeu de données d'images, par exemple data='coco.yaml' (5000 images de validation).

L'export LiteRT s'exécute hors de l'appareil

litert-converter ne fournit pas de wheel Linux aarch64, l'export format=litert n'est donc pris en charge que sur Linux x86_64 et macOS, et non sur le Raspberry Pi lui-même. Exporte le modèle .tflite sur une machine Linux x86_64 ou un Mac, copie-le sur le Raspberry Pi, et utilise le Pi pour l'inférence.

Utiliser la caméra Raspberry Pi#

Lors de l'utilisation du Raspberry Pi pour des projets de Computer Vision, il peut être essentiel de capturer des flux vidéo en temps réel pour effectuer des inférences. Le connecteur MIPI CSI intégré sur le Raspberry Pi te permet de connecter des modules de caméra Raspberry Pi officiels. Dans ce guide, nous avons utilisé un Raspberry Pi Camera Module 3 pour capturer les flux vidéo et effectuer des inférences à l'aide de modèles YOLO26.

Astuce
Remarque

Le Raspberry Pi 5 utilise des connecteurs CSI plus petits que le Raspberry Pi 4 (15 broches contre 22 broches), tu auras donc besoin d'un câble adaptateur de 15 broches à 22 broches pour le connecter à une caméra Raspberry Pi.

Tester la caméra#

Exécute la commande suivante après avoir connecté la caméra au Raspberry Pi. Tu devrais voir un flux vidéo en direct de la caméra pendant environ 5 secondes.

rpicam-hello
Astuce

Apprends-en plus sur l'utilisation de [rpicam-hello] dans la documentation officielle du Raspberry Pi.

Inférence avec la caméra#

Il existe deux méthodes pour utiliser la caméra Raspberry Pi afin d'exécuter l'inférence sur des modèles YOLO26.

Exécuter l'inférence avec la caméra Raspberry Pi

Nous pouvons utiliser picamera2, qui est préinstallé avec Raspberry Pi OS, pour accéder à la caméra et exécuter des inférences sur les modèles YOLO26.

Exemple
import cv2
from picamera2 import Picamera2

from ultralytics import YOLO

# Initialize the 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()

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

while True:
    # Capture frame-by-frame
    frame = picam2.capture_array()

    # Run YOLO26 inference on the frame
    results = model(frame)

    # Visualize the results on the frame
    annotated_frame = results[0].plot()

    # Display the resulting frame
    cv2.imshow("Camera", annotated_frame)

    # Break the loop if 'q' is pressed
    if cv2.waitKey(1) == ord("q"):
        break

# Release resources and close windows
cv2.destroyAllWindows()
Astuce

Consulte notre document sur les sources d'inférence si tu souhaites modifier le type d'entrée image/vidéo.

Bonnes pratiques lors de l'utilisation de Raspberry Pi#

Il existe quelques bonnes pratiques à suivre pour permettre une performance maximale sur les Raspberry Pis utilisant YOLO26.

  1. Utilise un SSD

    En cas d'utilisation continue 24h/24 et 7j/7 du Raspberry Pi, il est recommandé d'utiliser un SSD pour le système, car une carte SD ne supportera pas les écritures continues et risque de s'endommager. Grâce au connecteur PCIe intégré sur le Raspberry Pi 5, tu peux désormais connecter des SSD à l'aide d'un adaptateur tel que le NVMe Base pour Raspberry Pi 5.

  2. Flash sans interface graphique (GUI)

    Lors du flashage de Raspberry Pi OS, tu peux choisir de ne pas installer l'environnement de bureau (Raspberry Pi OS Lite), ce qui permet d'économiser un peu de RAM sur l'appareil et de libérer plus d'espace pour le traitement de la vision par ordinateur.

  3. Overclocker le Raspberry Pi

    Si tu souhaites un léger gain de performance lors de l'exécution des modèles Ultralytics YOLO26 sur Raspberry Pi 5, tu peux overclocker le CPU de sa base de 2,4 GHz à 2,9 GHz et le GPU de 800 MHz à 1 GHz. Si le système devient instable ou plante, réduis les valeurs d'overclocking par incréments de 100 MHz. Assure-toi qu'un refroidissement adéquat est en place, car l'overclocking augmente la production de chaleur et peut entraîner une limitation thermique.

    a. Mets à jour le logiciel

    sudo apt update && sudo apt dist-upgrade

    b. Ouvre le fichier de configuration pour le modifier

    sudo nano /boot/firmware/config.txt

    c. Ajoute les lignes suivantes en bas

    arm_freq=3000
    gpu_freq=1000
    force_turbo=1

    d. Enregistre et quitte en appuyant sur CTRL + X, puis Y, et appuie sur ENTREE

    e. Redémarre le Raspberry Pi

Prochaines étapes#

Tu as configuré avec succès YOLO26 sur ton Raspberry Pi. Pour aller plus loin, explore le mode Prédiction pour plus d'options d'inférence, le mode Export pour des formats de déploiement supplémentaires, ou le guide NVIDIA Jetson si tu as besoin de plus de puissance de calcul à la périphérie. Pour consulter la documentation complète, visite la documentation Ultralytics YOLO26.

Remerciements et Citations#

Ce guide a été initialement créé par Daan Eeltink pour la Kashmir World Foundation, une organisation dédiée à l'utilisation de YOLO pour la conservation des espèces menacées. Nous reconnaissons leur travail pionnier et leur orientation éducative dans le domaine des technologies de détection d'objets.

Pour plus d'informations sur les activités de la Kashmir World Foundation, tu peux visiter leur site Web.

FAQ#

  • Pour configurer Ultralytics YOLO26 sur un Raspberry Pi sans Docker, suis ces étapes :

    1. Mets à jour la liste des paquets et installe pip :
      sudo apt update
      sudo apt install python3-pip -y
      pip install -U pip
    2. Installe le paquet Ultralytics avec les dépendances optionnelles :
      pip install ultralytics[export]
    3. Redémarre l'appareil pour appliquer les changements :
      sudo reboot

    Pour des instructions détaillées, réfère-toi à la section Commencer sans Docker.

  • Le format NCNN d'Ultralytics YOLO26 est hautement optimisé pour les plateformes mobiles et embarquées, ce qui le rend idéal pour exécuter des tâches d'IA sur les appareils Raspberry Pi. NCNN maximise les performances d'inférence en exploitant l'architecture ARM, offrant un traitement plus rapide et plus efficace par rapport aux autres formats. Pour plus de détails sur les formats d'exportation pris en charge, consulte les options d'exportation de modèles.

  • Tu peux convertir un modèle PyTorch YOLO26 au format NCNN en utilisant soit Python, soit des commandes CLI :

    Exemple
    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")

    Pour plus de détails, consulte la section Utiliser NCNN sur Raspberry Pi.

  • Les différences clés incluent :

    • CPU : Le Raspberry Pi 4 utilise le Broadcom BCM2711, un SoC Cortex-A72 64 bits, tandis que le Raspberry Pi 5 utilise le Broadcom BCM2712, un SoC Cortex-A76 64 bits.
    • Fréquence CPU Max : Le Raspberry Pi 4 a une fréquence maximale de 1,8 GHz, alors que le Raspberry Pi 5 atteint 2,4 GHz.
    • Mémoire : Le Raspberry Pi 4 offre jusqu'à 8 Go de SDRAM LPDDR4-3200, tandis que le Raspberry Pi 5 dispose de SDRAM LPDDR4X-4267, disponible en variantes de 4 Go et 8 Go.

    Ces améliorations contribuent à de meilleurs benchmarks de performance pour les modèles YOLO26 sur Raspberry Pi 5 par rapport au Raspberry Pi 4. Réfère-toi au tableau Comparaison de la gamme Raspberry Pi pour plus de détails.

  • Il existe deux méthodes pour configurer une caméra Raspberry Pi pour l'inférence YOLO26 :

    1. Utilisation de 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. En utilisant un flux 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")

    Pour des instructions de configuration détaillées, visite la section Inférence avec caméra.

Commentaires