Ultralytics YOLO27 :

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

Raspberry Pi est un petit ordinateur abordable qui exécute Ultralytics YOLO26 pour la détection d’objets en temps réel à la périphérie — aucun GPU requis. 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 l’inférence la plus rapide sur ARM, et exécution de prédictions sur un flux vidéo provenant d’une caméra. Il inclut également des benchmarks de performance pour huit formats d’exportation afin que tu puisses 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 avec une caméra.



Watch: Raspberry Pi 5 updates and improvements.
Remarque

Ce guide a été testé avec 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 avec d’anciens appareils Raspberry Pi, comme le Raspberry Pi 3, devrait fonctionner tant que le même Raspberry Pi OS Bookworm est installé.

Qu’est-ce que Raspberry Pi ?#

Raspberry Pi est un petit ordinateur monocarte abordable. Il est devenu populaire pour un large éventail de projets et d’applications, de la domotique pour particuliers aux usages industriels. Les cartes Raspberry Pi peuvent exécuter différents systèmes d’exploitation et proposent des broches GPIO (entrée/sortie à usage général), qui permettent une intégration facile avec des capteurs, des actionneurs et d’autres composants matériels. Elles sont disponibles en différents modèles aux caractéristiques variées, mais partagent toutes la même philosophie de conception : être économiques, compactes et polyvalentes.

Comparaison des séries 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émoire1 Go de SDRAM LPDDR21 Go, 2 Go, 4 Go, 8 Go de SDRAM LPDDR4-32004 Go, 8 Go de SDRAM LPDDR4X-4267
PCIeN/AN/AInterface 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 pour la famille d’ordinateurs monocartes compacts Raspberry Pi, distribuée par la Raspberry Pi Foundation. Raspberry Pi OS est fortement optimisé pour les Raspberry Pi équipés de CPU ARM et utilise un environnement de bureau LXDE modifié avec le gestionnaire de fenêtres empilé Openbox. Raspberry Pi OS est activement développé, avec un accent mis 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 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 détaillée de démarrage 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#

La façon la plus rapide de commencer avec Ultralytics YOLO26 sur Raspberry Pi consiste à utiliser une image Docker préconfigurée pour Raspberry Pi.

Exécute la commande ci-dessous pour récupérer le conteneur Docker et l’exécuter sur Raspberry Pi. Elle 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’exportation de ton modèle vers NCNN.

Commencer sans Docker#

Installer le package Ultralytics#

Nous allons ici installer le paquet Ultralytics sur le Raspberry Pi. Les dépendances d’exportation pour 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 effectuer la mise à 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 de modèles pris en charge par Ultralytics, NCNN offre les meilleures performances d’inférence sur les appareils Raspberry Pi, car il est fortement optimisé pour les plateformes mobiles et 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")
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, comme le Raspberry Pi 5. Par rapport à YOLO11n, YOLO26n atteint une augmentation d’environ ~15 % des FPS (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 vers ONNX sur le 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
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

Benchmark réalisé avec Ultralytics 8.4.14.

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èles différents, en mesurant la vitesse et la précision : PyTorch, TorchScript, ONNX, OpenVINO, MNN, NCNN, ExecuTorch, LiteRT. Les benchmarks ont été réalisés sur un 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 grandes pour fonctionner sur les Raspberry Pi et n’offrent pas de performances satisfaisantes.

YOLO26 benchmarks on RPi 5
Benchmarked with Ultralytics 8.4.108

Tableau comparatif détaillé#

Le tableau ci-dessous présente les résultats des benchmarks de deux modèles différents (YOLO26n, YOLO26s) dans 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.

Performances
FormatStatutTaille sur le disque (Mo)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

Benchmark réalisé 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

# 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 sa charge actuelle 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 hors appareil

litert-converter ne fournit aucune roue Linux aarch64, l’exportation format=litert n’est donc prise en charge que sur Linux x86_64 et macOS, et non directement sur le Raspberry Pi. Exporte le modèle .tflite sur une machine Linux x86_64 ou un Mac, copie-le sur le Raspberry Pi, puis utilise le Pi pour l’inférence.

Utiliser la caméra Raspberry Pi#

Lorsque tu utilises Raspberry Pi pour des projets de vision par ordinateur, il peut être essentiel de récupérer des flux vidéo en temps réel pour effectuer l’inférence. Le connecteur MIPI CSI intégré au Raspberry Pi te permet de connecter les modules de caméra officiels Raspberry Pi. Dans ce guide, nous avons utilisé une 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

Le Raspberry Pi 5 utilise des connecteurs CSI plus petits que le Raspberry Pi 4 (15 broches contre 22), tu auras donc besoin d’un câble adaptateur 15 broches vers 22 broches pour 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 provenant de la caméra pendant environ 5 secondes.

rpicam-hello
Conseil

Inférence avec une 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, préinstallé avec Raspberry Pi OS, pour accéder à la caméra et exécuter l’inférence sur des 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()
Conseil

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

Bonnes pratiques pour utiliser Raspberry Pi#

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

  1. Utiliser un SSD

    Lorsque tu utilises un Raspberry Pi en continu 24 h/24 et 7 j/7, il est recommandé d’utiliser un SSD pour le système, car une carte SD ne pourra pas supporter les é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 for Raspberry Pi 5.

  2. Flasher sans interface graphique

    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 laisser davantage d’espace au traitement de vision par ordinateur.

  3. Overclocker Raspberry Pi

    Si tu veux un léger gain de performance lors de l'exécution des modèles Ultralytics YOLO26 sur Raspberry Pi 5, tu peux overclocker le processeur de sa base de 2,4 GHz à 3,0 GHz et le processeur graphique 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 réduction des performances thermiques.

    a. Mettre à niveau 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 en bas 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 ENTRÉE

    e. Redémarrer le Raspberry Pi

Prochaines étapes#

Tu as correctement configuré YOLO26 sur ton Raspberry Pi. Pour aller plus loin, explore le mode Predict pour découvrir d’autres options d’inférence, le mode Export pour utiliser d’autres formats de déploiement, ou le guide NVIDIA Jetson si tu as besoin de davantage 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 saluons leur travail pionnier et leur engagement éducatif 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 consulter leur site web.

FAQ#

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

    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émarre l'appareil pour appliquer les modifications :
      sudo reboot

    Pour obtenir des instructions détaillées, consulte la section Démarrer sans Docker.

  • Le format NCNN d'Ultralytics YOLO26 est fortement 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 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 à l'aide de commandes Python ou 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 principales différences sont les suivantes :

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

    Ces améliorations contribuent à de meilleures performances dans les benchmarks des modèles YOLO26 sur Raspberry Pi 5 par rapport à Raspberry Pi 4. Consulte le tableau Comparaison des séries Raspberry Pi pour plus de détails.

  • Il existe deux méthodes pour configurer une caméra Raspberry Pi afin d'effectuer des inférences 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 de configuration détaillées, consulte la section Inférence avec une caméra.

Commentaires