Skip to content

Guide de démarrage rapide : NVIDIA Jetson avec Ultralytics YOLO11

Ce guide complet fournit une marche à suivre détaillée pour déployer Ultralytics YOLO11 sur NVIDIA Jetson devices. En outre, il présente des repères de performance pour démontrer les capacités de YOLO11 sur ces appareils petits et puissants.

Soutien aux nouveaux produits

Nous avons mis à jour ce guide avec le dernier NVIDIA Jetson Orin Nano Super Developer Kit qui offre jusqu'à 67 TOPS de performance IA - une amélioration de 1,7 fois par rapport à son prédécesseur - pour exécuter de manière transparente les modèles IA les plus populaires.



Regarder : Comment utiliser Ultralytics YOLO11 sur les appareils NVIDIA JETSON

NVIDIA L'écosystème Jetson

Note

Ce guide a été testé avec NVIDIA Jetson Orin Nano Super Developer Kit fonctionnant avec la dernière version stable de JetPack, JP6.1, Seeed Studio reComputer J4012 qui est basé sur NVIDIA Jetson Orin NX 16GB fonctionnant avec la version de 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 de JetPack JP4.6.1. Il devrait fonctionner sur l'ensemble de 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'accélération de l'informatique 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 informatiques 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é. En outre, ces cartes sont basées sur l'architecture ARM64 et fonctionnent à faible consommation par rapport aux dispositifs informatiques traditionnels GPU .

NVIDIA Comparaison des séries Jetson

Jetson Orin est la dernière itération de la famille Jetson NVIDIA basée sur l'architecture Ampere NVIDIA qui améliore considérablement les performances de l'intelligence artificielle par rapport aux générations précédentes. Le tableau ci-dessous compare quelques-uns des appareils Jetson présents dans l'écosystème.

Jetson AGX Orin 64GB Jetson Orin NX 16GB Jetson Orin Nano Super Jetson AGX Xavier Jetson Xavier NX Jetson Nano
Performance de l'IA 275 TOPS 100 TOPS 67 TOPs 32 TOPS 21 TOPS 472 GFLOPS
GPU 2048 cœurs NVIDIA Architecture Ampère GPU avec 64 cœurs Tensor 1024 cœurs NVIDIA Architecture Ampere GPU avec 32 cœurs Tensor 1024 cœurs NVIDIA Architecture Ampere GPU avec 32 cœurs Tensor 512 cœurs NVIDIA Architecture Volta GPU avec 64 cœurs Tensor 384 cœurs NVIDIA Architecture Volta™ GPU avec 48 cœurs Tensor Architecture NVIDIA Maxwell™ à 128 cœurs GPU
GPU Fréquence maximale 1,3 GHz 918 MHz 1020 MHz 1377 MHz 1100 MHz 921MHz
CPU 12 cœurs NVIDIA Arm® Cortex A78AE v8.2 64-bit CPU 3MB L2 + 6MB L3 8 cœurs NVIDIA Arm® Cortex A78AE v8.2 64-bit CPU 2MB L2 + 4MB L3 Arm® Cortex®-A78AE v8.2 64-bit CPU 1.5MB L2 + 4MB L3 8 cœurs NVIDIA Carmel Arm®v8.2 64-bit CPU 8MB L2 + 4MB L3 6 cœurs NVIDIA Carmel Arm®v8.2 64-bit CPU 6MB L2 + 4MB L3 Processeur quadricœur Arm® Cortex®-A57 MPCore
CPU Fréquence maximale 2,2 GHz 2,0 GHz 1,7 GHz 2,2 GHz 1,9 GHz 1,43 GHz
Mémoire 64GB 256-bit LPDDR5 204.8GB/s 16GB 128-bit LPDDR5 102.4GB/s 8GB 128-bit LPDDR5 102 GB/s 32GB 256-bit LPDDR4x 136.5GB/s 8GB 128-bit LPDDR4x 59.7GB/s 4GB 64-bit LPDDR4 25.6GB/s"

Pour un tableau comparatif plus détaillé, veuillez consulter la section Spécifications techniques de la page officielle NVIDIA Jetson.

Qu'est-ce que NVIDIA JetPack ?

Le SDKNVIDIA JetPack qui équipe les modules Jetson est la solution la plus complète et fournit un environnement de développement complet pour créer des applications d'IA accélérées de bout en bout et raccourcir le temps de mise sur le marché. JetPack comprend Jetson Linux avec le chargeur de démarrage, le noyau Linux, l'environnement de bureau Ubuntu et un ensemble complet de bibliothèques pour l'accélération du calcul GPU , le multimédia, le graphisme et la vision par ordinateur. Il comprend également des échantillons, 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.

Flash JetPack pour 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.

  1. Si vous possédez un kit de développement officiel NVIDIA 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.
  2. Si vous possédez un autre kit de développement NVIDIA , vous pouvez flasher JetPack sur l'appareil à l'aide du SDK Manager.
  3. 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.
  4. Si vous possédez un autre appareil tiers alimenté par le module Jetson de NVIDIA , il est recommandé de suivre le flashage en ligne de commande.

Note

Pour les méthodes 3 et 4 ci-dessus, après avoir flashé le système et démarré l'appareil, veuillez saisir "sudo apt update && sudo apt install nvidia-jetpack -y" sur le terminal de l'appareil pour installer tous les composants JetPack restants nécessaires.

Support de JetPack basé sur le dispositif 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
Jetson Nano ✅ ❌ ❌
Jetson TX2 ✅ ❌ ❌
Jetson Xavier NX ✅ ✅ ❌
Jetson AGX Xavier ✅ ✅ ❌
Jetson AGX Orin ❌ ✅ ✅
Jetson Orin NX ❌ ✅ ✅
Jetson Orin Nano ❌ ✅ ✅

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

Après cela, passez à la section Utiliser TensorRT sur NVIDIA Jetson.

Commencer par l'installation native

Pour une installation native sans Docker, veuillez vous référer aux étapes ci-dessous.

Exécuter sur JetPack 6.1

Installer le paquet Ultralytics

Ici, nous allons installer le paquet Ultralytics sur le Jetson avec les dépendances optionnelles afin que nous puissions exporter les modèles dans d'autres formats. PyTorch vers d'autres formats différents. Nous nous concentrerons principalement sur les exportationsNVIDIA TensorRT car TensorRT nous permettra d'obtenir des performances maximales sur les appareils Jetson.

  1. Mise à jour de la liste des paquets, installation de pip et mise à niveau vers la dernière version

    sudo apt update
sudo apt install python3-pip -y
pip install -U pip

  2. Installer ultralytics paquetage pip avec dépendances optionnelles

    pip install ultralytics[export]

  3. Redémarrer l'appareil

    sudo reboot

Installer PyTorch et Torchvision

L'installation de ultralytics ci-dessus permet d'installer Torch et Torchvision. Cependant, ces deux paquets installés via pip ne sont pas compatibles pour fonctionner sur la plateforme Jetson qui est basée sur l'architecture ARM64. Par conséquent, nous devons installer manuellement PyTorch pip wheel et compiler/installer Torchvision à partir des sources.

Installer torch 2.5.0 et torchvision 0.20 selon 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

Note

Visitez la pagePyTorch for Jetson pour accéder à toutes les versions de PyTorch pour les différentes versions de JetPack. Pour une liste plus détaillée des compatibilités PyTorch et Torchvision, visitez la pagePyTorch et Torchvision compatibility.

Installer cuSPARSELt pour résoudre 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

Le onnxruntime-gpu hébergé dans PyPI n'a pas de aarch64 pour la Jetson. Nous devons donc installer manuellement ce paquet. Ce paquet est nécessaire pour certaines exportations.

Tous différents onnxruntime-gpu Les paquets correspondant aux différentes versions de JetPack et de Python sont listés ici. Cependant, nous allons ici télécharger et installer onnxruntime-gpu 1.20.0 avec Python3.10 le soutien.

pip install https://github.com/ultralytics/assets/releases/download/v0.0.0/onnxruntime_gpu-1.20.0-cp310-cp310-linux_aarch64.whl

Note

onnxruntime-gpu va automatiquement ramener la version de numpy à sa dernière version. Nous devons donc réinstaller numpy à 1.23.5 pour résoudre un problème en exécutant :

pip install numpy==1.23.5

Fonctionne avec JetPack 5.1.2

Installer le paquet Ultralytics

Ici, nous allons installer le paquet Ultralytics sur le Jetson avec des dépendances optionnelles afin que nous puissions exporter les modèles PyTorch vers d'autres formats différents. Nous nous concentrerons principalement sur les exportationsNVIDIA TensorRT car TensorRT nous permettra d'obtenir les performances maximales des appareils Jetson.

  1. Mise à jour de la liste des paquets, installation de pip et mise à niveau vers la dernière version

    sudo apt update
sudo apt install python3-pip -y
pip install -U pip

  2. Installer ultralytics paquetage pip avec dépendances optionnelles

    pip install ultralytics[export]

  3. Redémarrer l'appareil

    sudo reboot

Installer PyTorch et Torchvision

L'installation de ultralytics ci-dessus permet d'installer Torch et Torchvision. Cependant, ces deux paquets installés via pip ne sont pas compatibles pour fonctionner sur la plateforme Jetson qui est basée sur l'architecture ARM64. Par conséquent, nous devons installer manuellement PyTorch pip wheel et compiler/installer Torchvision à partir des sources.

  1. Désinstaller les versions actuellement installées de PyTorch et Torchvision

    pip uninstall torch torchvision

  2. Installer torch 2.2.0 et torchvision 0.17.2 conformément à JP5.1.2

    pip 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

Note

Visitez la pagePyTorch for Jetson pour accéder à toutes les versions de PyTorch pour les différentes versions de JetPack. Pour une liste plus détaillée des compatibilités PyTorch et Torchvision, visitez la pagePyTorch et Torchvision compatibility.

Installer onnxruntime-gpu

Le onnxruntime-gpu hébergé dans PyPI n'a pas de aarch64 pour la Jetson. Nous devons donc installer manuellement ce paquet. Ce paquet est nécessaire pour certaines exportations.

Tous différents onnxruntime-gpu Les paquets correspondant aux différentes versions de JetPack et de Python sont listés ici. Cependant, nous allons ici télécharger et installer onnxruntime-gpu 1.17.0 avec Python3.8 le soutien.

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

Note

onnxruntime-gpu va automatiquement ramener la version de numpy à sa dernière version. Nous devons donc réinstaller numpy à 1.23.5 pour résoudre un problème en exécutant :

pip install numpy==1.23.5

Utilisez 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 lorsque l'on travaille avec NVIDIA Jetson devices et nous recommandons d'utiliser TensorRT avec Jetson. Nous avons également un document détaillé sur TensorRT ici.

Convertir le modèle en TensorRT et lancer 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'

Note

Visitez la page 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é dans les appareils Jetson de NVIDIA qui optimise l'inférence de l'apprentissage profond en termes d'efficacité énergétique et de performance. En déchargeant le site GPU de certaines tâches (en le libérant pour des processus plus intensifs), le DLA permet aux modèles de fonctionner avec une consommation d'énergie plus faible 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.

Les appareils Jetson suivants sont équipés de matériel DLA :

Dispositif Jetson Noyaux DLA DLA Fréquence maximale
Série Jetson AGX Orin 2 1,6 GHz
Jetson Orin NX 16GB 2 614 MHz
Jetson Orin NX 8GB 1 614 MHz
Jetson AGX Série 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'

Note

Lors de l'utilisation des exportations DLA, certaines couches peuvent ne pas être prises en charge pour fonctionner sur DLA et seront exécutées sur le site GPU . Cette solution de 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 de l'inférence par rapport à TensorRT fonctionnant entièrement sur GPU. Son objectif principal est plutôt d'augmenter le débit et d'améliorer l'efficacité énergétique.

NVIDIA Jetson Orin YOLO11 Benchmarks

YOLO11 L'équipe de Ultralytics a réalisé des benchmarks sur 10 modèles de formats différents en mesurant la vitesse et la précision: PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel , TF GraphDef , TF Lite, PaddlePaddle, NCNN. Les tests ont été effectués sur NVIDIA Jetson Orin Nano Super Developer Kit et sur Seeed Studio reComputer J4012 équipé d'une Jetson Orin NX 16GB à la précision FP32 avec une taille d'image d'entrée par défaut de 640.

Tableaux de comparaison

Même si tous les modèles d'exportation fonctionnent avec NVIDIA Jetson, nous n'avons inclus que PyTorch, TorchScript, TensorRT dans le tableau comparatif ci-dessous parce qu'ils utilisent GPU sur le Jetson et qu'ils sont garantis de produire les meilleurs résultats. Toutes les autres exportations n'utilisent que CPU et leurs performances ne sont pas aussi bonnes que celles des trois exportations ci-dessus. Vous trouverez des points de référence pour toutes les exportations dans la section qui suit ce tableau.

NVIDIA Jetson Orin Nano Super Developer Kit

Jetson Orin Nano Super Benchmarks
Test de performance avec Ultralytics 8.3.51

NVIDIA Jetson Orin NX 16GB

Jetson Orin NX 16GB Benchmarks
Test de performance avec Ultralytics 8.3.51

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) sur dix formats différents (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel , TF GraphDef , TF Lite, PaddlePaddle, NCNN), nous donnant le statut, la taille, la métrique mAP50-95(B), et le temps d'inférence pour chaque combinaison.

NVIDIA Jetson Orin Nano Super Developer Kit

Performance

Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 5.4 0.6176 21.3
TorchScript ✅ 10.5 0.6100 13.40
ONNX ✅ 10.2 0.6100 7.94
OpenVINO ✅ 10.4 0.6091 57.36
TensorRT (FP32) ✅ 11.9 0.6082 7.60
TensorRT (FP16) ✅ 8.3 0.6096 4.91
TensorRT (INT8) ✅ 5.6 0.3180 3.91
TF SavedModel ✅ 25.8 0.6082 223.98
TF GraphDef ✅ 10.3 0.6082 289.95
TF Lite ✅ 10.3 0.6082 328.29
PaddlePaddle ✅ 20.4 0.6082 530.46
MNN ✅ 10.1 0.6120 74.75
NCNN ✅ 10.2 0.6106 46.12
Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 18.4 0.7526 22.00
TorchScript ✅ 36.5 0.7400 21.35
ONNX ✅ 36.3 0.7400 13.91
OpenVINO ✅ 36.4 0.7391 126.95
TensorRT (FP32) ✅ 38.0 0.7400 13.29
TensorRT (FP16) ✅ 21.3 0.7431 7.30
TensorRT (INT8) ✅ 12.2 0.3243 5.25
TF SavedModel ✅ 91.1 0.7400 406.73
TF GraphDef ✅ 36.4 0.7400 629.80
TF Lite ✅ 36.4 0.7400 953.98
PaddlePaddle ✅ 72.5 0.7400 1311.67
MNN ✅ 36.2 0.7392 187.66
NCNN ✅ 36.2 0.7403 122.02
Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 38.8 0.7598 33.00
TorchScript ✅ 77.3 0.7643 48.17
ONNX ✅ 76.9 0.7641 29.31
OpenVINO ✅ 77.1 0.7642 313.49
TensorRT (FP32) ✅ 78.7 0.7641 28.21
TensorRT (FP16) ✅ 41.8 0.7653 13.99
TensorRT (INT8) ✅ 23.2 0.4194 9.58
TF SavedModel ✅ 192.7 0.7643 802.30
TF GraphDef ✅ 77.0 0.7643 1335.42
TF Lite ✅ 77.0 0.7643 2842.42
PaddlePaddle ✅ 153.8 0.7643 3644.29
MNN ✅ 76.8 0.7648 503.90
NCNN ✅ 76.8 0.7674 298.78
Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 49.0 0.7475 43.00
TorchScript ✅ 97.6 0.7250 62.94
ONNX ✅ 97.0 0.7250 36.33
OpenVINO ✅ 97.3 0.7226 387.72
TensorRT (FP32) ✅ 99.1 0.7250 35.59
TensorRT (FP16) ✅ 52.0 0.7265 17.57
TensorRT (INT8) ✅ 31.0 0.4033 12.37
TF SavedModel ✅ 243.3 0.7250 1116.20
TF GraphDef ✅ 97.2 0.7250 1603.32
TF Lite ✅ 97.2 0.7250 3607.51
PaddlePaddle ✅ 193.9 0.7250 4890.90
MNN ✅ 96.9 0.7222 619.04
NCNN ✅ 96.9 0.7252 352.85
Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 109.3 0.8288 81.00
TorchScript ✅ 218.1 0.8308 113.49
ONNX ✅ 217.5 0.8308 75.20
OpenVINO ✅ 217.8 0.8285 508.12
TensorRT (FP32) ✅ 219.5 0.8307 67.32
TensorRT (FP16) ✅ 112.2 0.8248 32.94
TensorRT (INT8) ✅ 61.7 0.4854 20.72
TF SavedModel ✅ 545.0 0.8308 1048.8
TF GraphDef ✅ 217.8 0.8308 2961.8
TF Lite ✅ 217.8 0.8308 7898.8
PaddlePaddle ✅ 434.8 0.8308 9903.68
MNN ✅ 217.3 0.8308 1242.97
NCNN ✅ 217.3 0.8304 850.05

Test de performance avec Ultralytics 8.3.51

NVIDIA Jetson Orin NX 16GB

Performance

Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 5.4 0.6176 19.50
TorchScript ✅ 10.5 0.6100 13.03
ONNX ✅ 10.2 0.6100 8.44
OpenVINO ✅ 10.4 0.6091 40.83
TensorRT (FP32) ✅ 11.9 0.6100 8.05
TensorRT (FP16) ✅ 8.2 0.6096 4.85
TensorRT (INT8) ✅ 5.5 0.3180 4.37
TF SavedModel ✅ 25.8 0.6082 185.39
TF GraphDef ✅ 10.3 0.6082 244.85
TF Lite ✅ 10.3 0.6082 289.77
PaddlePaddle ✅ 20.4 0.6082 476.52
MNN ✅ 10.1 0.6120 53.37
NCNN ✅ 10.2 0.6106 33.55
Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 18.4 0.7526 19.00
TorchScript ✅ 36.5 0.7400 22.90
ONNX ✅ 36.3 0.7400 14.44
OpenVINO ✅ 36.4 0.7391 88.70
TensorRT (FP32) ✅ 37.9 0.7400 14.13
TensorRT (FP16) ✅ 21.6 0.7406 7.55
TensorRT (INT8) ✅ 12.2 0.3243 5.63
TF SavedModel ✅ 91.1 0.7400 317.61
TF GraphDef ✅ 36.4 0.7400 515.99
TF Lite ✅ 36.4 0.7400 838.85
PaddlePaddle ✅ 72.5 0.7400 1170.07
MNN ✅ 36.2 0.7413 125.23
NCNN ✅ 36.2 0.7403 68.13
Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 38.8 0.7598 36.50
TorchScript ✅ 77.3 0.7643 52.55
ONNX ✅ 76.9 0.7640 31.16
OpenVINO ✅ 77.1 0.7642 208.57
TensorRT (FP32) ✅ 78.7 0.7640 30.72
TensorRT (FP16) ✅ 41.5 0.7651 14.45
TensorRT (INT8) ✅ 23.3 0.4194 10.19
TF SavedModel ✅ 192.7 0.7643 590.11
TF GraphDef ✅ 77.0 0.7643 998.57
TF Lite ✅ 77.0 0.7643 2486.11
PaddlePaddle ✅ 153.8 0.7643 3236.09
MNN ✅ 76.8 0.7661 335.78
NCNN ✅ 76.8 0.7674 188.43
Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 49.0 0.7475 46.6
TorchScript ✅ 97.6 0.7250 66.54
ONNX ✅ 97.0 0.7250 39.55
OpenVINO ✅ 97.3 0.7226 262.44
TensorRT (FP32) ✅ 99.2 0.7250 38.68
TensorRT (FP16) ✅ 51.9 0.7265 18.53
TensorRT (INT8) ✅ 30.9 0.4033 13.36
TF SavedModel ✅ 243.3 0.7250 850.25
TF GraphDef ✅ 97.2 0.7250 1324.60
TF Lite ✅ 97.2 0.7250 3191.24
PaddlePaddle ✅ 193.9 0.7250 4204.97
MNN ✅ 96.9 0.7225 414.41
NCNN ✅ 96.9 0.7252 237.74
Format Statut Taille sur le disque (MB) mAP50-95(B) Temps d'inférence (ms/im)
PyTorch ✅ 109.3 0.8288 86.00
TorchScript ✅ 218.1 0.8308 122.43
ONNX ✅ 217.5 0.8307 77.50
OpenVINO ✅ 217.8 0.8285 508.12
TensorRT (FP32) ✅ 219.5 0.8307 76.44
TensorRT (FP16) ✅ 112.0 0.8309 35.99
TensorRT (INT8) ✅ 61.6 0.4854 22.32
TF SavedModel ✅ 545.0 0.8308 1470.06
TF GraphDef ✅ 217.8 0.8308 2549.78
TF Lite ✅ 217.8 0.8308 7025.44
PaddlePaddle ✅ 434.8 0.8308 8364.89
MNN ✅ 217.3 0.8289 827.13
NCNN ✅ 217.3 0.8304 490.29

Test de performance avec Ultralytics 8.3.51

Découvrez d'autres analyses comparatives réalisées par Seeed Studio sur différentes versions du matériel NVIDIA Jetson.

Reproduire nos résultats

Pour reproduire les résultats de Ultralytics 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 COCO8 dataset for all all export formats
results = model.benchmark(data="coco8.yaml", imgsz=640)

# Benchmark YOLO11n speed and accuracy on the COCO8 dataset for all all export formats
yolo benchmark model=yolo11n.pt data=coco8.yaml imgsz=640

Notez que les résultats de l'évaluation comparative 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 de l'exécution de l'évaluation comparative. Pour obtenir les résultats les plus fiables, utilisez un ensemble de données contenant un grand nombre d'images, c'est-à-dire un ensemble de données contenant un grand nombre d'images, c'est-à-dire un ensemble de données contenant un grand nombre d'images. data='coco8.yaml' (4 images val), ou data='coco.yaml' (5000 images de valeur).

Meilleures pratiques lors de l'utilisation de NVIDIA Jetson

Lors de l'utilisation de NVIDIA Jetson, il y a quelques bonnes pratiques à suivre afin d'obtenir des performances maximales sur NVIDIA Jetson exécutant YOLO11.

  1. Activer le mode d'alimentation MAX

    L'activation du mode MAX Power sur la Jetson permet de s'assurer que tous les cœurs CPU, GPU sont activés.

    sudo nvpmodel -m 0

  2. Activer les horloges Jetson

    L'activation des horloges Jetson permet de s'assurer que tous les cœurs CPU, GPU sont cadencés à leur fréquence maximale.

    sudo jetson_clocks

  3. Installer 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 CPU, GPU, l'utilisation de la RAM, changer les modes d'alimentation, régler les horloges au maximum, vérifier les informations JetPack.

    sudo apt update
sudo pip install jetson-stats
sudo reboot
jtop

Jetson Stats

Prochaines étapes

Félicitations pour avoir réussi à configurer YOLO11 sur votre NVIDIA Jetson ! Pour plus d'informations et d'assistance, visitez le guide Ultralytics YOLO11 Docs!

FAQ

Comment déployer Ultralytics YOLO11 sur les appareils NVIDIA Jetson ?

Le déploiement de Ultralytics YOLO11 sur NVIDIA Jetson est un processus simple. Tout d'abord, flashez votre appareil Jetson avec le SDK JetPack de NVIDIA . Ensuite, utilisez une image Docker préconstruite pour une installation rapide ou installez manuellement les paquets requis. Les étapes détaillées de chaque approche peuvent être trouvées dans les sections Démarrage rapide avec Docker et Démarrage avec l'installation native.

Quels sont les critères de performance auxquels je peux m'attendre avec les modèles YOLO11 sur les appareils NVIDIA Jetson ?

YOLO11 ont fait l'objet d'une analyse comparative sur divers appareils Jetson NVIDIA , qui a révélé 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 fournit une vue d'ensemble des mesures de performance telles que mAP50-95 et le temps d'inférence pour les 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 des modèles YOLO11 sur NVIDIA Jetson en raison de ses performances optimales. Il accélère l'inférence en exploitant les capacités de GPU de Jetson, ce qui garantit une efficacité et une vitesse maximales. Pour en savoir plus sur la conversion en TensorRT et l'exécution de l'inférence, consultez la section Utilisation de TensorRT sur NVIDIA Jetson.

Comment 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 PyTorch et Torchvision compatibles avec l'architecture ARM64 de la 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 optimiser les performances sur NVIDIA Jetson avec YOLO11, suivez ces bonnes pratiques :

  1. Activez le mode MAX Power pour utiliser tous les cœurs CPU et GPU .
  2. Activez les horloges Jetson pour faire fonctionner tous les cœurs à leur fréquence maximale.
  3. Installez l'application Jetson Stats pour surveiller les paramètres du système.

Pour les commandes et des détails supplémentaires, reportez-vous à la section Meilleures pratiques lors de l'utilisation de NVIDIA Jetson.

📅C réé il y a 11 mois ✏️ Mis à jour il y a 5 jours
glenn-jocher Y-T-G RizwanMunawar lakshanthad Rire-q justincdavis MatthewNoyce UltralytiqueAssistant Ahelsamahy Burhan-Q

Commentaires