Guide de démarrage rapide : NVIDIA Jetson avec Ultralytics YOLO11
Ce guide complet fournit une procédure détaillée pour le déploiement d'Ultralytics YOLO11 sur les appareils NVIDIA Jetson. De plus, il présente des benchmarks de performance pour démontrer les capacités de YOLO11 sur ces appareils petits mais puissants.
Nouvelle prise en charge de produits
Nous avons mis à jour ce guide avec le dernier kit de développementNVIDIA Jetson AGX Thor qui fournit jusqu'à 2070 FP4 TFLOPS 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 plus de calcul IA que NVIDIA Jetson AGX Orin, avec 3,5 fois plus d'efficacité énergétique pour faire tourner en toute transparence les modèles IA les plus populaires.
Regarder : Comment utiliser Ultralytics YOLO11 sur les appareils NVIDIA JETSON
Remarque
Ce guide a été testé avec le kit de développementNVIDIA Jetson AGX Thor fonctionnant avec la dernière version stable de JetPack ( JP7.0), le kit de développementNVIDIA Jetson AGX Orin (64 Go) fonctionnant avec la version de JetPack JP6.2, le kit de développementNVIDIA Jetson Orin Nano Super fonctionnant avec la version de JetPack JP6.1, Seeed Studio reComputer J4012 qui est basé sur NVIDIA Jetson Orin NX 16GB fonctionnant avec la version JetPack JP6.0/ JetPack JP5.1.3 et Seeed Studio reComputer J1020 v2 qui est basé sur NVIDIA Jetson Nano 4GB fonctionnant avec la version JetPack JP4.6.1. Il devrait fonctionner sur toute la gamme de matériel NVIDIA Jetson, y compris les plus récents et les plus anciens.
Qu'est-ce que NVIDIA Jetson ?
NVIDIA Jetson est une série de cartes informatiques embarquées conçues pour apporter l'informatique accélérée de l'IA (intelligence artificielle) aux appareils périphériques. Ces appareils compacts et puissants sont construits autour de l'architecture GPU de NVIDIA et sont capables d'exécuter des algorithmes d'IA complexes et des modèles d'apprentissage profond directement sur l'appareil, sans avoir besoin de s'appuyer sur des ressources d'informatique en nuage. Les cartes Jetson sont souvent utilisées dans la robotique, les véhicules autonomes, l'automatisation industrielle et d'autres applications où l'inférence de l'IA doit être effectuée localement avec une faible latence et une grande efficacité. De plus, ces cartes sont basées sur l'architecture ARM64 et fonctionnent avec une puissance inférieure à celle des appareils informatiques GPU traditionnels.
Comparaison des séries NVIDIA Jetson
NVIDIA Jetson AGX Thor est la dernière itération de la famille NVIDIA Jetson basée sur l'architecture NVIDIA Blackwell qui améliore considérablement les performances de l'IA par rapport aux générations précédentes. Le tableau ci-dessous compare quelques appareils Jetson dans l'écosystème.
| Jetson AGX Thor | Jetson AGX Orin 64 Go | Jetson Orin NX 16 Go | Jetson Orin Nano Super | Jetson AGX Xavier | Jetson Xavier NX | Jetson Nano | |
|---|---|---|---|---|---|---|---|
| Performance de l'IA | 2070 TFLOPS | 275 TOPS | 100 TOPS | 67 TOPS | 32 TOPS | 21 TOPS | 472 GFLOPS |
| GPU | GPU NVIDIA Blackwell à 2560 cœurs avec 96 cœurs de Tensor | GPU NVIDIA architecture Ampere à 2048 cœurs avec 64 Tensor Cores | GPU NVIDIA Ampere à architecture 1024 cœurs avec 32 Tensor Cores | GPU NVIDIA Ampere à architecture 1024 cœurs avec 32 Tensor Cores | GPU NVIDIA Volta architecture à 512 cœurs avec 64 cœurs Tensor | GPU NVIDIA architecture Volta™ à 384 cœurs avec 48 Tensor Cores | GPU NVIDIA Maxwell™ à architecture 128 cœurs |
| Fréquence maximale du GPU | 1,57 GHz | 1,3 GHz | 918 MHz | 1020 MHz | 1377 MHz | 1100 MHz | 921 MHz |
| CPU | CPU 64 bits Arm® Neoverse®-V3AE à 14 cœurs 1 Mo L2 + 16 Mo L3 | CPU 12 cœurs NVIDIA Arm® Cortex A78AE v8.2 64 bits 3 Mo L2 + 6 Mo L3 | CPU NVIDIA Arm® Cortex A78AE v8.2 64 bits à 8 cœurs, 2 Mo de L2 + 4 Mo de L3 | CPU Arm® Cortex®-A78AE v8.2 64 bits à 6 cœurs, 1,5 Mo de L2 + 4 Mo de L3 | CPU NVIDIA Carmel Arm®v8.2 64 bits à 8 cœurs, 8 Mo de L2 + 4 Mo de L3 | CPU NVIDIA Carmel Arm®v8.2 64 bits à 6 cœurs, 6 Mo de L2 + 4 Mo de L3 | Processeur Quad-Core Arm® Cortex®-A57 MPCore |
| Fréquence CPU maximale | 2,6 GHz | 2,2 GHz | 2,0 GHz | 1,7 GHz | 2,2 GHz | 1,9 GHz | 1,43 GHz |
| Mémoire | 128GB 256-bit LPDDR5X 273GB/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 | 4GB 64-bit LPDDR4 25.6GB/s |
Pour un tableau comparatif plus détaillé, veuillez consulter la section Comparer les spécifications de la page officielle de la 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 la création d'applications d'IA accélérées de bout en bout et réduit les délais de commercialisation. JetPack comprend Jetson Linux avec bootloader, 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 graphiques 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 les SDK de niveau supérieur tels que DeepStream pour l'analyse de flux vidéo, Isaac pour la robotique et Riva pour l'IA conversationnelle.
Flasher JetPack sur NVIDIA Jetson
La première étape après avoir mis la main sur un appareil NVIDIA Jetson est de flasher NVIDIA JetPack sur l'appareil. Il existe plusieurs façons de flasher les appareils NVIDIA Jetson.
- Si vous possédez un kit de développement NVIDIA officiel tel que le kit de développement Jetson AGX Thor, vous pouvez télécharger une image et préparer une clé USB amorçable pour flasher JetPack sur le SSD inclus.
- Si vous possédez un kit de développement NVIDIA officiel tel que le kit de développement Jetson Orin Nano, vous pouvez télécharger une image et préparer une carte SD avec JetPack pour démarrer l'appareil.
- Si vous possédez un autre kit de développement NVIDIA, vous pouvez flasher JetPack sur l'appareil à l'aide de SDK Manager.
- Si vous possédez un appareil Seeed Studio reComputer J4012, vous pouvez flasher JetPack sur le SSD inclus et si vous possédez un appareil Seeed Studio reComputer J1020 v2, vous pouvez flasher JetPack sur l'eMMC/SSD.
- Si vous possédez un autre appareil tiers alimenté par le module NVIDIA Jetson, il est recommandé de suivre le flashage en ligne de commande.
Remarque
Pour les méthodes 1, 4 et 5 ci-dessus, après avoir flashé le système et démarré l'appareil, veuillez saisir "sudo apt update && sudo apt install nvidia-y" sur le terminal de l'appareil pour installer tous les composants JetPack restants nécessaires.
Prise en charge de JetPack basée sur le périphérique Jetson
Le tableau ci-dessous met en évidence 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
Le moyen le plus rapide de démarrer avec Ultralytics YOLO11 sur NVIDIA Jetson est d'utiliser des images Docker pré-construites pour Jetson. Reportez-vous au tableau ci-dessus et choisissez la version de JetPack en fonction de l'appareil Jetson que vous possédez.
t=ultralytics/ultralytics:latest-jetson-jetpack4
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
t=ultralytics/ultralytics:latest-jetson-jetpack5
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
t=ultralytics/ultralytics:latest-jetson-jetpack6
sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
Bientôt disponible ! Restez à l'écoute !
Une fois cela fait, passez à la section Utiliser TensorRT sur NVIDIA Jetson.
Commencer avec l'installation native
Pour une installation native sans Docker, veuillez vous référer aux étapes ci-dessous.
Exécuter sur JetPack 7.0
Installer le paquet Ultralytics
Ici, nous allons installer le package Ultralytics sur le Jetson avec les dépendances optionnelles afin de pouvoir exporter les modèles PyTorch vers d'autres formats différents. Nous nous concentrerons principalement sur les exportations NVIDIA TensorRT car TensorRT nous permettra d'obtenir les performances maximales des appareils Jetson.
Mettre à jour la liste des paquets, installer pip et mettre à niveau vers la dernière version
sudo apt update sudo apt install python3-pip -y pip install -U pipInstaller
ultralyticsPaquet pip avec des dépendances optionnellespip install ultralytics[export]Redémarrez l'appareil
sudo reboot
Installer PyTorch et Torchvision
L'installation d'ultralytics ci-dessus installera Torch et Torchvision. Cependant, ces 2 paquets installés via pip ne sont pas compatibles pour fonctionner sur la Jetson AGX Thor qui est livrée avec JetPack 7.0 et CUDA 13. Par conséquent, nous devons les installer manuellement.
Installer torch et torchvision selon JP7.0
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu130
Installer onnxruntime-gpu
L'argument onnxruntime-gpu package hébergé dans PyPI n'a pas aarch64 binaires pour le Jetson. Nous devons donc installer ce paquet manuellement. Ce paquet est nécessaire pour certaines des exportations.
Nous allons télécharger et installer onnxruntime-gpu 1.24.0 avec Python3.12 support.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.24.0-cp312-cp312-linux_aarch64.whl
Exécuter sur JetPack 6.1
Installer le paquet Ultralytics
Ici, nous allons installer le package Ultralytics sur le Jetson avec les dépendances optionnelles afin de pouvoir exporter les modèles PyTorch vers d'autres formats différents. Nous nous concentrerons principalement sur les exportations NVIDIA TensorRT car TensorRT nous permettra d'obtenir les performances maximales des appareils Jetson.
Mettre à jour la liste des paquets, installer pip et mettre à niveau vers la dernière version
sudo apt update sudo apt install python3-pip -y pip install -U pipInstaller
ultralyticsPaquet pip avec des dépendances optionnellespip install ultralytics[export]Redémarrez l'appareil
sudo reboot
Installer PyTorch et Torchvision
L'installation d'ultralytics ci-dessus installera Torch et Torchvision. Cependant, ces deux paquets installés via pip ne sont pas compatibles avec la plateforme Jetson, qui est basée sur l'architecture ARM64. Par conséquent, nous devons installer manuellement une roue PyTorch pip préconstruite et compiler ou installer Torchvision à partir des sources.
Installer torch 2.5.0 et torchvision 0.20 conformément à JP6.1
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.5.0a0+872d972e41.nv24.08-cp310-cp310-linux_aarch64.whl
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.20.0a0+afc54f7-cp310-cp310-linux_aarch64.whl
Remarque
Consultez la page PyTorch pour Jetson pour accéder à toutes les différentes versions de PyTorch pour différentes versions de JetPack. Pour une liste plus détaillée sur la compatibilité de PyTorch, Torchvision, consultez la page de compatibilité PyTorch et Torchvision.
Installer cuSPARSELt pour corriger un problème de dépendance avec torch 2.5.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 -y install libcusparselt0 libcusparselt-dev
Installer onnxruntime-gpu
L'argument onnxruntime-gpu package hébergé dans PyPI n'a pas aarch64 binaires pour le Jetson. Nous devons donc installer ce paquet manuellement. Ce paquet est nécessaire pour certaines des exportations.
Vous pouvez trouver tous les onnxruntime-gpu packages, organisés par version de JetPack, version de Python et autres détails de compatibilité, dans le Matrice de compatibilité Jetson Zoo ONNX Runtime. Ici, nous allons télécharger et installer onnxruntime-gpu 1.20.0 avec Python3.10 support.
pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whl
Remarque
onnxruntime-gpu restaurera automatiquement la version numpy à la dernière version. Nous devons donc réinstaller numpy pour 1.23.5 pour résoudre un problème en exécutant :
pip install numpy==1.23.5
Exécuter sur JetPack 5.1.2
Installer le paquet Ultralytics
Ici, nous allons installer le package Ultralytics sur le Jetson avec les dépendances optionnelles afin de pouvoir exporter les modèles PyTorch vers d'autres formats différents. Nous nous concentrerons principalement sur les exportations NVIDIA TensorRT car TensorRT nous permettra d'obtenir les performances maximales des appareils Jetson.
Mettre à jour la liste des paquets, installer pip et mettre à niveau vers la dernière version
sudo apt update sudo apt install python3-pip -y pip install -U pipInstaller
ultralyticsPaquet pip avec des dépendances optionnellespip install ultralytics[export]Redémarrez l'appareil
sudo reboot
Installer PyTorch et Torchvision
L'installation d'ultralytics ci-dessus installera Torch et Torchvision. Cependant, ces deux paquets installés via pip ne sont pas compatibles avec la plateforme Jetson, qui est basée sur l'architecture ARM64. Par conséquent, nous devons installer manuellement une roue PyTorch pip préconstruite et compiler ou installer Torchvision à partir des sources.
Désinstaller PyTorch et Torchvision actuellement installés
pip uninstall torch torchvisionInstaller
torch 2.2.0ettorchvision 0.17.2conformément à JP5.1.2pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torch-2.2.0-cp38-cp38-linux_aarch64.whl pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/torchvision-0.17.2+c1d70fe-cp38-cp38-linux_aarch64.whl
Remarque
Consultez la page PyTorch pour Jetson pour accéder à toutes les différentes versions de PyTorch pour différentes versions de JetPack. Pour une liste plus détaillée sur la compatibilité de PyTorch, Torchvision, consultez la page de compatibilité PyTorch et Torchvision.
Installer onnxruntime-gpu
L'argument onnxruntime-gpu package hébergé dans PyPI n'a pas aarch64 binaires pour le Jetson. Nous devons donc installer ce paquet manuellement. Ce paquet est nécessaire pour certaines des exportations.
Vous pouvez trouver tous les onnxruntime-gpu packages, organisés par version de JetPack, version de Python et autres détails de compatibilité, dans le Matrice de compatibilité Jetson Zoo ONNX Runtime. Ici, nous allons télécharger et installer onnxruntime-gpu 1.17.0 avec Python3.8 support.
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.whl
Remarque
onnxruntime-gpu restaurera automatiquement la version numpy à la dernière version. Nous devons donc réinstaller numpy pour 1.23.5 pour résoudre 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 meilleures performances d’inférence sur les appareils NVIDIA Jetson, ce qui en fait notre principale recommandation pour les déploiements Jetson. Pour obtenir des instructions de configuration et une utilisation avancée, consultez notre guide d’intégration TensorRT dédié.
Convertir le modèle en TensorRT et exécuter l'inférence
Le modèle YOLO11n au format PyTorch est converti en TensorRT pour exécuter l'inférence avec le modèle exporté.
Exemple
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Export the model to TensorRT
model.export(format="engine") # creates 'yolo11n.engine'
# Load the exported TensorRT model
trt_model = YOLO("yolo11n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLO11n PyTorch model to TensorRT format
yolo export model=yolo11n.pt format=engine # creates 'yolo11n.engine'
# Run inference with the exported model
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'
Remarque
Consultez la page d’exportation pour accéder à des arguments supplémentaires lors de l’exportation de modèles vers différents formats de modèles.
Utiliser NVIDIA Deep Learning Accelerator (DLA)
NVIDIA Deep Learning Accelerator (DLA) est un composant matériel spécialisé intégré aux appareils NVIDIA Jetson qui optimise l'inférence du deep learning pour l'efficacité énergétique et la performance. En déchargeant les tâches du GPU (le libérant pour des processus plus intensifs), DLA permet aux modèles de fonctionner avec une consommation d'énergie plus faible tout en maintenant un débit élevé, idéal pour les systèmes embarqués et les applications d'IA en temps réel.
Les appareils Jetson suivants sont équipés du matériel DLA :
| Périphérique Jetson | Cœurs DLA | Fréquence maximale DLA |
|---|---|---|
| Série Jetson AGX Orin | 2 | 1.6 GHz |
| Jetson Orin NX 16 Go | 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 |
Exemple
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Export the model to TensorRT with DLA enabled (only works with FP16 or INT8)
model.export(format="engine", device="dla:0", half=True) # dla:0 or dla:1 corresponds to the DLA cores
# Load the exported TensorRT model
trt_model = YOLO("yolo11n.engine")
# Run inference
results = trt_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLO11n PyTorch model to TensorRT format with DLA enabled (only works with FP16 or INT8)
# Once DLA core number is specified at export, it will use the same core at inference
yolo export model=yolo11n.pt format=engine device="dla:0" half=True # dla:0 or dla:1 corresponds to the DLA cores
# Run inference with the exported model on the DLA
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'
Remarque
Lors de l'utilisation des exportations DLA, certaines couches peuvent ne pas être prises en charge pour s'exécuter sur DLA et reviendront au GPU pour l'exécution. Ce repli peut introduire une latence supplémentaire et avoir un impact sur les performances globales de l'inférence. Par conséquent, DLA n'est pas principalement conçu pour réduire la latence d'inférence par rapport à TensorRT s'exécutant entièrement sur le GPU. Au lieu de cela, son objectif principal est d'augmenter le débit et d'améliorer l'efficacité énergétique.
Benchmarks NVIDIA Jetson YOLO11
Les benchmarks YOLO11 ont été réalisés par l'équipe d'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 kits de développement NVIDIA Jetson AGX Thor, NVIDIA Jetson AGX Orin (64 Go), NVIDIA Jetson Orin Nano Super Developer Kit et Seeed Studio reComputer J4012 équipé d'un périphérique Jetson Orin NX de 16 Go à la précision FP32 avec une taille d'image d'entrée par défaut de 640.
Tableaux comparatifs
Même si toutes les exportations de modèles fonctionnent avec NVIDIA Jetson, nous n'avons inclus que PyTorch, TorchScript, TensorRT pour le tableau comparatif ci-dessous, car ils utilisent le GPU sur le Jetson et sont garantis pour produire les meilleurs résultats. Toutes les autres exportations utilisent uniquement le CPU et les performances ne sont pas aussi bonnes que les trois ci-dessus. Vous pouvez trouver des benchmarks pour toutes les exportations dans la section après ce tableau.
Kit de développement NVIDIA Jetson AGX Thor
Kit de développement NVIDIA Jetson AGX Orin (64 Go)
Kit de super développement NVIDIA Jetson Orin Nano
NVIDIA Jetson Orin NX 16GB
Tableaux comparatifs détaillés
Le tableau ci-dessous représente les résultats du benchmark pour cinq modèles différents (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) dans 11 formats différentsPyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN, ExecuTorch), nous donnant l'état, 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
Performance
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.4 | 0.5070 | 4.1 |
| TorchScript | ✅ | 10.5 | 0.5083 | 3.61 |
| ONNX | ✅ | 10.2 | 0.5076 | 4.8 |
| OpenVINO | ✅ | 10.4 | 0.5058 | 16.48 |
| TensorRT (FP32) | ✅ | 12.6 | 0.5077 | 1.70 |
| TensorRT (FP16) | ✅ | 7.7 | 0.5075 | 1.20 |
| TensorRT (INT8) | ✅ | 6.2 | 0.4858 | 1.29 |
| TF SavedModel | ✅ | 25.7 | 0.5076 | 40.35 |
| TF GraphDef | ✅ | 10.3 | 0.5076 | 40.55 |
| TF Lite | ✅ | 10.3 | 0.5075 | 206.74 |
| MNN | ✅ | 10.1 | 0.5075 | 23.47 |
| NCNN | ✅ | 10.2 | 0.5041 | 22.05 |
| ExecuTorch | ✅ | 10.2 | 0.5075 | 34.28 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 18.4 | 0.5770 | 6.10 |
| TorchScript | ✅ | 36.6 | 0.5783 | 5.33 |
| ONNX | ✅ | 36.3 | 0.5783 | 7.01 |
| OpenVINO | ✅ | 36.4 | 0.5809 | 33.08 |
| TensorRT (FP32) | ✅ | 40.1 | 0.5784 | 2.57 |
| TensorRT (FP16) | ✅ | 20.8 | 0.5796 | 1.55 |
| TensorRT (INT8) | ✅ | 12.7 | 0.5514 | 1.50 |
| TF SavedModel | ✅ | 90.8 | 0.5782 | 80.55 |
| TF GraphDef | ✅ | 36.3 | 0.5782 | 80.82 |
| TF Lite | ✅ | 36.3 | 0.5782 | 615.29 |
| MNN | ✅ | 36.2 | 0.5790 | 54.12 |
| NCNN | ✅ | 36.3 | 0.5806 | 40.76 |
| ExecuTorch | ✅ | 36.2 | 0.5782 | 67.21 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 38.8 | 0.6250 | 11.4 |
| TorchScript | ✅ | 77.3 | 0.6304 | 10.16 |
| ONNX | ✅ | 76.9 | 0.6304 | 12.35 |
| OpenVINO | ✅ | 77.1 | 0.6284 | 77.81 |
| TensorRT (FP32) | ✅ | 80.7 | 0.6305 | 5.29 |
| TensorRT (FP16) | ✅ | 41.3 | 0.6294 | 2.42 |
| TensorRT (INT8) | ✅ | 23.7 | 0.6133 | 2.20 |
| TF SavedModel | ✅ | 192.4 | 0.6306 | 184.66 |
| TF GraphDef | ✅ | 76.9 | 0.6306 | 187.91 |
| TF Lite | ✅ | 76.9 | 0.6306 | 1845.09 |
| MNN | ✅ | 76.8 | 0.6298 | 143.52 |
| NCNN | ✅ | 76.9 | 0.6308 | 95.86 |
| ExecuTorch | ✅ | 76.9 | 0.6306 | 167.94 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 49.0 | 0.6370 | 14.0 |
| TorchScript | ✅ | 97.6 | 0.6409 | 13.77 |
| ONNX | ✅ | 97.0 | 0.6410 | 16.37 |
| OpenVINO | ✅ | 97.3 | 0.6377 | 98.86 |
| TensorRT (FP32) | ✅ | 101.0 | 0.6396 | 6.71 |
| TensorRT (FP16) | ✅ | 51.5 | 0.6358 | 3.26 |
| TensorRT (INT8) | ✅ | 29.7 | 0.6190 | 3.21 |
| TF SavedModel | ✅ | 242.7 | 0.6409 | 246.93 |
| TF GraphDef | ✅ | 97.0 | 0.6409 | 251.84 |
| TF Lite | ✅ | 97.0 | 0.6409 | 2383.45 |
| MNN | ✅ | 96.9 | 0.6361 | 176.53 |
| NCNN | ✅ | 97.0 | 0.6373 | 118.05 |
| ExecuTorch | ✅ | 97.0 | 0.6409 | 211.46 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 109.3 | 0.6990 | 21.70 |
| TorchScript | ✅ | 218.1 | 0.6900 | 20.99 |
| ONNX | ✅ | 217.5 | 0.6900 | 24.07 |
| OpenVINO | ✅ | 217.8 | 0.6872 | 187.33 |
| TensorRT (FP32) | ✅ | 220.0 | 0.6902 | 11.70 |
| TensorRT (FP16) | ✅ | 114.6 | 0.6881 | 5.10 |
| TensorRT (INT8) | ✅ | 59.9 | 0.6857 | 4.53 |
| TF SavedModel | ✅ | 543.9 | 0.6900 | 489.91 |
| TF GraphDef | ✅ | 217.5 | 0.6900 | 503.21 |
| TF Lite | ✅ | 217.5 | 0.6900 | 5164.31 |
| MNN | ✅ | 217.3 | 0.6905 | 350.37 |
| NCNN | ✅ | 217.5 | 0.6901 | 230.63 |
| ExecuTorch | ✅ | 217.4 | 0.6900 | 419.9 |
Comparaison avec Ultralytics 8.3.226
Remarque
Le temps d'inférence n'inclut pas le prétraitement ni le post-traitement.
Kit de développement NVIDIA Jetson AGX Orin (64 Go)
Performance
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.4 | 0.5101 | 9.40 |
| TorchScript | ✅ | 10.5 | 0.5083 | 11.00 |
| ONNX | ✅ | 10.2 | 0.5077 | 48.32 |
| OpenVINO | ✅ | 10.4 | 0.5058 | 27.24 |
| TensorRT (FP32) | ✅ | 12.1 | 0.5085 | 3.93 |
| TensorRT (FP16) | ✅ | 8.3 | 0.5063 | 2.55 |
| TensorRT (INT8) | ✅ | 5.4 | 0.4719 | 2.18 |
| TF SavedModel | ✅ | 25.9 | 0.5077 | 66.87 |
| TF GraphDef | ✅ | 10.3 | 0.5077 | 65.68 |
| TF Lite | ✅ | 10.3 | 0.5077 | 272.92 |
| MNN | ✅ | 10.1 | 0.5059 | 36.33 |
| NCNN | ✅ | 10.2 | 0.5031 | 28.51 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 18.4 | 0.5783 | 12.10 |
| TorchScript | ✅ | 36.5 | 0.5782 | 11.01 |
| ONNX | ✅ | 36.3 | 0.5782 | 107.54 |
| OpenVINO | ✅ | 36.4 | 0.5810 | 55.03 |
| TensorRT (FP32) | ✅ | 38.1 | 0.5781 | 6.52 |
| TensorRT (FP16) | ✅ | 21.4 | 0.5803 | 3.65 |
| TensorRT (INT8) | ✅ | 12.1 | 0.5735 | 2.81 |
| TF SavedModel | ✅ | 91.0 | 0.5782 | 132.73 |
| TF GraphDef | ✅ | 36.4 | 0.5782 | 134.96 |
| TF Lite | ✅ | 36.3 | 0.5782 | 798.21 |
| MNN | ✅ | 36.2 | 0.5777 | 82.35 |
| NCNN | ✅ | 36.2 | 0.5784 | 56.07 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 38.8 | 0.6265 | 22.20 |
| TorchScript | ✅ | 77.3 | 0.6307 | 21.47 |
| ONNX | ✅ | 76.9 | 0.6307 | 270.89 |
| OpenVINO | ✅ | 77.1 | 0.6284 | 129.10 |
| TensorRT (FP32) | ✅ | 78.8 | 0.6306 | 12.53 |
| TensorRT (FP16) | ✅ | 41.9 | 0.6305 | 6.25 |
| TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 4.69 |
| TF SavedModel | ✅ | 192.7 | 0.6307 | 299.95 |
| TF GraphDef | ✅ | 77.1 | 0.6307 | 310.58 |
| TF Lite | ✅ | 77.0 | 0.6307 | 2400.54 |
| MNN | ✅ | 76.8 | 0.6308 | 213.56 |
| NCNN | ✅ | 76.8 | 0.6284 | 141.18 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 49.0 | 0.6364 | 27.70 |
| TorchScript | ✅ | 97.6 | 0.6399 | 27.94 |
| ONNX | ✅ | 97.0 | 0.6409 | 345.47 |
| OpenVINO | ✅ | 97.3 | 0.6378 | 161.93 |
| TensorRT (FP32) | ✅ | 99.1 | 0.6406 | 16.11 |
| TensorRT (FP16) | ✅ | 52.6 | 0.6376 | 8.08 |
| TensorRT (INT8) | ✅ | 30.8 | 0.6208 | 6.12 |
| TF SavedModel | ✅ | 243.1 | 0.6409 | 390.78 |
| TF GraphDef | ✅ | 97.2 | 0.6409 | 398.76 |
| TF Lite | ✅ | 97.1 | 0.6409 | 3037.05 |
| MNN | ✅ | 96.9 | 0.6372 | 265.46 |
| NCNN | ✅ | 96.9 | 0.6364 | 179.68 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 109.3 | 0.7005 | 44.40 |
| TorchScript | ✅ | 218.1 | 0.6898 | 47.49 |
| ONNX | ✅ | 217.5 | 0.6900 | 682.98 |
| OpenVINO | ✅ | 217.8 | 0.6876 | 298.15 |
| TensorRT (FP32) | ✅ | 219.6 | 0.6904 | 28.50 |
| TensorRT (FP16) | ✅ | 112.2 | 0.6887 | 13.55 |
| TensorRT (INT8) | ✅ | 60.0 | 0.6574 | 9.40 |
| TF SavedModel | ✅ | 544.3 | 0.6900 | 749.85 |
| TF GraphDef | ✅ | 217.7 | 0.6900 | 753.86 |
| TF Lite | ✅ | 217.6 | 0.6900 | 6603.27 |
| MNN | ✅ | 217.3 | 0.6868 | 519.77 |
| NCNN | ✅ | 217.3 | 0.6849 | 298.58 |
Étalonné avec Ultralytics 8.3.157
Remarque
Le temps d'inférence n'inclut pas le prétraitement ni le post-traitement.
Kit de super développement NVIDIA Jetson Orin Nano
Performance
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.4 | 0.5101 | 13.70 |
| TorchScript | ✅ | 10.5 | 0.5082 | 13.69 |
| ONNX | ✅ | 10.2 | 0.5081 | 14.47 |
| OpenVINO | ✅ | 10.4 | 0.5058 | 56.66 |
| TensorRT (FP32) | ✅ | 12.0 | 0.5081 | 7.44 |
| TensorRT (FP16) | ✅ | 8.2 | 0.5061 | 4.53 |
| TensorRT (INT8) | ✅ | 5.4 | 0.4825 | 3.70 |
| TF SavedModel | ✅ | 25.9 | 0.5077 | 116.23 |
| TF GraphDef | ✅ | 10.3 | 0.5077 | 114.92 |
| TF Lite | ✅ | 10.3 | 0.5077 | 340.75 |
| MNN | ✅ | 10.1 | 0.5059 | 76.26 |
| NCNN | ✅ | 10.2 | 0.5031 | 45.03 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 18.4 | 0.5790 | 20.90 |
| TorchScript | ✅ | 36.5 | 0.5781 | 21.22 |
| ONNX | ✅ | 36.3 | 0.5781 | 25.07 |
| OpenVINO | ✅ | 36.4 | 0.5810 | 122.98 |
| TensorRT (FP32) | ✅ | 37.9 | 0.5783 | 13.02 |
| TensorRT (FP16) | ✅ | 21.8 | 0.5779 | 6.93 |
| TensorRT (INT8) | ✅ | 12.2 | 0.5735 | 5.08 |
| TF SavedModel | ✅ | 91.0 | 0.5782 | 250.65 |
| TF GraphDef | ✅ | 36.4 | 0.5782 | 252.69 |
| TF Lite | ✅ | 36.3 | 0.5782 | 998.68 |
| MNN | ✅ | 36.2 | 0.5781 | 188.01 |
| NCNN | ✅ | 36.2 | 0.5784 | 101.37 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 38.8 | 0.6266 | 46.50 |
| TorchScript | ✅ | 77.3 | 0.6307 | 47.95 |
| ONNX | ✅ | 76.9 | 0.6307 | 53.06 |
| OpenVINO | ✅ | 77.1 | 0.6284 | 301.63 |
| TensorRT (FP32) | ✅ | 78.8 | 0.6305 | 27.86 |
| TensorRT (FP16) | ✅ | 41.7 | 0.6309 | 13.50 |
| TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 9.12 |
| TF SavedModel | ✅ | 192.7 | 0.6307 | 622.24 |
| TF GraphDef | ✅ | 77.1 | 0.6307 | 628.74 |
| TF Lite | ✅ | 77.0 | 0.6307 | 2997.93 |
| MNN | ✅ | 76.8 | 0.6299 | 509.96 |
| NCNN | ✅ | 76.8 | 0.6284 | 292.99 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 49.0 | 0.6364 | 56.50 |
| TorchScript | ✅ | 97.6 | 0.6409 | 62.51 |
| ONNX | ✅ | 97.0 | 0.6399 | 68.35 |
| OpenVINO | ✅ | 97.3 | 0.6378 | 376.03 |
| TensorRT (FP32) | ✅ | 99.2 | 0.6396 | 35.59 |
| TensorRT (FP16) | ✅ | 52.1 | 0.6361 | 17.48 |
| TensorRT (INT8) | ✅ | 30.9 | 0.6207 | 11.87 |
| TF SavedModel | ✅ | 243.1 | 0.6409 | 807.47 |
| TF GraphDef | ✅ | 97.2 | 0.6409 | 822.88 |
| TF Lite | ✅ | 97.1 | 0.6409 | 3792.23 |
| MNN | ✅ | 96.9 | 0.6372 | 631.16 |
| NCNN | ✅ | 96.9 | 0.6364 | 350.46 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 109.3 | 0.7005 | 90.00 |
| TorchScript | ✅ | 218.1 | 0.6901 | 113.40 |
| ONNX | ✅ | 217.5 | 0.6901 | 122.94 |
| OpenVINO | ✅ | 217.8 | 0.6876 | 713.1 |
| TensorRT (FP32) | ✅ | 219.5 | 0.6904 | 66.93 |
| TensorRT (FP16) | ✅ | 112.2 | 0.6892 | 32.58 |
| TensorRT (INT8) | ✅ | 61.5 | 0.6612 | 19.90 |
| TF SavedModel | ✅ | 544.3 | 0.6900 | 1605.4 |
| TF GraphDef | ✅ | 217.8 | 0.6900 | 2961.8 |
| TF Lite | ✅ | 217.6 | 0.6900 | 8234.86 |
| MNN | ✅ | 217.3 | 0.6893 | 1254.18 |
| NCNN | ✅ | 217.3 | 0.6849 | 725.50 |
Étalonné avec Ultralytics 8.3.157
Remarque
Le temps d'inférence n'inclut pas le prétraitement ni le post-traitement.
NVIDIA Jetson Orin NX 16GB
Performance
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 5.4 | 0.5101 | 12.90 |
| TorchScript | ✅ | 10.5 | 0.5082 | 13.17 |
| ONNX | ✅ | 10.2 | 0.5081 | 15.43 |
| OpenVINO | ✅ | 10.4 | 0.5058 | 39.80 |
| TensorRT (FP32) | ✅ | 11.8 | 0.5081 | 7.94 |
| TensorRT (FP16) | ✅ | 8.1 | 0.5085 | 4.73 |
| TensorRT (INT8) | ✅ | 5.4 | 0.4786 | 3.90 |
| TF SavedModel | ✅ | 25.9 | 0.5077 | 88.48 |
| TF GraphDef | ✅ | 10.3 | 0.5077 | 86.67 |
| TF Lite | ✅ | 10.3 | 0.5077 | 302.55 |
| MNN | ✅ | 10.1 | 0.5059 | 52.73 |
| NCNN | ✅ | 10.2 | 0.5031 | 32.04 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 18.4 | 0.5790 | 21.70 |
| TorchScript | ✅ | 36.5 | 0.5781 | 22.71 |
| ONNX | ✅ | 36.3 | 0.5781 | 26.49 |
| OpenVINO | ✅ | 36.4 | 0.5810 | 84.73 |
| TensorRT (FP32) | ✅ | 37.8 | 0.5783 | 13.77 |
| TensorRT (FP16) | ✅ | 21.2 | 0.5796 | 7.31 |
| TensorRT (INT8) | ✅ | 12.0 | 0.5735 | 5.33 |
| TF SavedModel | ✅ | 91.0 | 0.5782 | 185.06 |
| TF GraphDef | ✅ | 36.4 | 0.5782 | 186.45 |
| TF Lite | ✅ | 36.3 | 0.5782 | 882.58 |
| MNN | ✅ | 36.2 | 0.5775 | 126.36 |
| NCNN | ✅ | 36.2 | 0.5784 | 66.73 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 38.8 | 0.6266 | 45.00 |
| TorchScript | ✅ | 77.3 | 0.6307 | 51.87 |
| ONNX | ✅ | 76.9 | 0.6307 | 56.00 |
| OpenVINO | ✅ | 77.1 | 0.6284 | 202.69 |
| TensorRT (FP32) | ✅ | 78.7 | 0.6305 | 30.38 |
| TensorRT (FP16) | ✅ | 41.8 | 0.6302 | 14.48 |
| TensorRT (INT8) | ✅ | 23.2 | 0.6291 | 9.74 |
| TF SavedModel | ✅ | 192.7 | 0.6307 | 445.58 |
| TF GraphDef | ✅ | 77.1 | 0.6307 | 460.94 |
| TF Lite | ✅ | 77.0 | 0.6307 | 2653.65 |
| MNN | ✅ | 76.8 | 0.6308 | 339.38 |
| NCNN | ✅ | 76.8 | 0.6284 | 187.64 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 49.0 | 0.6364 | 56.60 |
| TorchScript | ✅ | 97.6 | 0.6409 | 66.72 |
| ONNX | ✅ | 97.0 | 0.6399 | 71.92 |
| OpenVINO | ✅ | 97.3 | 0.6378 | 254.17 |
| TensorRT (FP32) | ✅ | 99.2 | 0.6406 | 38.89 |
| TensorRT (FP16) | ✅ | 51.9 | 0.6363 | 18.59 |
| TensorRT (INT8) | ✅ | 30.9 | 0.6207 | 12.60 |
| TF SavedModel | ✅ | 243.1 | 0.6409 | 575.98 |
| TF GraphDef | ✅ | 97.2 | 0.6409 | 583.79 |
| TF Lite | ✅ | 97.1 | 0.6409 | 3353.41 |
| MNN | ✅ | 96.9 | 0.6367 | 421.33 |
| NCNN | ✅ | 96.9 | 0.6364 | 228.26 |
| Format | Statut | Taille sur le disque (Mo) | mAP50-95(B) | Temps d'inférence (ms/im) |
|---|---|---|---|---|
| PyTorch | ✅ | 109.3 | 0.7005 | 98.50 |
| TorchScript | ✅ | 218.1 | 0.6901 | 123.03 |
| ONNX | ✅ | 217.5 | 0.6901 | 129.55 |
| OpenVINO | ✅ | 217.8 | 0.6876 | 483.44 |
| TensorRT (FP32) | ✅ | 219.6 | 0.6904 | 75.92 |
| TensorRT (FP16) | ✅ | 112.1 | 0.6885 | 35.78 |
| TensorRT (INT8) | ✅ | 61.6 | 0.6592 | 21.60 |
| TF SavedModel | ✅ | 544.3 | 0.6900 | 1120.43 |
| TF GraphDef | ✅ | 217.7 | 0.6900 | 1172.35 |
| TF Lite | ✅ | 217.6 | 0.6900 | 7283.63 |
| MNN | ✅ | 217.3 | 0.6877 | 840.16 |
| NCNN | ✅ | 217.3 | 0.6849 | 474.41 |
Étalonné avec Ultralytics 8.3.157
Remarque
Le temps d'inférence n'inclut pas le prétraitement ni le post-traitement.
Explorez d'autres efforts de benchmarking de Seeed Studio s'exécutant sur différentes versions du matériel NVIDIA Jetson.
Reproduire nos résultats
Pour reproduire les benchmarks Ultralytics ci-dessus sur tous les formats d’exportation, exécutez ce code :
Exemple
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all all export formats
results = model.benchmark(data="coco128.yaml", imgsz=640)
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all all export formats
yolo benchmark model=yolo11n.pt data=coco128.yaml imgsz=640
Notez 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 la charge de travail actuelle du système au moment où les benchmarks sont exécutés. Pour obtenir les résultats les plus fiables, utilisez un ensemble de données contenant un grand nombre d'images, c'est-à-dire data='coco.yaml' (5000 images de validation).
Meilleures pratiques lors de l'utilisation de NVIDIA Jetson
Lors de l'utilisation de NVIDIA Jetson, il existe quelques bonnes pratiques à suivre afin d'activer des performances maximales sur le NVIDIA Jetson exécutant YOLO11.
Activer le mode de puissance MAX
L'activation du mode de puissance MAX sur le Jetson permettra de s'assurer que tous les cœurs du CPU et du GPU sont activés.
sudo nvpmodel -m 0Activer les horloges Jetson
L'activation des horloges Jetson garantira que tous les cœurs CPU et GPU sont cadencés à leur fréquence maximale.
sudo jetson_clocksInstaller l’application Jetson Stats
Nous pouvons utiliser l'application jetson stats pour surveiller les températures des composants du système et vérifier d'autres détails du système tels que l'utilisation du CPU, du GPU, de la RAM, modifier les modes d'alimentation, régler les horloges au maximum, vérifier les informations de JetPack.
sudo apt update sudo pip install jetson-stats sudo reboot jtop
Prochaines étapes
Félicitations pour avoir configuré YOLO11 avec succès sur votre NVIDIA Jetson ! Pour plus d’informations et d’assistance, consultez d’autres guides sur Ultralytics YOLO11 Docs !
FAQ
Comment déployer Ultralytics YOLO11 sur les appareils NVIDIA Jetson ?
Le déploiement d'Ultralytics YOLO11 sur les appareils NVIDIA Jetson est un processus simple. Tout d'abord, flashez votre appareil Jetson avec le SDK NVIDIA JetPack. Ensuite, utilisez une image Docker pré-construite pour une configuration rapide ou installez manuellement les packages requis. Vous trouverez des instructions détaillées pour chaque approche dans les sections Démarrage rapide avec Docker et Démarrer avec l'installation native.
Quels benchmarks de performance puis-je attendre des modèles YOLO11 sur les appareils NVIDIA Jetson ?
Les modèles YOLO11 ont été évalués sur divers appareils NVIDIA Jetson, montrant des améliorations significatives en termes de performances. Par exemple, le format TensorRT offre les meilleures performances d'inférence. Le tableau de la section Tableaux de comparaison détaillés offre une vue complète des mesures de performance telles que mAP50-95 et le temps d'inférence pour différents formats de modèles.
Pourquoi devrais-je utiliser TensorRT pour déployer YOLO11 sur NVIDIA Jetson ?
TensorRT est fortement recommandé pour le déploiement de modèles YOLO11 sur NVIDIA Jetson en raison de ses performances optimales. Il accélère l'inférence en tirant parti des capacités 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, consultez la section Utiliser TensorRT sur NVIDIA Jetson.
Comment puis-je installer PyTorch et Torchvision sur NVIDIA Jetson ?
Pour installer PyTorch et Torchvision sur NVIDIA Jetson, désinstallez d'abord toutes les versions existantes qui ont pu être installées via pip. Ensuite, installez manuellement les versions compatibles de PyTorch et Torchvision pour l'architecture ARM64 de Jetson. Des instructions détaillées pour ce processus sont fournies dans la section Installer PyTorch et Torchvision.
Quelles sont les meilleures pratiques pour maximiser les performances sur NVIDIA Jetson lors de l'utilisation de YOLO11 ?
Pour maximiser les performances sur NVIDIA Jetson avec YOLO11, suivez ces bonnes pratiques :
- Activez le mode de puissance MAX pour utiliser tous les cœurs CPU et GPU.
- Activez les horloges Jetson pour exécuter tous les cœurs à leur fréquence maximale.
- Installer l'application Jetson Stats pour surveiller les métriques du système.
Pour les commandes et les détails supplémentaires, consultez la section Meilleures pratiques lors de l'utilisation de NVIDIA Jetson.
