Guide de démarrage rapide : NVIDIA Jetson avec Ultralytics YOLO26#
Ce guide complet fournit une procédure détaillée pour déployer Ultralytics YOLO26 sur des appareils NVIDIA Jetson. Il présente également des benchmarks de performances pour démontrer les capacités de YOLO26 sur ces appareils compacts et puissants.
Nous avons mis à jour ce guide avec le dernier NVIDIA Jetson AGX Thor Developer Kit, qui fournit jusqu'à 2070 TFLOPS FP4 de calcul IA et 128 Go de mémoire, avec une puissance configurable entre 40 W et 130 W. Il offre une puissance de calcul IA plus de 7,5 fois supérieure à celle du NVIDIA Jetson AGX Orin, avec une efficacité énergétique 3,5 fois meilleure, afin d'exécuter en toute fluidité les modèles IA les plus populaires.
Watch: How to use Ultralytics YOLO26 on NVIDIA Jetson Devices
Ce guide a été testé avec le NVIDIA Jetson AGX Thor Developer Kit (Jetson T5000) et le NVIDIA Jetson AGX Orin Developer Kit (64GB) exécutant la dernière version stable de JetPack 7.2, avec le NVIDIA Jetson Orin Nano Super Developer Kit exécutant la version JetPack de JP6.1, avec le Seeed Studio reComputer J4012, basé sur le NVIDIA Jetson Orin NX 16GB et exécutant la version JetPack de JP6.0/ la version JetPack de JP5.1.3, ainsi qu'avec le Seeed Studio reComputer J1020 v2, basé sur le NVIDIA Jetson Nano 4GB et exécutant la version JetPack de JP4.6.1. Il 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 série de cartes de calcul embarqué conçues pour apporter le calcul accéléré d'intelligence artificielle (AI) aux appareils edge. Ces appareils compacts et puissants reposent sur l'architecture GPU de NVIDIA et peuvent exécuter directement sur l'appareil des algorithmes IA complexes et des modèles de deep learning, sans dépendre des ressources de cloud computing. 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 effectué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 séries NVIDIA Jetson#
Le NVIDIA Jetson AGX Thor est la dernière évolution de la famille NVIDIA Jetson, basée sur l'architecture NVIDIA Blackwell, qui améliore considérablement les performances IA par rapport aux générations précédentes. Le tableau ci-dessous compare quelques appareils Jetson de l'écosystème.
| 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 NVIDIA basé sur l'architecture Blackwell, avec 2560 cœurs et 96 Tensor Cores | GPU NVIDIA basé sur l'architecture Ampere, avec 2048 cœurs et 64 Tensor Cores | GPU NVIDIA basé sur l'architecture Ampere, avec 1024 cœurs et 32 Tensor Cores | GPU NVIDIA basé sur l'architecture Ampere, avec 1024 cœurs et 32 Tensor Cores | GPU NVIDIA basé sur l'architecture Volta, avec 512 cœurs et 64 Tensor Cores | GPU NVIDIA basé sur l'architecture Volta™ avec 384 cœurs et 48 Tensor Cores | GPU NVIDIA basé sur l'architecture 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 Arm® Neoverse®-V3AE 64 bits à 14 cœurs, 1MB de L2 + 16MB de L3 | CPU NVIDIA Arm® Cortex A78AE v8.2 64 bits à 12 cœurs, 3MB de L2 + 6MB de L3 | CPU NVIDIA Arm® Cortex A78AE v8.2 64 bits à 8 cœurs, 2MB de L2 + 4MB de L3 | CPU Arm® Cortex®-A78AE v8.2 64 bits à 6 cœurs, 1.5MB de L2 + 4MB de L3 | CPU NVIDIA Carmel Arm®v8.2 64 bits à 8 cœurs, 8MB de L2 + 4MB de L3 | CPU NVIDIA Carmel Arm®v8.2 64 bits à 6 cœurs, 6MB de L2 + 4MB de L3 | Processeur Arm® Cortex®-A57 MPCore quadricœur |
| 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 | 128GB LPDDR5X 256 bits, 273GB/s | 64GB LPDDR5 256 bits, 204.8GB/s | 16GB LPDDR5 128 bits, 102.4GB/s | 8GB LPDDR5 128 bits, 102GB/s | 32GB LPDDR4x 256 bits, 136.5GB/s | 8GB LPDDR4x 128 bits, 59.7GB/s | 4GB LPDDR4 64 bits, 25.6GB/s |
Pour consulter un tableau comparatif plus détaillé, accède à 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 et fournit un environnement de développement complet pour créer des applications IA accélérées de bout en bout, tout en réduisant le délai de mise sur le marché. JetPack comprend Jetson Linux avec le chargeur d'amorçage, le noyau Linux, l'environnement de bureau Ubuntu et un ensemble complet de bibliothèques pour l'accélération du calcul GPU, du multimédia, des graphismes et de 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 obtenu 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 Jetson AGX Thor, AGX Orin ou Orin Nano Developer Kit officiel, télécharge l'ISO Jetson unifiée, écris-la sur une clé USB et suis le guide de démarrage rapide spécifique à l'appareil pour 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 USB avec l'ISO installe Jetson Linux sur la carte microSD ou le SSD NVMe de l'appareil.
- Si tu utilises intentionnellement JetPack 6 sur un Jetson Orin Nano Developer Kit, suis les instructions de mise à jour et de 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 et, si tu possèdes un appareil Seeed Studio reComputer J1020 v2, tu peux flasher JetPack sur l'eMMC/ SSD.
- Si tu possèdes un autre appareil tiers alimenté par le 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 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#
La façon la plus rapide de commencer avec Ultralytics YOLO26 sur NVIDIA Jetson consiste à utiliser des images Docker préconstruites 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, incluant CUDA 13.4 et TensorRT 11.2. NVIDIA liste JetPack 7.1 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 exportations Jetson TensorRT, utilise l'installation native ci-dessous avec le runtime TensorRT 10.x pris en charge par ta version de JetPack. JetPack 7.2 sur Thor ou Orin nécessite une validation de conteneur distincte. Reconstruis les moteurs pour le GPU cible et la version de TensorRT.
Pour les images JetPack 4, 5 et 6, continue vers Utiliser TensorRT sur NVIDIA Jetson. L'image JetPack 7.1 ci-dessus est réservée aux charges de travail PyTorch.
Commencer par l'installation native#
Pour effectuer une installation native sans Docker, suis les étapes ci-dessous.
Exécuter sur JetPack 7.2#
Installer le package Ultralytics#
Nous allons ici installer le package Ultralytics sur le Jetson. Les dépendances d'exportation sont installées automatiquement lors du premier export d'un modèle ; seul le package de base est donc nécessaire ici. Nous nous concentrerons principalement sur les exports NVIDIA TensorRT, car TensorRT nous permettra d'obtenir les performances maximales des appareils Jetson.
-
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 -
Installer le package pip
ultralyticspip install ultralytics -
Redémarrer l'appareil
sudo reboot
Installer PyTorch et Torchvision#
L'installation d'Ultralytics ci-dessus installera Torch et Torchvision. Toutefois, ces deux packages installés via pip ne sont pas compatibles avec les appareils JetPack 7.2 utilisant CUDA 13. Nous devons donc les installer manuellement.
Installer torch et torchvision selon JP7.2
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130Installer onnxruntime-gpu#
Utilise un wheel ONNX Runtime GPU adapté à tes versions de JetPack, Python et CUDA. Les versions actuelles de PyPI incluent des wheels ARM64, mais elles ne remplacent pas les paquets spécifiques à l'appareil pour chaque version de JetPack.
Nous allons ici 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 ici installer le package Ultralytics sur le Jetson. Les dépendances d'exportation sont installées automatiquement lors du premier export d'un modèle ; seul le package de base est donc nécessaire ici. Nous nous concentrerons principalement sur les exports NVIDIA TensorRT, car TensorRT nous permettra d'obtenir les performances maximales des appareils Jetson.
-
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 -
Installer le package pip
ultralyticspip install ultralytics -
Redémarrer l'appareil
sudo reboot
Installer PyTorch et Torchvision#
L'installation d'Ultralytics ci-dessus installera Torch et Torchvision. Toutefois, ces deux packages installés via pip ne sont pas compatibles avec la plateforme Jetson, basée sur l'architecture ARM64. Nous devons donc installer manuellement un wheel PyTorch précompilé et compiler ou installer Torchvision depuis les sources.
Installer torch 2.10.0 et torchvision 0.25.0 selon 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 à toutes les versions de PyTorch disponibles pour les différentes versions de JetPack. Pour obtenir une liste plus détaillée de la compatibilité entre PyTorch et Torchvision, consulte la page de compatibilité PyTorch et Torchvision.
Installer 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 un wheel ONNX Runtime GPU adapté à tes versions de JetPack, Python et CUDA. Les versions actuelles de PyPI incluent des wheels ARM64, mais elles ne remplacent pas les paquets spécifiques à l'appareil pour chaque version de JetPack.
Tu trouveras tous les packages onnxruntime-gpu disponibles — classé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 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 ici installer le package Ultralytics sur le Jetson. Les dépendances d'exportation sont installées automatiquement lors du premier export d'un modèle ; seul le package de base est donc nécessaire ici. Nous nous concentrerons principalement sur les exports NVIDIA TensorRT, car TensorRT nous permettra d'obtenir les performances maximales des appareils Jetson.
-
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 -
Installer le package pip
ultralyticspip install ultralytics -
Redémarrer l'appareil
sudo reboot
Installer PyTorch et Torchvision#
L'installation d'Ultralytics ci-dessus installera Torch et Torchvision. Toutefois, ces deux packages installés via pip ne sont pas compatibles avec la plateforme Jetson, basée sur l'architecture ARM64. Nous devons donc installer manuellement un wheel PyTorch précompilé et compiler ou installer Torchvision depuis les sources.
-
Désinstaller PyTorch et Torchvision actuellement installés
pip uninstall torch torchvision -
Installer
torch 2.1.0ettorchvision 0.16.2selon 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 à toutes les versions de PyTorch disponibles pour les différentes versions de JetPack. Pour obtenir une liste plus détaillée de la compatibilité entre PyTorch et Torchvision, consulte la page de compatibilité PyTorch et Torchvision.
Installer onnxruntime-gpu#
Utilise un wheel ONNX Runtime GPU adapté à tes versions de JetPack, Python et CUDA. Les versions actuelles de PyPI incluent des wheels ARM64, mais elles ne remplacent pas les paquets spécifiques à l'appareil pour chaque version de JetPack.
Tu trouveras tous les packages onnxruntime-gpu disponibles — classé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 ici 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établira automatiquement la version de NumPy à la dernière version. 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'exportation de modèles pris en charge par Ultralytics, TensorRT offre les performances d'inférence les plus élevées sur les appareils NVIDIA Jetson, ce qui en fait notre recommandation principale pour les déploiements Jetson. Avant l'exportation, installe les liaisons Python TensorRT fournies pour ta version de JetPack et vérifie-les avec python3 -c "import tensorrt; print(tensorrt.__version__)". Conserve le runtime TensorRT 10.x pris en charge sur JetPack 6/7 ; ne le remplace pas par TensorRT 11.2.1. Pour les instructions d'installation et l'utilisation avancée, consulte notre guide d'intégration TensorRT dédié.
Tu peux également exporter depuis le navigateur sans configurer localement l'environnement de compilation. Dans l'onglet Exportation de modèles de la plateforme Ultralytics, 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 SKU Orin prévu avant le déploiement.
TensorRT établit le profil et optimise un moteur sur son GPU de 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. Les SKU Orin dotés de la même architecture ne garantissent pas automatiquement la portabilité, et l'étalonnage INT8 doit être effectué sur l'appareil cible pour obtenir les meilleurs résultats.
Convertir un modèle en TensorRT et exécuter l'inférence#
Le modèle YOLO26n au format PyTorch est converti en TensorRT pour exécuter l'inférence avec le modèle exporté.
from ultralytics import YOLO
# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")
# Export the model to TensorRT
model.export(format="engine") # creates 'yolo26n.engine'
# Load the exported TensorRT model
trt_model = YOLO("yolo26n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")Consulte la page Export pour accéder à des arguments supplémentaires lors de l'exportation de modèles vers différents formats de modèle
Utiliser l’accélérateur NVIDIA pour l’apprentissage profond (DLA)#
L’accélérateur NVIDIA pour l’apprentissage profond (DLA) est un composant matériel spécialisé intégré aux appareils NVIDIA Jetson, qui optimise l’inférence des modèles d’apprentissage profond pour améliorer l’efficacité énergétique et les performances. En déchargeant le GPU de certaines tâches (et en le libérant pour des processus plus intensifs), le DLA permet aux modèles de s’exécuter avec une consommation énergétique réduite tout en maintenant un débit élevé, ce qui est idéal pour les systèmes embarqués et les applications d’IA en temps réel.
NVIDIA répertorie TensorRT 10.7 comme la dernière version avec 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 prise en charge par ta version de JetPack. TensorRT 11.2.1 ne prend pas en charge JetPack, y compris pour les exportations GPU uniquement.
Les appareils Jetson suivants sont équipés d’un 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 8GB | 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
# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")
# Export the model to TensorRT with DLA enabled (only works with FP16 or INT8)
model.export(format="engine", device="dla:0", quantize=16) # dla:0 or dla:1 corresponds to the DLA cores
# Load the exported TensorRT model
trt_model = YOLO("yolo26n.engine")
# Run inference
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 le DLA et basculeront vers le GPU pour leur exécution. Ce basculement peut introduire une latence supplémentaire et affecter les 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. Son objectif principal est plutôt d’augmenter le débit et d’améliorer l’efficacité énergétique.
Benchmarks de YOLO26 sur NVIDIA Jetson#
Les benchmarks de YOLO26 ont été exécutés par l'équipe Ultralytics sur 11 formats de modèles différents mesurant la vitesse et la précision : PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch. Les benchmarks ont été exécutés sur les appareils NVIDIA Jetson AGX Thor Developer Kit, NVIDIA Jetson AGX Orin Developer Kit (64GB), NVIDIA Jetson Orin Nano Super Developer Kit et Seeed Studio reComputer J4012 alimenté par Jetson Orin NX 16GB en précision FP32 avec une taille d'image d'entrée par défaut de 640.
Graphiques comparatifs#
Même si tous les exports de modèles fonctionnent sur NVIDIA Jetson, nous avons inclus uniquement PyTorch, TorchScript, TensorRT dans le graphique comparatif ci-dessous, car ils utilisent le GPU du Jetson et garantissent les meilleurs résultats. Tous les autres exports utilisent uniquement le CPU et leurs performances sont moins bonnes que celles des trois précédents. Tu trouveras les benchmarks de tous les exports dans la section qui suit ce graphique.
NVIDIA Jetson AGX Thor Developer Kit#
NVIDIA Jetson AGX Orin Developer Kit (64GB)#
NVIDIA Jetson Orin Nano Super Developer Kit#
NVIDIA Jetson Orin NX 16GB#
Tableaux comparatifs détaillés#
Le tableau ci-dessous représente les résultats des benchmarks pour cinq modèles différents (YOLO26n, YOLO26s, YOLO26m, YOLO26l, YOLO26x) sur 11 formats différents (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch), donnant le statut, la taille, la métrique mAP50-95(B) et le temps d'inférence pour chaque combinaison.
NVIDIA Jetson AGX Thor Developer Kit#
| Format | Statut | Taille sur le disque (Mo) | 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.
NVIDIA Jetson AGX Orin Developer Kit (64GB)#
| Format | Statut | Taille sur le disque (Mo) | 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.0450 | 4.18 |
| TensorRT (FP16) | ✅ | 7.9 | 0.0450 | 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.
NVIDIA Jetson Orin Nano Super Developer Kit#
| Format | Statut | Taille sur le disque (Mo) | 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 (Mo) | 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 travaux de benchmark réalisés par Seeed Studio 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
# 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).
Bonnes pratiques lors de l’utilisation de NVIDIA Jetson#
Lors de l’utilisation de NVIDIA Jetson, suis quelques bonnes pratiques afin d’obtenir des performances maximales sur le NVIDIA Jetson exécutant YOLO26.
-
Activer le mode de puissance MAX
L’activation du mode de puissance MAX sur le Jetson garantit que tous les cœurs CPU et GPU sont activés.
sudo nvpmodel -m 0 -
Activer les horloges Jetson
L’activation des horloges Jetson 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 de puissance, 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 variantes disposant de moins de mémoire, comme le Jetson Orin Nano (8 GB) ou l’Orin NX 8 GB. Les conseils ci-dessous proposent des modifications pratiques et peu risquées qui peuvent libérer collectivement 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 parallèles. Pour un traitement complet, consulte le blog NVIDIA sur l’optimisation de l’efficacité mémoire sur Jetson.
1. Passer à un démarrage sans interface graphique#
Si ton Jetson est connecté via SSH ou fonctionne comme une appliance de production sans écran connecté, la suppression de l’environnement de bureau et du serveur d’affichage peut récupérer jusqu’à 865 MB de RAM :
sudo systemctl set-default multi-user.target
sudo rebootPour restaurer ultérieurement le bureau :
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 tout ce 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 (taille proportionnelle de l’ensemble), qui reflète plus fidèlement l’empreinte mémoire réelle de chaque processus que le RSS (taille de l’ensemble résident, c’est-à-dire le nombre total de pages de RAM physique mappées par un processus, y compris les pages partagées avec d’autres processus) :
git clone https://github.com/csimmonds/procrank_linux.git
cd procrank_linux && make
sudo ./procrankPour afficher les allocations GPU et NvMap (pipeline CUDA/vidéo) de chaque 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 ne nécessitent pas de prévisualisation en direct, la désactivation des composants liés à l’affichage (Tiler, OSD, DisplaySink) peut économiser 200+ MB pour le pipeline seul. Avec Ultralytics YOLO, désactive la visionneuse et écris plutôt les résultats sur le disque :
from ultralytics import YOLO
model = YOLO("yolo26n.engine")
# show=False prevents any display window; save=True writes annotated output to disk
results = model.predict(source="video.mp4", show=False, save=True)Impact cumulé#
| Optimisation | Mémoire économisée approximativement |
|---|---|
| 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 interface graphique (sans affichage) | ~200+ MB |
| Total (gains faciles) | ~1 GB+ |
La combinaison de ces modifications est particulièrement utile lorsque tu cibles des modèles TensorRT INT8 sur des appareils disposant de peu de mémoire : elle peut faire la différence entre pouvoir charger en mémoire une variante de modèle plus volumineuse ou non.
Prochaines étapes#
Pour approfondir tes connaissances et obtenir de l'aide, consulte la documentation Ultralytics YOLO26.
FAQ#
Les modèles YOLO26 ont été évalués sur divers appareils NVIDIA Jetson montrant des améliorations de performance significatives. Par exemple, le format TensorRT offre les meilleures performances d'inférence. Le tableau de la section Detailed Comparison Tables fournit une vue d'ensemble des métriques de performance telles que mAP50-95 et le temps d'inférence selon les différents formats de modèles.
TensorRT est fortement recommandé pour déployer les modèles YOLO26 sur NVIDIA Jetson en raison de ses performances optimales. Il accélère l’inférence en exploitant les capacités du GPU du Jetson, garantissant 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 les versions existantes qui ont pu être installées via pip. Installe ensuite manuellement les versions compatibles de PyTorch et Torchvision pour l’architecture ARM64 du Jetson. Des instructions détaillées sont fournies dans la section Installer PyTorch et Torchvision.
Pour maximiser les performances de YOLO26 sur NVIDIA Jetson, suis ces bonnes pratiques :
- Active le mode de puissance MAX pour utiliser tous les cœurs CPU et GPU.
- Active les horloges Jetson pour faire fonctionner tous les cœurs à leur fréquence maximale.
- Installe l’application Jetson Stats pour surveiller les métriques du système.
Pour connaître les commandes et obtenir des informations supplémentaires, consulte la section Bonnes pratiques lors de l’utilisation de NVIDIA Jetson.
La RAM disponible constitue souvent le goulot d’étranglement sur les appareils Jetson disposant de moins de mémoire. Trois gains faciles peuvent ensemble libérer plus de 1 GB :
- Passer à un démarrage sans interface graphique (
sudo systemctl set-default multi-user.target) pour supprimer l’interface graphique du bureau (~865 MB économisés). - Désactiver les services inutilisés, comme Bluetooth ou les gestionnaires de connectivité (~32 MB économisés).
- Exécuter l’inférence sans écran en définissant
show=Falsedans ton appel YOLOpredict, ce qui évite d’allouer la mémoire du pipeline d’affichage (~200+ MB économisés).
Utilise
procrankpour analyser l’utilisation de la RAM par processus etsudo cat /sys/kernel/debug/nvmap/iovmm/clientspour inspecter les allocations GPU. Consulte la section Conseils d’optimisation de la mémoire pour tous les détails.- Passer à un démarrage sans interface graphique (
TensorRT 10.3.0 livré avec JetPack 6 présente un problème connu qui empêche la génération de moteurs INT8 lorsque
nms=Falseest activé. Lorsque Ultralytics détecte cette combinaison, Ultralytics sélectionne automatiquement la tête one-to-many pour garantir la réussite de l'export.Pour rétablir les exports 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 ton exportation. Pour plus de détails, consulte l’issue GitHub n° 23841.
Le déploiement d’Ultralytics YOLO26 sur des appareils NVIDIA Jetson est un processus simple. Commence par flasher ton appareil Jetson avec le SDK NVIDIA JetPack. Ensuite, utilise soit une image Docker précompilée pour une configuration rapide, soit installe manuellement les packages requis. Tu trouveras les étapes détaillées pour chaque approche dans les sections Démarrage rapide avec Docker et Commencer avec l’installation native.