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.
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 3 | Raspberry Pi 4 | Raspberry Pi 5 | |
|---|---|---|---|
| CPU | SoC Broadcom BCM2837, Cortex-A53 64 bits | SoC Broadcom BCM2711, Cortex-A72 64 bits | SoC Broadcom BCM2712, Cortex-A76 64 bits |
| Fréquence maximale du CPU | 1.4GHz | 1.8GHz | 2.4GHz |
| GPU | VideoCore IV | VideoCore VI | VideoCore VII |
| Fréquence maximale du GPU | 400MHz | 500MHz | 800MHz |
| Mémoire | 1GB de SDRAM LPDDR2 | 1GB, 2GB, 4GB, 8GB de SDRAM LPDDR4-3200 | 2GB, 4GB, 8GB, 16GB de SDRAM LPDDR4X-4267 |
| PCIe | S. O. | S. O. | Interface PCIe 2.0 1x |
| Consommation électrique maximale | 2.5A@5V | 3A@5V | 5A@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 $tL'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.
-
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 -
Installer le package pip
ultralyticspip install ultralytics -
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é :
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 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.
| Modèle | mAP50-95(B) | Temps d’inférence (ms/im) |
|---|---|---|
| YOLO26n | 40.1 | 128.42 |
| YOLO26s | 47.8 | 352.84 |
| YOLO26m | 52.5 | 993.78 |
| YOLO26l | 54.4 | 1259.46 |
| YOLO26x | 56.9 | 2636.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.
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.
| Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d’inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4760 | 299.09 |
| TorchScript | ✅ | 9.8 | 0.4734 | 353.20 |
| ONNX | ✅ | 9.5 | 0.4734 | 125.99 |
| OpenVINO | ✅ | 9.6 | 0.4734 | 104.55 |
| LiteRT | ✅ | 9.8 | 0.4730 | 123.30 |
| MNN | ✅ | 9.4 | 0.4749 | 91.87 |
| NCNN | ✅ | 9.4 | 0.4784 | 67.03 |
| ExecuTorch | ✅ | 9.4 | 0.4772 | 144.83 |
Évalué avec Ultralytics 8.4.108
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 :
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 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.
Découvre-en plus sur les différents modules de caméra proposés par Raspberry Pi et sur la prise en main des modules de caméra Raspberry Pi.
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-helloDé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.
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.
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()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.
-
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.
-
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.
-
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-upgradeb. Ouvrir le fichier de configuration pour le modifier
sudo nano /boot/firmware/config.txtc. Ajouter les lignes suivantes à la fin du fichier
arm_freq=3000 gpu_freq=1000 force_turbo=1d. 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 :
- Mettre à jour la liste des paquets et installer
pip:sudo apt update sudo apt install python3-pip -y pip install -U pip - Installer le paquet Ultralytics :
pip install ultralytics - Redémarrer l'appareil pour appliquer les modifications :
sudo reboot
Pour obtenir des instructions détaillées, consulte la section Commencer sans Docker.
- Mettre à jour la liste des paquets et installer
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 :
Exemplefrom 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 :
-
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() -
Avec un flux TCP :
rpicam-vid -n -t 0 --inline --listen -o tcp://127.0.0.1:8888from 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.
-