Licence YOLO
Guides

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 SezerOnuralp Sezer13 min de lecture
Liste des formats d’exportation d’Ultralytics Platform, avec la ligne NCNN mise en évidence au-dessus de MNN, le format recommandé pour exécuter YOLO26 sur le CPU d’un Raspberry Pi 5

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 YOLO26nTemps d’inférence (ms/image)mAP50-95(B), COCO128
PyTorch299.090.4760
ONNX125.990.4734
LiteRT123.300.4730
OpenVINO104.550.4734
MNN91.870.4749
NCNN67.030.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.

  1. Installe Ultralytics dans un environnement virtuel. La version actuelle de Raspberry Pi OS bloque les installations de pip dans 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
  1. Exporte YOLO26n au format NCNN et teste-le. Le mode d’exportation crée un dossier yolo26n_ncnn_model que 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

Modèle YOLO26n NCNN détectant un bus et quatre personnes dans une rue en ville

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.

  1. 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.
  2. Lance la détection en direct. picamera2 transmet directement les images au modèle. La fenêtre cv2.imshow né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()
  1. Effectue un benchmark sur ta carte. yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640 essaie 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, comme data=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 :

  1. Clone arm/Optimized-Runtimes, ouvre le répertoire yolo26-raspberry-pi-5, suis ses prérequis et compile le runtime avec make runtime.
  2. Exécute make example-video pour voir les détections sur une vidéo d’exemple.
  3. Exécute make ultralytics-benchmark pour mesurer les performances du runtime d’Arm sur ta carte.
  4. 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.
  5. 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=3000 et force_turbo=1 dans /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 imgsz plus 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_model sur le Pi et charge-le avec YOLO("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

Onuralp Sezer
Onuralp Sezer

Ingénieur senior en apprentissage automatique · Ultralytics

Onuralp Sezer est ingénieur senior en apprentissage automatique chez Ultralytics, où il travaille à faire progresser les technologies de vision par ordinateur telles que YOLO et contribue au développement open source. Organisateur de longue date du Google Developer Group (GDG) et contributeur open source, il est actif dans la communauté des développeurs en tant qu'intervenant spécialisé en apprentissage automatique et en vision par ordinateur, et a déjà contribué au Fedora Project.

Commentaires

Pose une question, partage tes résultats ou aide quelqu’un.

Découvre les solutions

La vision par ordinateur dans le sport

La vision par ordinateur dans le sport

Découvre comment Ultralytics YOLO propulse la vision par ordinateur dans le sport grâce au suivi des joueurs et du ballon, aux analyses de performance, aux conseils d’entraînement et à la rééducation des athlètes.
En savoir plus
Vision par ordinateur pour les images aériennes

Vision par ordinateur pour les images aériennes

Transforme les images de drones et les images aériennes en informations exploitables en temps réel pour l’agriculture, l’aquaculture, la conservation et l’analyse géospatiale avec Ultralytics YOLO.
En savoir plus
Vision par ordinateur dans l’aérospatiale

Vision par ordinateur dans l’aérospatiale

Applique la vision par ordinateur dans l’aérospatiale avec Ultralytics YOLO pour l’inspection des aéronefs, la détection des corps étrangers sur les pistes, les opérations au sol des aéroports et la détection des défauts des matériaux composites.
En savoir plus
La vision par ordinateur dans la sécurité

La vision par ordinateur dans la sécurité

Protège chaque site avec les modèles Ultralytics YOLO. L’IA visuelle permet la surveillance des périmètres, la détection des menaces, la reconnaissance des plaques d’immatriculation et la sécurité au travail.
En savoir plus
La vision par ordinateur en robotique

La vision par ordinateur en robotique

Donne plus de capacités à tes machines grâce aux modèles Ultralytics YOLO. Dans la robotique, l’IA visuelle permet la navigation autonome, la perception, le suivi des objets et le contrôle en temps réel.
En savoir plus
La vision par ordinateur dans la logistique

La vision par ordinateur dans la logistique

Optimise la logistique avec les modèles Ultralytics YOLO. La vision par IA permet d’inspecter les colis, de les trier, de suivre les véhicules et de surveiller la sécurité des entrepôts en temps réel.
En savoir plus
La vision par ordinateur dans le commerce de détail

La vision par ordinateur dans le commerce de détail

Réinvente le commerce de détail avec les modèles Ultralytics YOLO. La vision par IA permet de suivre les stocks, de surveiller les rayons, de gérer les files d’attente et de mieux comprendre les clients.
En savoir plus
La vision par ordinateur dans le secteur de la santé

La vision par ordinateur dans le secteur de la santé

Crée des solutions de santé avec les modèles Ultralytics YOLO. La vision par IA dans le secteur de la santé accélère l’imagerie médicale, améliore les diagnostics et facilite la surveillance des patients.
En savoir plus
La vision par ordinateur dans l’industrie manufacturière

La vision par ordinateur dans l’industrie manufacturière

Optimise la fabrication avec les modèles Ultralytics YOLO. La vision par IA améliore le contrôle qualité, la détection des défauts, le respect des règles concernant les EPI et l’automatisation des chaînes de montage.
En savoir plus
La vision par ordinateur dans l’automobile

La vision par ordinateur dans l’automobile

Mets la vision par ordinateur au service de l’automobile avec les modèles Ultralytics YOLO. La vision par IA renforce la sécurité routière, l’aide à la conduite et l’automatisation des véhicules pour des routes plus intelligentes.
En savoir plus
Vision par ordinateur dans l’agriculture

Vision par ordinateur dans l’agriculture

Fais entrer l’IA de vision dans l’agriculture intelligente avec les modèles Ultralytics YOLO. Optimise le suivi des cultures et du bétail ainsi que l’agriculture de précision pour obtenir des rendements plus élevés et plus intelligents.
En savoir plus

Construisons ensemble l’avenir de l’IA !

Commence ton parcours vers l’avenir de l’apprentissage automatique