Guide de démarrage rapide : NVIDIA Jetson avec Ultralytics YOLO26#
Ce guide complet présente en détail le déploiement d’Ultralytics YOLO26 sur les appareils NVIDIA Jetson. Il présente également des benchmarks de performances qui illustrent les capacités de YOLO26 sur ces appareils compacts et puissants.
Nous avons mis à jour ce guide avec le tout dernier NVIDIA Jetson AGX Thor Developer Kit, qui offre jusqu’à 2070 TFLOPS FP4 de calcul IA et 128 Go de mémoire, avec une puissance configurable entre 40 W et 130 W. Il fournit plus de 7,5 fois la puissance de calcul IA du NVIDIA Jetson AGX Orin, avec une efficacité énergétique 3,5 fois supérieure, pour exécuter facilement les modèles d’IA les plus populaires.
À regarder : Comment utiliser Ultralytics YOLO26 sur les appareils NVIDIA Jetson
Ce guide a été testé avec le NVIDIA Jetson AGX Thor Developer Kit (Jetson T5000) et le NVIDIA Jetson AGX Orin Developer Kit (64GB), équipés de la dernière version stable JetPack 7.2, le NVIDIA Jetson Orin Nano Super Developer Kit, équipé de la version JetPack JP6.1, le Seeed Studio reComputer J4012, basé sur NVIDIA Jetson Orin NX 16GB et équipé de la version JetPack JP6.0/JP5.1.3, ainsi que le Seeed Studio reComputer J1020 v2, basé sur NVIDIA Jetson Nano 4GB et équipé de la version JetPack JP4.6.1. Le guide devrait fonctionner sur toute la gamme de matériel NVIDIA Jetson, y compris les appareils les plus récents et les modèles plus anciens.
Qu’est-ce que NVIDIA Jetson ?#
NVIDIA Jetson est une gamme de cartes informatiques embarquées conçues pour apporter des capacités de calcul accéléré par l’IA (AI) aux appareils en périphérie. Ces appareils compacts et puissants reposent sur l’architecture GPU de NVIDIA et peuvent exécuter des algorithmes complexes d’IA et des modèles d’apprentissage profond directement sur l’appareil, sans dépendre des ressources de l’informatique en nuage. Les cartes Jetson sont souvent utilisées en robotique, dans les véhicules autonomes, l’automatisation industrielle et d’autres applications où l’inférence IA doit être exécutée localement, avec une faible latence et une grande efficacité. De plus, ces cartes reposent sur l’architecture ARM64 et consomment moins d’énergie que les appareils de calcul GPU traditionnels.
Comparaison des gammes NVIDIA Jetson#
NVIDIA Jetson AGX Thor est le dernier modèle de la gamme NVIDIA Jetson, basé sur l’architecture NVIDIA Blackwell, qui offre des performances d’IA nettement supérieures à celles des générations précédentes. Le tableau ci-dessous compare quelques appareils de l’écosystème Jetson.
| Jetson AGX Thor (T5000) | Jetson AGX Orin 64GB | Jetson Orin NX 16GB | Jetson Orin Nano Super | Jetson AGX Xavier | Jetson Xavier NX | Jetson Nano | |
|---|---|---|---|---|---|---|---|
| Performances IA | 2070 TFLOPS | 275 TOPS | 100 TOPS | 67 TOPS | 32 TOPS | 21 TOPS | 472 GFLOPS |
| GPU | GPU basé sur l’architecture NVIDIA Blackwell, avec 2560 cœurs et 96 cœurs Tensor | GPU basé sur l’architecture NVIDIA Ampere, avec 2048 cœurs et 64 cœurs Tensor | GPU basé sur l’architecture NVIDIA Ampere, avec 1024 cœurs et 32 cœurs Tensor | GPU basé sur l’architecture NVIDIA Ampere, avec 1024 cœurs et 32 cœurs Tensor | GPU basé sur l’architecture NVIDIA Volta, avec 512 cœurs et 64 cœurs Tensor | GPU basé sur l’architecture NVIDIA Volta™, avec 384 cœurs et 48 cœurs Tensor | GPU basé sur l’architecture NVIDIA Maxwell™, avec 128 cœurs |
| Fréquence maximale du GPU | 1.57 GHz | 1.3 GHz | 918 MHz | 1020 MHz | 1377 MHz | 1100 MHz | 921MHz |
| CPU | CPU 64 bits Arm® Neoverse®-V3AE à 14 cœurs, 1 Mo de cache L2 + 16 Mo de cache L3 | CPU 64 bits NVIDIA Arm® Cortex A78AE v8.2 à 12 cœurs, 3 Mo de cache L2 + 6 Mo de cache L3 | CPU 64 bits NVIDIA Arm® Cortex A78AE v8.2 à 8 cœurs, 2 Mo de cache L2 + 4 Mo de cache L3 | CPU Arm® Cortex®-A78AE v8.2 64 bits à 6 cœurs, 1,5 Mo de cache L2 + 4 Mo de cache L3 | CPU NVIDIA Carmel Arm®v8.2 64 bits à 8 cœurs, 8 Mo de cache L2 + 4 Mo de cache L3 | CPU NVIDIA Carmel Arm®v8.2 64 bits à 6 cœurs, 6 Mo de cache L2 + 4 Mo de cache L3 | Processeur MPCore Arm® Cortex®-A57 à quatre cœurs |
| Fréquence maximale du CPU | 2.6 GHz | 2.2 GHz | 2.0 GHz | 1.7 GHz | 2.2 GHz | 1.9 GHz | 1.43GHz |
| Mémoire | 128 Go LPDDR5X 256 bits, 273 Go/s | 64 Go LPDDR5 256 bits, 204,8 Go/s | 16 Go LPDDR5 128 bits, 102,4 Go/s | 8 Go LPDDR5 128 bits, 102 Go/s | 32 Go LPDDR4x 256 bits, 136,5 Go/s | 8 Go LPDDR4x 128 bits, 59,7 Go/s | 4 Go LPDDR4 64 bits, 25,6 Go/s |
Pour obtenir un tableau comparatif plus détaillé, consulte la section Compare Specifications de la page officielle NVIDIA Jetson.
Qu’est-ce que NVIDIA JetPack ?#
Le NVIDIA JetPack SDK qui alimente les modules Jetson est la solution la plus complète. Il fournit un environnement de développement complet pour créer des applications d’IA accélérées de bout en bout et raccourcit le délai de mise sur le marché. JetPack inclut Jetson Linux avec le chargeur de démarrage, le noyau Linux, l’environnement de bureau Ubuntu et un ensemble complet de bibliothèques pour accélérer le calcul GPU, le multimédia, les graphismes et la vision par ordinateur. Il comprend également des exemples, de la documentation et des outils de développement pour l’ordinateur hôte et le kit de développement, et prend en charge des SDK de niveau supérieur tels que DeepStream pour l’analyse vidéo en continu, Isaac pour la robotique et Riva pour l’IA conversationnelle.
Flasher JetPack sur NVIDIA Jetson#
La première étape après avoir reçu un appareil NVIDIA Jetson consiste à flasher NVIDIA JetPack sur l’appareil. Il existe plusieurs façons de flasher les appareils NVIDIA Jetson.
- Pour JetPack 7.2 sur un kit de développement officiel Jetson AGX Thor, AGX Orin ou Orin Nano, télécharge l’image ISO unifiée de Jetson, écris-la sur une clé USB, puis suis le guide de démarrage rapide correspondant à AGX Thor, AGX Orin ou Orin Nano. À partir de JetPack 7.2, Orin Nano n’utilise plus d’image de carte SD téléchargeable ; l’installation à partir de l’ISO sur clé USB installe Jetson Linux sur la carte microSD ou le SSD NVMe de l’appareil.
- Si tu choisis délibérément d’utiliser JetPack 6 sur un kit de développement Jetson Orin Nano, suis les instructions de mise à jour et d’installation sur carte SD de JetPack 6.x de NVIDIA.
- Si tu possèdes un autre kit de développement NVIDIA, tu peux flasher JetPack sur l’appareil à l’aide de SDK Manager.
- Si tu possèdes un appareil Seeed Studio reComputer J4012, tu peux flasher JetPack sur le SSD inclus. Si tu possèdes un appareil Seeed Studio reComputer J1020 v2, tu peux flasher JetPack sur l’eMMC/ SSD.
- Si tu possèdes un appareil tiers équipé d’un module NVIDIA Jetson, il est recommandé de suivre la procédure de flashage en ligne de commande.
Pour les méthodes 1, 4 et 5 ci-dessus, après avoir flashé le système et démarré l’appareil, saisis « sudo apt update && sudo apt install nvidia-jetpack -y » dans le terminal de l’appareil afin d’installer tous les composants JetPack restants nécessaires.
Prise en charge de JetPack selon l’appareil Jetson#
Le tableau ci-dessous présente les versions de NVIDIA JetPack prises en charge par les différents appareils NVIDIA Jetson.
| JetPack 4 | JetPack 5 | JetPack 6 | JetPack 7 | |
|---|---|---|---|---|
| Jetson Nano | ✅ | ❌ | ❌ | ❌ |
| Jetson TX2 | ✅ | ❌ | ❌ | ❌ |
| Jetson Xavier NX | ✅ | ✅ | ❌ | ❌ |
| Jetson AGX Xavier | ✅ | ✅ | ❌ | ❌ |
| Jetson AGX Orin | ❌ | ✅ | ✅ | ✅ |
| Jetson Orin NX | ❌ | ✅ | ✅ | ✅ |
| Jetson Orin Nano | ❌ | ✅ | ✅ | ✅ |
| Jetson AGX Thor | ❌ | ❌ | ❌ | ✅ |
Démarrage rapide avec Docker#
Le moyen le plus rapide de commencer à utiliser Ultralytics YOLO26 sur NVIDIA Jetson consiste à lancer les images Docker précompilées pour Jetson. Consulte le tableau ci-dessus et choisis la version de JetPack correspondant à l’appareil Jetson que tu possèdes.
t=ultralytics/ultralytics:latest-jetson-jetpack4
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $tL’image latest-nvidia-arm64 utilise NVIDIA PyTorch 26.08, notamment CUDA 13.4 et TensorRT 11.2. NVIDIA indique que JetPack 7.1 est pris en charge pour PyTorch dans son tableau de compatibilité, mais TensorRT 11.2.1 ne prend pas en charge JetPack, y compris Thor. Utilise cette image uniquement pour les charges de travail PyTorch sur un hôte pris en charge. Pour les exports Jetson TensorRT, utilise l’installation native ci-dessous avec l’environnement d’exécution TensorRT 10.x pris en charge par ta version de JetPack. JetPack 7.2 sur Thor ou Orin nécessite une validation distincte du conteneur. Recompile les moteurs pour le GPU et la version de TensorRT ciblés.
Pour les images JetPack 4, 5 et 6, poursuis avec Utiliser TensorRT sur NVIDIA Jetson. L’image JetPack 7.1 ci-dessus est réservée aux charges de travail PyTorch.
Commencer par une installation native#
Pour une installation native sans Docker, suis les étapes ci-dessous.
Exécuter sur JetPack 7.2#
Installer le package Ultralytics#
Nous allons installer le package Ultralytics sur le Jetson. Les dépendances d’export sont installées automatiquement lors du premier export d’un modèle ; seul le package de base est donc nécessaire ici. Nous allons principalement nous intéresser aux exports NVIDIA TensorRT, car TensorRT permet d’exploiter au mieux les performances des appareils Jetson.
-
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
Installer PyTorch et Torchvision#
L’installation d’Ultralytics ci-dessus installe Torch et Torchvision. Cependant, ces deux packages installés avec pip ne sont pas compatibles avec les appareils JetPack 7.2 équipés de CUDA 13. Il faut donc les installer manuellement.
Installer torch et torchvision en fonction de JP7.2
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130Installer onnxruntime-gpu#
Utilise une roue ONNX Runtime GPU correspondant à tes versions de JetPack, Python et CUDA. Les versions actuelles disponibles sur PyPI incluent des roues ARM64, mais celles-ci ne remplacent pas les packages spécifiques à l’appareil pour chaque version de JetPack.
Nous allons télécharger et installer onnxruntime-gpu 1.24.0 avec la prise en charge de Python3.12.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whlExécuter sur JetPack 6.1#
Installer le package Ultralytics#
Nous allons installer le package Ultralytics sur le Jetson. Les dépendances d’export sont installées automatiquement lors du premier export d’un modèle ; seul le package de base est donc nécessaire ici. Nous allons principalement nous intéresser aux exports NVIDIA TensorRT, car TensorRT permet d’exploiter au mieux les performances des appareils Jetson.
-
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
Installer PyTorch et Torchvision#
L’installation d’Ultralytics ci-dessus installe Torch et Torchvision. Cependant, ces deux packages installés avec pip ne sont pas compatibles avec la plateforme Jetson, basée sur l’architecture ARM64. Il faut donc installer manuellement une roue PyTorch pip précompilée, puis compiler Torchvision à partir des sources ou l’installer depuis les sources.
Installer torch 2.10.0 et torchvision 0.25.0 en fonction de JP6.1
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.10.0-cp310-cp310-linux_aarch64.whl
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.25.0-cp310-cp310-linux_aarch64.whlConsulte la page PyTorch pour Jetson pour accéder aux différentes versions de PyTorch correspondant aux versions de JetPack. Pour obtenir une liste plus détaillée de la compatibilité entre PyTorch et Torchvision, consulte la page de compatibilité entre PyTorch et Torchvision.
Installe cuDSS pour corriger un problème de dépendance avec torch 2.10.0
wget https://developer.download.nvidia.com/compute/cudss/0.7.1/local_installers/cudss-local-tegra-repo-ubuntu2204-0.7.1_0.7.1-1_arm64.deb
sudo dpkg -i cudss-local-tegra-repo-ubuntu2204-0.7.1_0.7.1-1_arm64.deb
sudo cp /var/cudss-local-tegra-repo-ubuntu2204-0.7.1/cudss-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cudssInstaller onnxruntime-gpu#
Utilise une roue ONNX Runtime GPU correspondant à tes versions de JetPack, Python et CUDA. Les versions actuelles disponibles sur PyPI incluent des roues ARM64, mais celles-ci ne remplacent pas les packages spécifiques à l’appareil pour chaque version de JetPack.
Tu trouveras tous les packages onnxruntime-gpu disponibles, organisés par version de JetPack, version de Python et autres détails de compatibilité, dans la matrice de compatibilité ONNX Runtime de Jetson Zoo.
Pour JetPack 6 avec la prise en charge de Python 3.10, tu peux installer onnxruntime-gpu 1.23.0 :
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.23.0-cp310-cp310-linux_aarch64.whlSinon, pour onnxruntime-gpu 1.20.0 :
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whlExécuter sur JetPack 5.1.2#
Installer le package Ultralytics#
Nous allons installer le package Ultralytics sur le Jetson. Les dépendances d’export sont installées automatiquement lors du premier export d’un modèle ; seul le package de base est donc nécessaire ici. Nous allons principalement nous intéresser aux exports NVIDIA TensorRT, car TensorRT permet d’exploiter au mieux les performances des appareils Jetson.
-
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
Installer PyTorch et Torchvision#
L’installation d’Ultralytics ci-dessus installe Torch et Torchvision. Cependant, ces deux packages installés avec pip ne sont pas compatibles avec la plateforme Jetson, basée sur l’architecture ARM64. Il faut donc installer manuellement une roue PyTorch pip précompilée, puis compiler Torchvision à partir des sources ou l’installer depuis les sources.
-
Désinstaller PyTorch et Torchvision actuellement installés
pip uninstall torch torchvision -
Installer
torch 2.1.0ettorchvision 0.16.2en fonction de JP5.1.2pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.16.2+c6f3977-cp38-cp38-linux_aarch64.whl
Consulte la page PyTorch pour Jetson pour accéder aux différentes versions de PyTorch correspondant aux versions de JetPack. Pour obtenir une liste plus détaillée de la compatibilité entre PyTorch et Torchvision, consulte la page de compatibilité entre PyTorch et Torchvision.
Installer onnxruntime-gpu#
Utilise une roue ONNX Runtime GPU correspondant à tes versions de JetPack, Python et CUDA. Les versions actuelles disponibles sur PyPI incluent des roues ARM64, mais celles-ci ne remplacent pas les packages spécifiques à l’appareil pour chaque version de JetPack.
Tu trouveras tous les packages onnxruntime-gpu disponibles, organisés par version de JetPack, version de Python et autres détails de compatibilité, dans la matrice de compatibilité ONNX Runtime de Jetson Zoo. Nous allons télécharger et installer onnxruntime-gpu 1.17.0 avec la prise en charge de Python3.8.
wget https://nvidia.box.com/shared/static/zostg6agm00fb6t5uisw51qi6kpcuwzd.whl -O onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whl
pip install onnxruntime_gpu-1.17.0-cp38-cp38-linux_aarch64.whlonnxruntime-gpu rétablit automatiquement la dernière version de NumPy. Nous devons donc réinstaller NumPy en version 1.23.5 pour corriger un problème, en exécutant :
pip install numpy==1.23.5
Utiliser TensorRT sur NVIDIA Jetson#
Parmi tous les formats d’export de modèles pris en charge par Ultralytics, TensorRT offre les meilleures performances d’inférence sur les appareils NVIDIA Jetson ; c’est donc notre principale recommandation pour les déploiements sur Jetson. Avant l’export, installe les liaisons Python TensorRT fournies pour ta version de JetPack et vérifie leur fonctionnement avec python3 -c "import tensorrt; print(tensorrt.__version__)". Utilise l’environnement d’exécution TensorRT 10.x pris en charge sur JetPack 6/7 ; ne le remplace pas par TensorRT 11.2.1. Pour consulter les instructions de configuration et l’utilisation avancée, consulte notre guide dédié à l’intégration de TensorRT.
Tu peux aussi effectuer l’export dans le navigateur sans configurer l’environnement de compilation localement. Dans l’onglet Export du modèle sur l’Ultralytics Platform, sélectionne TensorRT et la cible Jetson souhaitée. Les sélections Thor sont validées sur du matériel Thor physique. Les six sélections Orin produisent actuellement des moteurs candidats compilés pour AGX-Orin ; valide-les sur le modèle SKU Orin visé avant le déploiement.
TensorRT profile et optimise un moteur sur le GPU utilisé pour sa compilation. Fais correspondre l’architecture GPU et l’environnement d’exécution TensorRT/CUDA de la cible, puis valide chaque moteur téléchargé sur l’appareil de déploiement. Une architecture Orin identique ne garantit pas automatiquement la portabilité entre les différents modèles SKU, et l’étalonnage INT8 devrait être effectué sur l’appareil cible pour obtenir les meilleurs résultats.
Convertir le modèle en TensorRT et exécuter l’inférence#
Le modèle YOLO26n au format PyTorch est converti en TensorRT afin d’exécuter 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 en TensorRT
model.export(format="engine") # crée 'yolo26n.engine'
# Charger le modèle TensorRT exporté
trt_model = YOLO("yolo26n.engine")
# Exécuter l’inférence
results = trt_model("https://ultralytics.com/images/bus.jpg")Consulte la page Export pour accéder à d’autres arguments lors de l’export de modèles vers différents formats
Utiliser NVIDIA Deep Learning Accelerator (DLA)#
Le NVIDIA Deep Learning Accelerator (DLA) est un composant matériel spécialisé intégré aux appareils NVIDIA Jetson, qui optimise l’inférence d’apprentissage profond pour améliorer l’efficacité énergétique et les performances. En déchargeant des tâches du GPU (et en libérant ainsi des ressources pour des processus plus intensifs), le DLA permet aux modèles de fonctionner avec une consommation d’énergie réduite tout en maintenant un débit élevé, ce qui convient parfaitement aux systèmes embarqués et aux applications d’IA en temps réel.
NVIDIA indique que TensorRT 10.7 est la dernière version offrant la prise en charge de DLA ; TensorRT 11.0, 11.1 et 11.2 ne prennent pas en charge DLA. Utilise une version de TensorRT compatible avec DLA et prise en charge par ta version de JetPack. TensorRT 11.2.1 ne prend pas en charge JetPack, y compris pour les exports utilisant uniquement le GPU.
Les appareils Jetson suivants sont équipés de matériel DLA :
| Appareil Jetson | Cœurs DLA | Fréquence maximale du DLA |
|---|---|---|
| Série Jetson AGX Orin | 2 | 1.6 GHz |
| Jetson Orin NX 16GB | 2 | 614 MHz |
| Jetson Orin NX 8 Go | 1 | 614 MHz |
| Série Jetson AGX Xavier | 2 | 1.4 GHz |
| Série Jetson Xavier NX | 2 | 1.1 GHz |
from ultralytics import YOLO
# Charger un modèle YOLO26n PyTorch
model = YOLO("yolo26n.pt")
# Exporter le modèle en TensorRT avec DLA activé (fonctionne uniquement avec FP16 ou INT8)
model.export(format="engine", device="dla:0", quantize=16) # dla:0 ou dla:1 correspond aux cœurs DLA
# Charger le modèle TensorRT exporté
trt_model = YOLO("yolo26n.engine")
# Exécuter l’inférence
results = trt_model("https://ultralytics.com/images/bus.jpg")Lors de l’utilisation d’exports DLA, certaines couches peuvent ne pas être prises en charge par DLA et basculer vers le GPU pour leur exécution. Ce basculement peut ajouter de la latence et nuire aux performances globales de l’inférence. Le DLA n’est donc pas principalement conçu pour réduire la latence d’inférence par rapport à TensorRT exécuté entièrement sur le GPU. Il vise plutôt à augmenter le débit et à améliorer l’efficacité énergétique.
Benchmarks NVIDIA Jetson pour YOLO26#
L’équipe Ultralytics a effectué des benchmarks YOLO26 sur 11 formats de modèles différents, en mesurant la vitesse et la précision : PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN et ExecuTorch. Les benchmarks ont été effectués avec le kit de développement NVIDIA Jetson AGX Thor, le kit de développement NVIDIA Jetson AGX Orin (64 Go), le kit de développement NVIDIA Jetson Orin Nano Super et un Seeed Studio reComputer J4012 équipé d’un appareil Jetson Orin NX 16 Go, avec une précision FP32 et une taille d’image d’entrée par défaut de 640.
Graphiques comparatifs#
Bien que tous les exports de modèles fonctionnent sur NVIDIA Jetson, nous n’avons inclus que PyTorch, TorchScript, TensorRT dans le graphique comparatif ci-dessous, car ils exploitent le GPU du Jetson et garantissent les meilleurs résultats. Tous les autres exports n’utilisent que le CPU et offrent des performances moins bonnes que les trois précédents. Tu trouveras les benchmarks de tous les exports dans la section qui suit ce graphique.
Kit de développement NVIDIA Jetson AGX Thor#
Kit de développement NVIDIA Jetson AGX Orin (64GB)#
Kit de développement NVIDIA Jetson Orin Nano Super#
NVIDIA Jetson Orin NX 16GB#
Tableaux comparatifs détaillés#
Le tableau ci-dessous présente les résultats de benchmark de cinq modèles différents (YOLO26n, YOLO26s, YOLO26m, YOLO26l, YOLO26x) dans 11 formats différents (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch). Il indique le statut, la taille, la métrique mAP50-95(B) et le temps d’inférence pour chaque combinaison.
Kit de développement NVIDIA Jetson AGX Thor#
| Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d’inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4798 | 7.39 |
| TorchScript | ✅ | 9.8 | 0.4789 | 4.21 |
| ONNX | ✅ | 9.5 | 0.4767 | 6.58 |
| OpenVINO | ✅ | 10.1 | 0.4794 | 17.50 |
| TensorRT (FP32) | ✅ | 13.9 | 0.4791 | 1.90 |
| TensorRT (FP16) | ✅ | 7.6 | 0.4797 | 1.39 |
| TensorRT (INT8) | ✅ | 6.5 | 0.4273 | 1.52 |
| TF SavedModel | ✅ | 25.7 | 0.4764 | 47.24 |
| TF GraphDef | ✅ | 9.5 | 0.4764 | 45.98 |
| TF Lite | ✅ | 9.9 | 0.4764 | 182.04 |
| MNN | ✅ | 9.4 | 0.4784 | 21.83 |
Benchmark réalisé avec Ultralytics 8.4.7
Le temps d’inférence n’inclut pas le prétraitement ni le post-traitement.
Kit de développement NVIDIA Jetson AGX Orin (64GB)#
| Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d’inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4790 | 11.58 |
| TorchScript | ✅ | 9.8 | 0.4770 | 4.60 |
| ONNX | ✅ | 9.5 | 0.4770 | 9.87 |
| OpenVINO | ✅ | 9.6 | 0.4820 | 28.80 |
| TensorRT (FP32) | ✅ | 11.5 | 0.4770 | 4.18 |
| TensorRT (FP16) | ✅ | 7.9 | 0.4789 | 2.62 |
| TensorRT (INT8) | ✅ | 5.4 | 0.4640 | 2.30 |
| TF SavedModel | ✅ | 24.6 | 0.4760 | 71.10 |
| TF GraphDef | ✅ | 9.5 | 0.4760 | 70.02 |
| TF Lite | ✅ | 9.9 | 0.4760 | 227.94 |
| MNN | ✅ | 9.4 | 0.4760 | 32.46 |
| NCNN | ✅ | 9.3 | 0.4810 | 29.93 |
Benchmark réalisé avec Ultralytics 8.4.32
Le temps d’inférence n’inclut pas le prétraitement ni le post-traitement.
Kit de développement NVIDIA Jetson Orin Nano Super#
| Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d’inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4790 | 15.60 |
| TorchScript | ✅ | 9.8 | 0.4770 | 12.60 |
| ONNX | ✅ | 9.5 | 0.4760 | 15.76 |
| OpenVINO | ✅ | 9.6 | 0.4820 | 56.23 |
| TensorRT (FP32) | ✅ | 11.3 | 0.4770 | 7.53 |
| TensorRT (FP16) | ✅ | 8.1 | 0.4800 | 4.57 |
| TensorRT (INT8) | ✅ | 5.3 | 0.4490 | 3.80 |
| TF SavedModel | ✅ | 24.6 | 0.4760 | 118.33 |
| TF GraphDef | ✅ | 9.5 | 0.4760 | 116.30 |
| TF Lite | ✅ | 9.9 | 0.4760 | 286.00 |
| MNN | ✅ | 9.4 | 0.4760 | 68.77 |
| NCNN | ✅ | 9.3 | 0.4810 | 47.50 |
Benchmark réalisé avec Ultralytics 8.4.33
Le temps d’inférence n’inclut pas le prétraitement ni le post-traitement.
NVIDIA Jetson Orin NX 16GB#
| Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d’inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.3 | 0.4799 | 13.90 |
| TorchScript | ✅ | 9.8 | 0.4787 | 11.60 |
| ONNX | ✅ | 9.5 | 0.4763 | 14.18 |
| OpenVINO | ✅ | 9.6 | 0.4819 | 40.19 |
| TensorRT (FP32) | ✅ | 11.4 | 0.4770 | 7.01 |
| TensorRT (FP16) | ✅ | 8.0 | 0.4789 | 4.13 |
| TensorRT (INT8) | ✅ | 5.5 | 0.4489 | 3.49 |
| TF SavedModel | ✅ | 24.6 | 0.4764 | 92.34 |
| TF GraphDef | ✅ | 9.5 | 0.4764 | 92.06 |
| TF Lite | ✅ | 9.9 | 0.4764 | 254.43 |
| MNN | ✅ | 9.4 | 0.4760 | 48.55 |
| NCNN | ✅ | 9.3 | 0.4805 | 34.31 |
Benchmark réalisé avec Ultralytics 8.4.33
Le temps d’inférence n’inclut pas le prétraitement ni le post-traitement.
Découvre d’autres projets de benchmarking de Seeed Studio exécutés sur différentes versions du matériel NVIDIA Jetson.
Reproduire nos résultats#
Pour reproduire les benchmarks Ultralytics ci-dessus dans 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).
Bonnes pratiques d’utilisation de NVIDIA Jetson#
Lorsque tu utilises NVIDIA Jetson, suis quelques bonnes pratiques pour obtenir des performances maximales avec YOLO26 sur NVIDIA Jetson.
-
Activer le mode d’alimentation MAX
L’activation du mode d’alimentation MAX sur Jetson garantit que tous les cœurs CPU et GPU sont activés.
sudo nvpmodel -m 0 -
Activer Jetson Clocks
L’activation de Jetson Clocks garantit que tous les cœurs CPU et GPU fonctionnent à leur fréquence maximale.
sudo jetson_clocks -
Installer l’application Jetson Stats
Tu peux utiliser l’application jetson stats pour surveiller la température des composants du système et consulter d’autres informations système, comme l’utilisation du CPU, du GPU et de la RAM, modifier les modes d’alimentation, régler les fréquences maximales et vérifier les informations JetPack.
sudo apt update sudo pip install jetson-stats sudo reboot jtop
Conseils d’optimisation de la mémoire pour NVIDIA Jetson#
La mémoire disponible est souvent le facteur limitant sur les appareils Jetson, en particulier sur les modèles dotés de moins de mémoire, comme le Jetson Orin Nano (8 GB) ou le Orin NX 8 GB. Les conseils ci-dessous proposent des ajustements pratiques et peu risqués qui peuvent libérer ensemble plusieurs centaines de mégaoctets et te permettre d’exécuter des modèles YOLO plus volumineux ou de prendre en charge davantage de charges de travail en parallèle. Pour une présentation complète, consulte le blog NVIDIA sur l’optimisation de l’efficacité mémoire sur Jetson.
1. Passer au démarrage sans interface graphique#
Si ton Jetson est connecté via SSH ou fonctionne comme un appareil de production sans écran, supprimer l’environnement de bureau et le serveur d’affichage peut libérer jusqu’à 865 MB de RAM :
sudo systemctl set-default multi-user.target
sudo rebootPour rétablir l’environnement de bureau ultérieurement :
sudo systemctl set-default graphical.target
sudo reboot2. Désactiver les services système inutilisés#
Les services d’arrière-plan non essentiels (Bluetooth, gestionnaires de connectivité, démons matériels inutilisés) consomment environ 32 MB au total. Liste les services actifs et désactive ceux dont ton déploiement n’a pas besoin :
# List running services
systemctl list-units --type=service --state=running
# Disable a service
sudo systemctl disable SERVICE_NAME3. Analyser l’utilisation de la mémoire#
Avant d’optimiser, identifie les processus qui consomment réellement de la RAM. procrank trie les processus par PSS (Proportional Set Size), qui reflète plus précisément l’empreinte mémoire réelle de chaque processus que RSS (Resident Set Size, le nombre total de pages de RAM physique mappées par un processus, y compris celles partagées avec d’autres processus) :
git clone https://github.com/csimmonds/procrank_linux.git
cd procrank_linux && make
sudo ./procrankPour consulter les allocations GPU et NvMap (pipeline CUDA/vidéo) par processus :
sudo cat /sys/kernel/debug/nvmap/iovmm/clients4. Exécuter l’inférence sans écran en production#
Pour les pipelines d’inférence qui n’ont pas besoin d’un aperçu en direct, désactiver les composants liés à l’affichage (Tiler, OSD, DisplaySink) peut libérer 200+ MB rien qu’au niveau du pipeline. Avec Ultralytics YOLO, désactive l’affichage et enregistre plutôt les résultats sur le disque :
from ultralytics import YOLO
model = YOLO("yolo26n.engine")
# show=False empêche l’ouverture de toute fenêtre d’affichage ; save=True écrit les résultats annotés sur le disque
results = model.predict(source="video.mp4", show=False, save=True)Impact cumulé#
| Optimisation | Mémoire économisée (approx.) |
|---|---|
| Désactiver l’interface graphique du bureau | ~865 MB |
| Désactiver les services du système d’exploitation inutilisés | ~32 MB |
| Pipeline d’inférence sans écran | ~200+ MB |
| Total (gains faciles) | ~1 GB+ |
La combinaison de ces changements est particulièrement utile pour exécuter des modèles TensorRT INT8 sur des appareils dont la mémoire est limitée : elle peut faire la différence entre pouvoir charger ou non une variante de modèle plus volumineuse en mémoire.
Étapes suivantes#
Pour approfondir le sujet et obtenir de l’aide, consulte la documentation Ultralytics YOLO26.
FAQ#
Le déploiement d’Ultralytics YOLO26 sur des appareils NVIDIA Jetson est simple. Commence par flasher ton appareil Jetson avec le SDK NVIDIA JetPack. Ensuite, utilise une image Docker précompilée pour une configuration rapide ou installe manuellement les paquets requis. Tu trouveras les étapes détaillées pour chaque méthode dans les sections Démarrage rapide avec Docker et Commencer par une installation native.
Les modèles YOLO26 ont été évalués sur différents appareils NVIDIA Jetson et affichent des améliorations significatives de leurs performances. Par exemple, le format TensorRT offre les meilleures performances d’inférence. Le tableau de la section Tableaux comparatifs détaillés présente une vue d’ensemble des métriques de performance, comme mAP50-95 et le temps d’inférence, pour différents formats de modèle.
TensorRT est vivement recommandé pour déployer des modèles YOLO26 sur NVIDIA Jetson en raison de ses performances optimales. Il accélère l’inférence en tirant parti des capacités GPU de Jetson, pour une efficacité et une vitesse maximales. Pour en savoir plus sur la conversion vers TensorRT et l’exécution de l’inférence, consulte la section Utiliser TensorRT sur NVIDIA Jetson.
Pour installer PyTorch et Torchvision sur NVIDIA Jetson, désinstalle d’abord toutes les versions existantes qui ont pu être installées avec pip. Installe ensuite manuellement les versions de PyTorch et Torchvision compatibles avec l’architecture ARM64 de Jetson. La section Installer PyTorch et Torchvision fournit des instructions détaillées pour cette procédure.
Pour optimiser les performances de YOLO26 sur NVIDIA Jetson, suis ces bonnes pratiques :
- Active le mode d’alimentation MAX pour utiliser tous les cœurs CPU et GPU.
- Active Jetson Clocks pour faire fonctionner tous les cœurs à leur fréquence maximale.
- Installe l’application Jetson Stats pour surveiller les métriques système.
Pour les commandes et plus de détails, consulte la section Bonnes pratiques d’utilisation de NVIDIA Jetson.
La RAM disponible est souvent le principal goulot d’étranglement sur les appareils Jetson dotés de moins de mémoire. Voici trois gains faciles qui peuvent ensemble libérer plus de 1 GB :
- Passer au démarrage sans interface graphique (
sudo systemctl set-default multi-user.target) pour supprimer l’interface graphique du bureau (~865 MB libérés). - Désactiver les services inutilisés, comme Bluetooth ou les gestionnaires de connectivité (~32 MB libérés).
- Exécuter l’inférence sans écran en définissant
show=Falsedans ton appel YOLOpredict, afin d’éviter d’allouer de la mémoire au pipeline d’affichage (~200+ MB libérés).
Utilise
procrankpour analyser l’utilisation de la RAM par processus etsudo cat /sys/kernel/debug/nvmap/iovmm/clientspour examiner les allocations GPU. Consulte la section Conseils d’optimisation de la mémoire pour tous les détails.- Passer au démarrage sans interface graphique (
TensorRT 10.3.0 fourni avec JetPack 6 comporte un problème connu qui empêche la création de moteurs INT8 sans NMS (
nms=False). Lorsqu’Ultralytics détecte cette combinaison, il sélectionne automatiquement la tête one-to-many pour garantir la réussite de l’exportation.Pour rétablir les exportations INT8 sans NMS, mets à niveau TensorRT vers une version plus récente (par exemple, 10.7.0+) :
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/arm64/cuda-keyring_1.1-1_all.deb sudo dpkg -i cuda-keyring_1.1-1_all.deb sudo apt-get update sudo apt-get install -y tensorrtAprès la mise à niveau, relance l’exportation. Pour plus de détails, consulte le problème GitHub n° 23841.