Ultralytics YOLO27 :
Get Started

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

Raspberry Pi est un ordinateur compact et abordable qui exécute Ultralytics YOLO26 pour la détection d’objets en temps réel en périphérie — sans GPU. Ce guide t’accompagne dans le déploiement de YOLO26 sur Raspberry Pi 4 et 5 : installation du système d’exploitation, installation d’Ultralytics, exportation vers NCNN pour accélérer l’inférence sur ARM, et exécution de prédictions sur le flux d’une caméra en direct. Il comprend également des benchmarks de performance pour huit formats d’exportation afin de t’aider à choisir le meilleur compromis entre vitesse et précision pour ton matériel.

Accède directement à la section configuration d’Ultralytics, exportation vers NCNN et exécution de l’inférence, benchmarks ou inférence par caméra.



À regarder : Mises à jour et améliorations du Raspberry Pi 5.
Remarque

Ce guide a été testé avec Raspberry Pi 4 et Raspberry Pi 5 sous la dernière version de Raspberry Pi OS Bookworm (Debian 12). Il devrait également fonctionner sur les anciens appareils Raspberry Pi, comme le Raspberry Pi 3, à condition que la même version de Raspberry Pi OS Bookworm soit installée.

Qu’est-ce que Raspberry Pi ?#

Raspberry Pi est un ordinateur monocarte compact et abordable. Il est devenu populaire pour de nombreux projets et usages, de la domotique amateur aux applications industrielles. Les cartes Raspberry Pi peuvent exécuter différents systèmes d’exploitation et disposent de broches GPIO (entrée/sortie à usage général) qui facilitent l’intégration de capteurs, d’actionneurs et d’autres composants matériels. Elles sont proposées dans différents modèles aux caractéristiques variées, mais partagent toutes la même philosophie de conception : un faible coût, un format compact et une grande polyvalence.

Comparaison des modèles Raspberry Pi#

Raspberry Pi 3Raspberry Pi 4Raspberry Pi 5
CPUSoC Broadcom BCM2837, Cortex-A53 64 bitsSoC Broadcom BCM2711, Cortex-A72 64 bitsSoC Broadcom BCM2712, Cortex-A76 64 bits
Fréquence maximale du CPU1.4GHz1.8GHz2.4GHz
GPUVideoCore IVVideoCore VIVideoCore VII
Fréquence maximale du GPU400MHz500MHz800MHz
Mémoire1GB de SDRAM LPDDR21GB, 2GB, 4GB, 8GB de SDRAM LPDDR4-32002GB, 4GB, 8GB, 16GB de SDRAM LPDDR4X-4267
PCIeS. O.S. O.Interface PCIe 2.0 1x
Consommation électrique maximale2.5A@5V3A@5V5A@5V (PD activé)

Qu'est-ce que Raspberry Pi OS ?#

Raspberry Pi OS (anciennement appelé Raspbian) est un système d'exploitation de type Unix basé sur la distribution Debian GNU/Linux, conçu pour la famille d'ordinateurs compacts à carte unique Raspberry Pi distribués par la Raspberry Pi Foundation. Raspberry Pi OS est hautement optimisé pour le Raspberry Pi doté de CPU ARM et utilise un environnement de bureau léger qui fonctionne par défaut avec Wayland sur Raspberry Pi 4 et 5. Raspberry Pi OS est activement développé, avec pour objectif d'améliorer autant que possible la stabilité et les performances des paquets Debian sur Raspberry Pi.

Flasher Raspberry Pi OS sur Raspberry Pi#

La première chose à faire après avoir obtenu 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 sur le système d'exploitation. Suis la documentation de démarrage détaillée de Raspberry Pi pour préparer ton appareil à sa première utilisation.

Configurer Ultralytics#

Tu peux configurer le paquet Ultralytics sur Raspberry Pi de deux façons pour ton prochain projet de vision par ordinateur :

Commencer avec Docker#

Le moyen le plus rapide de démarrer avec Ultralytics YOLO26 sur Raspberry Pi consiste à utiliser une image Docker précompilée pour Raspberry Pi.

Exécute la commande ci-dessous pour récupérer le conteneur Docker et le lancer sur Raspberry Pi. Il est basé sur l’image officielle Python 3.13-slim-trixie, qui utilise Debian 13 avec Python 3.13.

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'exportation de ton modèle vers NCNN.

Commencer sans Docker#

Installer le package Ultralytics#

Nous allons installer ici le paquet Ultralytics sur Raspberry Pi. Les dépendances nécessaires à l'exportation vers des formats tels que NCNN sont installées automatiquement lors de la première exportation d'un modèle PyTorch ; seul le paquet de base est donc nécessaire ici.

  1. Mettre à jour la liste des packages, installer pip et le 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

    pip install ultralytics
  3. Redémarrer l’appareil

    sudo reboot

Utiliser NCNN sur Raspberry Pi#

Parmi tous les formats d'exportation 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 et embarquées telles que l'architecture ARM. Convertis ton modèle YOLO26n PyTorch en NCNN, puis lance l'inférence avec le modèle exporté :

Exemple
from ultralytics import YOLO

# Charger un modèle YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Exporter le modèle au format NCNN
model.export(format="ncnn")  # creates 'yolo26n_ncnn_model'

# Charger le modèle exporté au format NCNN
ncnn_model = YOLO("yolo26n_ncnn_model")

# Exécuter l’inférence
results = ncnn_model("https://ultralytics.com/images/bus.jpg")
Conseil

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

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

YOLO26 est spécialement conçu pour fonctionner sur des appareils aux ressources matérielles limitées, tels que Raspberry Pi 5. Par rapport à YOLO11n, YOLO26n augmente le nombre de FPS d'environ ~15 % (6.79 → 7.79), tout en offrant un mAP supérieur (40.1 contre 39.5), avec une taille d'entrée de 640 et des modèles exportés au format ONNX sur Raspberry Pi 5. Le tableau et le graphique ci-dessous présentent cette comparaison.

YOLO26 benchmarks on RPi 5
Évalué avec Ultralytics 8.4.14
Performances
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

Évalué avec Ultralytics 8.4.14.

Résultats des benchmarks de YOLO26 sur Raspberry Pi 5#

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

Graphique comparatif#

Nous avons inclus uniquement les benchmarks des modèles YOLO26n et YOLO26s, car les autres tailles de modèles sont trop volumineuses pour fonctionner sur les Raspberry Pi et n'offrent pas de performances satisfaisantes.

YOLO26 benchmarks on RPi 5
Évalué avec Ultralytics 8.4.108

Tableau comparatif détaillé#

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

Performances
FormatStatutTaille sur le disque (MB)mAP50-95(B)Temps d’inférence (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

Évalué avec Ultralytics 8.4.108

Remarque

Le temps d’inférence n’inclut pas le prétraitement ni le post-traitement.

Reproduire 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

# Charger un modèle YOLO26n PyTorch
model = YOLO("yolo26n.pt")

# Évaluer la vitesse et la précision de YOLO26n sur le jeu de données COCO128 dans tous les formats d’exportation
results = model.benchmark(data="coco128.yaml", imgsz=640)

Note que les résultats du benchmark peuvent varier selon la configuration matérielle et logicielle précise d’un système, ainsi que sa charge au moment de l’exécution des benchmarks. Pour obtenir les résultats les plus fiables, utilise un jeu de données contenant un grand nombre d’images, par exemple data='coco.yaml' (5000 images de validation).

L'exportation LiteRT s'effectue sur un autre appareil

L'exportation format=litert (via litert-torch) est prise en charge uniquement sous Linux x86_64 et macOS, et non sur Raspberry Pi. Exporte le modèle .tflite sur une machine Linux x86_64 ou un Mac, copie-le sur Raspberry Pi et utilise le Pi pour l'inférence.

Utiliser la caméra Raspberry Pi#

Pour les projets de vision par ordinateur utilisant Raspberry Pi, il peut être indispensable de récupérer des flux vidéo en temps réel afin d'effectuer l'inférence. Le connecteur MIPI CSI intégré au Raspberry Pi permet de brancher les modules de caméra officiels Raspberry Pi. Dans ce guide, nous avons utilisé un Raspberry Pi Camera Module 3 pour récupérer les flux vidéo et effectuer l'inférence avec des modèles YOLO26.

Conseil
Remarque

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

Tester la caméra#

Exécute la commande suivante après avoir branché 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
Conseil

Découvre-en plus sur l'utilisation de rpicam-hello dans la documentation officielle Raspberry Pi

Inférence avec une caméra#

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

Lancer l'inférence avec la caméra Raspberry Pi

Nous pouvons utiliser picamera2, préinstallé avec Raspberry Pi OS, pour accéder à la caméra et effectuer l'inférence avec des modèles YOLO26.

Exemple
import cv2
from picamera2 import Picamera2

from ultralytics import YOLO

# Initialiser 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()

# Charger le modèle YOLO26
model = YOLO("yolo26n.pt")

while True:
    # Capturer image par image
    frame = picam2.capture_array()

    # Exécuter l'inférence YOLO26 sur l'image
    results = model(frame)

    # Visualiser les résultats sur l’image
    annotated_frame = results[0].plot()

    # Afficher l'image résultante
    cv2.imshow("Camera", annotated_frame)

    # Interrompre la boucle si « q » est pressé
    if cv2.waitKey(1) == ord("q"):
        break

# Libérer les ressources et fermer les fenêtres
cv2.destroyAllWindows()
Conseil

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

Bonnes pratiques pour l'utilisation de Raspberry Pi#

Voici quelques bonnes pratiques à suivre pour obtenir des performances maximales sur les Raspberry Pi exécutant YOLO26.

  1. Utiliser un SSD

    Pour une utilisation continue 24 h/24 et 7 j/7 de Raspberry Pi, il est recommandé d'utiliser un SSD pour le système, car une carte SD ne résistera pas aux écritures continues et risque de tomber en panne. Grâce au connecteur PCIe intégré au 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. Flasher sans interface graphique

    Lorsque tu flashes 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 laisser davantage de ressources disponibles pour le traitement de la vision par ordinateur.

  3. Surcadencer Raspberry Pi

    Si tu souhaites obtenir un léger gain de performances lors de l'exécution des modèles Ultralytics YOLO26 sur Raspberry Pi 5, tu peux surcadencer le CPU de sa fréquence de base de 2.4GHz à 3.0GHz et le GPU de 800MHz à 1GHz. Si le système devient instable ou plante, réduis les valeurs de surcadencement par incréments de 100MHz. Veille à assurer un refroidissement adéquat, car le surcadencement augmente la chaleur produite et peut entraîner une limitation thermique.

    a. Mettre à jour les logiciels

    sudo apt update && sudo apt dist-upgrade

    b. Ouvrir le fichier de configuration pour le modifier

    sudo nano /boot/firmware/config.txt

    c. Ajouter les lignes suivantes à la fin du fichier

    arm_freq=3000
    gpu_freq=1000
    force_turbo=1

    d. Enregistrer et quitter en appuyant sur CTRL + X, puis sur Y, et enfin sur ENTER

    e. Redémarrer Raspberry Pi

Étapes suivantes#

Tu as correctement configuré YOLO26 sur ton Raspberry Pi. Pour aller plus loin, découvre le mode Predict et ses options d'inférence supplémentaires, le mode Export et ses formats de déploiement supplémentaires, ou le guide NVIDIA Jetson si tu as besoin de davantage de puissance de calcul en périphérie. Pour consulter la documentation complète, rends-toi sur la documentation Ultralytics YOLO26.

Remerciements et citations#

Ce guide a été initialement créé par Daan Eeltink pour Kashmir World Foundation, une organisation qui se consacre à l'utilisation de YOLO pour la préservation des espèces menacées. Nous saluons son travail pionnier et son engagement éducatif dans le domaine des technologies de détection d'objets.

Pour en savoir plus sur les activités de Kashmir World Foundation, tu peux consulter son site web.

FAQ#

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

    1. Mettre à jour la liste des paquets et installer pip :
      sudo apt update
      sudo apt install python3-pip -y
      pip install -U pip
    2. Installer le paquet Ultralytics :
      pip install ultralytics
    3. Redémarrer l'appareil pour appliquer les modifications :
      sudo reboot

    Pour obtenir des instructions détaillées, consulte 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 tirant parti de l'architecture ARM et fournit un traitement plus rapide et plus efficace que les autres formats. Pour plus de détails sur les formats d'exportation pris en charge, consulte les options d'exportation des modèles.

  • Tu peux convertir un modèle YOLO26 PyTorch au format NCNN avec Python ou des commandes CLI :

    Exemple
    from ultralytics import YOLO
    
    # Charger un modèle YOLO26n PyTorch
    model = YOLO("yolo26n.pt")
    
    # Exporter le modèle au format NCNN
    model.export(format="ncnn")  # creates 'yolo26n_ncnn_model'
    
    # Charger le modèle exporté au format NCNN
    ncnn_model = YOLO("yolo26n_ncnn_model")
    
    # Exécuter l’inférence
    results = ncnn_model("https://ultralytics.com/images/bus.jpg")

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

  • Les principales différences sont les suivantes :

    • CPU : Raspberry Pi 4 utilise un SoC 64 bits Broadcom BCM2711 Cortex-A72, tandis que Raspberry Pi 5 utilise un SoC 64 bits Broadcom BCM2712 Cortex-A76.
    • Fréquence maximale du CPU : la fréquence maximale de Raspberry Pi 4 est de 1.8GHz, tandis que celle de Raspberry Pi 5 atteint 2.4GHz.
    • Mémoire : le Raspberry Pi 4 offre jusqu’à 8 Go de SDRAM LPDDR4-3200, tandis que le Raspberry Pi 5 est équipé d’une SDRAM LPDDR4X-4267, disponible en versions 2 Go, 4 Go, 8 Go et 16 Go.

    Ces améliorations contribuent aux meilleurs résultats des modèles YOLO26 sur Raspberry Pi 5 par rapport au Raspberry Pi 4. Consulte le tableau Comparaison des séries Raspberry Pi pour en savoir plus.

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

    1. Avec 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. Avec 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 obtenir des instructions détaillées sur la configuration, consulte la section Inférence avec une caméra.

Commentaires