Détection d’objets sur Raspberry Pi : YOLO26 sur le CPU d’un Pi 5, sans accélérateur
YOLO26n s’exécute en 67,03 ms par image avec NCNN sur le CPU d’un Raspberry Pi 5, tandis que le runtime open source d’Arm mesure 36,60 ms lors de son propre test. Voici comment exécuter les deux.
Onuralp Sezer13 min de lecture
Un Raspberry Pi 5 peut-il effectuer de la détection d’objets uniquement avec son CPU, sans AI HAT ni accélérateur USB ? Oui. Lors de notre propre benchmark, Ultralytics YOLO26n exporté au format NCNN prend 67,03 ms d’inférence par image sur les quatre cœurs Arm Cortex-A76 du Pi 5, soit environ 15 images d’inférence par seconde. Arm a également publié un runtime open source conçu pour ce modèle et cette carte, qui atteint 36,60 ms par image lors de son propre test, soit environ 27 FPS d’inférence.
Cet article distingue les conditions qui sous-tendent chaque chiffre et explique ce que chacun révèle. Il détaille ensuite l’exécution de YOLO26n sur le CPU d’un Raspberry Pi 5, étape par étape, de l’installation à la caméra en direct, montre comment exécuter le runtime d’Arm sur la même carte et explique dans quels cas l’ajout d’un accélérateur reste pertinent.
Si tu découvres cette tâche, commence par découvrir ce qu’est la détection d’objets. Cette page explique comment la faire fonctionner sur un Pi.
Le runtime d’Arm exécute YOLO26n sur le CPU d’un Raspberry Pi 5 en 36,60 ms par image#
Le dépôt Optimized-Runtimes d’Arm regroupe des runtimes d’inférence optimisés par Arm pour des modèles et plateformes spécifiques. Le runtime actuellement répertorié permet la détection d’objets avec YOLO26n sur un Raspberry Pi 5. Chaque runtime se trouve dans son propre répertoire, qui contient sa compilation, sa conversion, ses exemples, ses benchmarks, ses tests et sa documentation de publication.
Le parcours d’apprentissage d’Arm compare son runtime à NCNN dans un même test : 36,60 ms par image pour le runtime d’Arm contre 67,20 ms pour NCNN, avec YOLO26n en 640 x 640, un batch de 1 et le jeu de données coco-128-by-sa d’Arm, composé de 128 images. La précision était proche : 0,4863 mAP50-95 pour le runtime d’Arm et 0,4902 pour NCNN. Ces durées correspondent à environ 27 FPS d’inférence contre environ 15, soit un débit supérieur d’environ 84 % pour le runtime d’Arm lors de ce test. Arm précise que son modèle NCNN utilisait des poids FP32 avec l’arithmétique FP16 activée.
Pour une équipe qui développe sur une carte limitée en coût et en puissance, réduire presque de moitié le temps d’inférence laisse davantage de marge par image pour la capture, le suivi et le reste de l’application. Ces mesures concernent uniquement l’inférence ; la capture, le prétraitement, le dessin et l’affichage s’ajoutent à chaque image : mesure donc l’ensemble de ton pipeline caméra sur l’appareil. Ce runtime prolonge également une collaboration abordée dans notre compte rendu d’Arm Create 2026, où Ultralytics YOLO a rejoint l’Arm AI Portal comme modèle préoptimisé dès son lancement.
Notre benchmark NCNN mesure YOLO26n à 67,03 ms par image sur un Raspberry Pi 5#
L’équipe Ultralytics a comparé YOLO26 sur un Raspberry Pi 5 avec huit formats d’exportation pour le guide Raspberry Pi. Conditions : modèles exportés en précision FP32, entrée par défaut de 640 pixels, Ultralytics 8.4.108, précision mesurée sur COCO128 et temps d’inférence uniquement, sans le prétraitement ni le post-traitement. Notre benchmark utilisait un export FP32. Le test NCNN distinct d’Arm activait l’arithmétique FP16. Les deux mesures NCNN, 67,03 ms et 67,20 ms, ne sont pas directement comparables.
NCNN était de loin le format d’exportation Ultralytics le plus rapide :
| Format YOLO26n | Temps d’inférence (ms/image) | mAP50-95(B), COCO128 |
|---|---|---|
| PyTorch | 299.09 | 0.4760 |
| ONNX | 125.99 | 0.4734 |
| LiteRT | 123.30 | 0.4730 |
| OpenVINO | 104.55 | 0.4734 |
| MNN | 91.87 | 0.4749 |
| NCNN | 67.03 | 0.4784 |
NCNN est environ 4,5 fois plus rapide que les poids PyTorch (67,03 ms contre 299,09 ms) et obtient un score de 0,4784 mAP50-95 sur COCO128, contre 0,4760 pour PyTorch. Le modèle plus grand YOLO26s prend 172,88 ms avec NCNN ; pour obtenir la fréquence d’images la plus élevée sur le CPU d’un Pi, commence donc par le modèle nano.
YOLO26 fait également mieux que son prédécesseur sur cette carte. Dans un benchmark ONNX distinct à 640 pixels, YOLO26n atteint 7,79 FPS contre 6,79 FPS pour YOLO11n, soit environ 15 % de plus, tout en obtenant 40,1 % mAP50-95 sur l’ensemble de validation COCO contre 39,5 % (Ultralytics 8.4.14). YOLO26 peut également s’exécuter sans suppression non maximale lorsqu’il est exporté avec nms=False vers des formats compatibles, comme ONNX et OpenVINO ; NCNN revient à la tête standard avec NMS, comme l’explique le guide de détection de bout en bout.
Compare les chiffres du Raspberry Pi uniquement dans des conditions équivalentes#
Le test d’Arm est utile, car il maintient le modèle, la taille d’entrée, le batch et le jeu de données constants d’un runtime à l’autre. Ce n’est pas le cas de la plupart des benchmarks sur Pi disponibles en ligne. Trois paramètres influent davantage que tout autre sur le résultat : la précision (FP32, FP16 ou INT8), la taille d’entrée et ce que le chronométrage inclut — uniquement la passe avant du modèle ou tout le parcours, de l’image aux boîtes finales.
La précision demande la même attention. Notre mAP est calculé sur COCO128, un échantillon de 128 images : vérifie donc la précision sur tes propres images de validation avant de déployer un modèle, surtout s’il est quantifié.
Exécute YOLO26n sur le CPU d’un Raspberry Pi 5 en cinq étapes#
Voici le parcours pris en charge le plus rapide avec le package Python Ultralytics. Il suppose que tu utilises un Raspberry Pi 5 avec Raspberry Pi OS 64 bits ; le guide Raspberry Pi explique comment flasher le système d’exploitation et configurer Docker.
- Installe Ultralytics dans un environnement virtuel. La version actuelle de Raspberry Pi OS bloque les installations de
pipdans Python système. Crée donc un environnement qui peut tout de même accéder à la bibliothèque caméra du système :
sudo apt update
sudo apt install -y python3-venv python3-picamera2 rpicam-apps
python3 -m venv --system-site-packages ~/yolo
source ~/yolo/bin/activate
pip install ultralytics- Exporte YOLO26n au format NCNN et teste-le. Le mode d’exportation crée un dossier
yolo26n_ncnn_modelque tu charges comme n’importe quel autre modèle :
from ultralytics import YOLO
# Effectue l’exportation une fois sur le Pi ; crée le dossier 'yolo26n_ncnn_model'
model = YOLO("yolo26n.pt")
model.export(format="ncnn")
# Charge le modèle NCNN et exécute-le sur le CPU
ncnn_model = YOLO("yolo26n_ncnn_model")
results = ncnn_model("https://ultralytics.com/images/bus.jpg")
print(results[0].speed) # temps de prétraitement, d’inférence et de post-traitement en ms
YOLO26n exporté au format NCNN, exécuté sur l’image de test bus.jpg de l’étape 2 : un bus et quatre personnes détectés. Mesure effectuée sur un CPU de bureau ; les boîtes et les scores peuvent légèrement différer sur un Pi.
- Connecte une caméra. Vérifie le flux avec
rpicam-hello. Le Pi 5 possède deux connecteurs caméra/écran à 22 broches ; les modules caméra à 15 broches nécessitent donc un câble adaptateur. - Lance la détection en direct.
picamera2transmet directement les images au modèle. La fenêtrecv2.imshownécessite une session de bureau ; sur un Pi sans interface graphique, supprime les lignes d’affichage et utilise plutôt les résultats dans le code :
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_ncnn_model")
while True:
frame = picam2.capture_array()
results = model(frame)
cv2.imshow("Camera", results[0].plot())
if cv2.waitKey(1) == ord("q"):
break
cv2.destroyAllWindows()- Effectue un benchmark sur ta carte.
yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640essaie chaque format d’exportation sur ton propre Pi pour que tu puisses voir les performances offertes par ton système de refroidissement, ton image de système d’exploitation et ton alimentation. Certains formats ne peuvent pas être exportés directement sur le Pi : LiteRT, par exemple, ne s’exporte que sur Linux x86_64 ou macOS. Exporte-le donc sur cette plateforme, copie le fichier sur le Pi et valide-le séparément. Pour obtenir des mesures de précision plus stables, utilise un jeu de validation plus grand, commedata=coco.yaml.
Exécute le runtime d’Arm à côté de NCNN sur le même Pi#
Le runtime d’Arm est un projet distinct, et non un format d’exportation Ultralytics ; ses instructions de configuration ciblent Raspberry Pi OS Trixie 64 bits avec Python 3.13. Pour l’essayer et le comparer à NCNN :
- Clone arm/Optimized-Runtimes, ouvre le répertoire
yolo26-raspberry-pi-5, suis ses prérequis et compile le runtime avecmake runtime. - Exécute
make example-videopour voir les détections sur une vidéo d’exemple. - Exécute
make ultralytics-benchmarkpour mesurer les performances du runtime d’Arm sur ta carte. - Exporte YOLO26n au format NCNN comme à l’étape 2 ci-dessus, puis valide-le sur le même jeu de données généré
coco-128-by-sa, en utilisant l’environnement, le point de contrôle et les commandes de la page de comparaison d’Arm, afin que les deux runtimes traitent les mêmes images à la même taille d’entrée. - Pour ton propre modèle, convertis un point de contrôle YOLO26n affiné et compatible avec
make model CHECKPOINT=/path/to/checkpoint.pt, comme l’explique la fiche du modèle du runtime, puis compare la précision sur ton propre jeu de validation ainsi que la vitesse.
Dans la comparaison d’Arm, son runtime était la méthode CPU la plus rapide pour la détection avec YOLO26n. L’exportation NCNN d’Ultralytics couvre le reste : les autres tailles et tâches YOLO26, y compris la segmentation et l’estimation de pose, avec les mêmes deux lignes de code, dans les limites indiquées dans le guide NCNN.
Le refroidissement, l’overclocking et un système d’exploitation allégé offrent des images supplémentaires#
Une fois le modèle opérationnel, c’est la carte qui fixe la limite. Les bonnes pratiques du guide Raspberry Pi indiquent ce qui peut aider :
- Refroidis la carte. Une inférence soutenue chauffe le CPU et la limitation thermique réduit la fréquence d’horloge supposée par ton benchmark. Un dissipateur thermique et un ventilateur stabilisent les temps de traitement des images.
- Overclocke si tu peux refroidir la carte. Certaines cartes Pi 5 font tourner le CPU à 3,0 GHz au lieu de sa fréquence de base de 2,4 GHz avec
arm_freq=3000etforce_turbo=1dans/boot/firmware/config.txt, puis un redémarrage. La stabilité varie d’une carte à l’autre ; si le système devient instable, réduis la fréquence de 100 MHz. - Évite l’interface de bureau. Raspberry Pi OS Lite laisse davantage de RAM disponible pour les tâches de vision.
- Utilise un SSD pour les exécutions 24 h/24 et 7 j/7. Une carte SD peut s’user en cas d’écritures continues ; le connecteur PCIe du Pi 5 permet de brancher un adaptateur NVMe.
- Réduis la taille d’entrée quand les objets sont grands. Une valeur
imgszplus petite signifie moins de pixels par image. Mesure l’effet sur la vitesse et la précision avec tes propres séquences vidéo, car les objets petits ou éloignés sont les premiers à en pâtir. Notre guide sur les FPS en vision par ordinateur explique comment définir un budget de fréquence d’images.
Ajoute un accélérateur si le CPU d’un seul Pi ne suffit pas#
Un Pi 5 utilisé uniquement avec son CPU convient à une caméra avec une fréquence d’images modérée. Pour plusieurs flux, des modèles plus grands ou davantage de marge pour les autres logiciels, un accélérateur décharge le CPU du modèle. Voici nos mesures du temps d’inférence de YOLO26n sur un Raspberry Pi 5 (inférence uniquement, COCO128), issues de tests distincts avec des modèles quantifiés et différentes versions d’Ultralytics :
- Hailo-8 sur l’AI HAT+ : 21,7 ms avec 0,455 mAP50-95, Ultralytics 8.4.174.
- Module M.2 DEEPX DX-M1 : 34,6 ms avec 0,4660 mAP50-95, Ultralytics 8.4.48.
- Coral Edge TPU : une option USB avec son propre parcours d’exportation ; les temps indiqués dans ce guide ont été mesurés avec des modèles YOLOv8.
Chaque solution ajoute du matériel, de la consommation électrique et une étape de compilation du modèle. Les modèles accélérés étant quantifiés, vérifie la précision après l’exportation. Pour une vue d’ensemble, consulte comment choisir le bon appareil edge et le guide NVIDIA Jetson si tu as besoin de plus de puissance de calcul que ce qu’offre un Pi.
Entraîne un détecteur personnalisé, puis déploie-le de la même manière#
Les 80 classes de COCO constituent un point de départ. La plupart des projets sur Pi nécessitent leurs propres objets : une pièce sur une chaîne de production, un produit sur une étagère, un nuisible sur une feuille. Ultralytics Platform gère l’ensemble du processus : téléverse et annote un jeu de données, entraîne dans le cloud à partir du point de contrôle YOLO26n, puis exporte au format NCNN et copie le dossier sur le Pi.
Commence par le modèle nano, puis valide la précision et mesure la vitesse de ton modèle personnalisé sur des séquences représentatives provenant de la caméra que tu vas déployer. Nos conseils pour l’entraînement de modèles et la leçon de l’Academy sur le choix d’une cible de déploiement couvrent le reste.
À qui s’adresse l’exécution de YOLO26 sur le CPU d’un Raspberry Pi 5 ?#
Exécute YOLO26n sur le CPU du Pi 5 si tu as une seule caméra, que tu peux te satisfaire de la fréquence d’images mesurée sur l’ensemble du pipeline de l’appareil et que tu veux une nomenclature aussi simple que possible : un Raspberry Pi, une caméra, un ventilateur et une alimentation. Cela convient aux caisses de magasins, aux caméras domestiques et de surveillance de la faune, au comptage sur convoyeur et aux prototypes de robotique.
Utilise le runtime d’Arm lorsque la détection avec YOLO26n constitue toute ta charge de travail et que chaque milliseconde compte. Ajoute un accélérateur si tu as besoin de plusieurs caméras, de modèles plus grands ou de réserver du temps CPU au reste de ton application.
Ultralytics YOLO est disponible sous AGPL-3.0 ou sous une licence Ultralytics Enterprise. Consulte les options de licence Ultralytics pour déterminer celle qui convient à ton déploiement.
Foire aux questions
Oui, pour des tâches utilisant une seule caméra à une fréquence d’images modérée. Dans le benchmark d’Ultralytics, YOLO26n exporté au format NCNN prend 67,03 ms d’inférence par image sur le CPU d’un Raspberry Pi 5 (exportation FP32, entrée de 640 pixels), soit environ 15 FPS d’inférence. Par ailleurs, Arm a mesuré 36,60 ms pour YOLO26n avec son runtime open source dans sa propre comparaison ; il s’agit d’un test différent, et non d’une accélération par rapport à notre résultat de 67,03 ms. La capture de la caméra et le dessin prennent du temps supplémentaire : mesure donc l’ensemble du pipeline.
Dans le test de comparaison d’Arm, son runtime YOLO26n Optimized-Runtimes était le plus rapide, à 36,60 ms par image contre 67,20 ms pour NCNN. Dans notre benchmark distinct des formats d’exportation Ultralytics, NCNN était le plus rapide, à 67,03 ms, devant MNN à 91,87 ms et OpenVINO à 104,55 ms. Ces benchmarks distincts utilisent des jeux de données différents, COCO128 et coco-128-by-sa d’Arm ; les temps mesurés ne permettent donc pas d’établir une accélération entre les deux tests.
Oui. Dans un benchmark ONNX distinct à 640 pixels sur un Raspberry Pi 5, YOLO26n atteint 7,79 FPS contre 6,79 FPS pour YOLO11n, soit environ 15 % de plus, tout en obtenant 40,1 % mAP50-95 sur l’ensemble de validation COCO contre 39,5 %.
Pas pour une seule caméra à une fréquence d’images modérée. Un accélérateur est utile pour plusieurs flux ou des modèles plus grands : lors de nos tests, un YOLO26n quantifié sur un AI HAT+ Hailo-8 prenait 21,7 ms d’inférence par image, contre 67,03 ms pour l’exportation NCNN FP32 exécutée sur le CPU. Ces mesures proviennent de tests distincts utilisant des versions et des précisions différentes.
Oui. Entraîne ton modèle avec Python ou sur Ultralytics Platform, exporte-le avec
format="ncnn", copie le dossier_ncnn_modelsur le Pi et charge-le avecYOLO("your_model_ncnn_model"). Mets à jour le chemin du modèle dans le code de la caméra et mesure ses performances avec ton propre fichier YAML de jeu de données et tes propres classes. Le runtime d’Arm convertit également les points de contrôle YOLO26n affinés compatibles.
Écrit par
Commentaires
Pose une question, partage tes résultats ou aide quelqu’un.










