Passer au contenu

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 NVIDIA Jetson Orin Nano Super Developer Kit qui offre jusqu'à 67 TOPS de performance d'IA, soit une amélioration de 1,7 fois par rapport à son prédécesseur, pour exécuter de manière transparente les modèles d'IA les plus populaires.



Regarder : Comment utiliser Ultralytics YOLO11 sur les appareils NVIDIA JETSON

Écosystème NVIDIA Jetson

Remarque

Ce guide a été testé avec NVIDIA Jetson AGX Orin Developer Kit (64 Go) exécutant la dernière version stable de JetPack JP6.2, NVIDIA Jetson Orin Nano Super Developer Kit exécutant la version JetPack JP6.1, Seeed Studio reComputer J4012 qui est basé sur NVIDIA Jetson Orin NX 16 Go exécutant la version JetPack JP6.0/ la version JetPack JP5.1.3 et Seeed Studio reComputer J1020 v2 qui est basé sur NVIDIA Jetson Nano 4 Go exécutant la version JetPack JP4.6.1. Il est prévu qu'il fonctionne sur toute la gamme de matériel NVIDIA Jetson, y compris les versions les plus récentes et les versions héritées.

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

Jetson Orin est la dernière itération de la famille NVIDIA Jetson basée sur l'architecture NVIDIA Ampere, qui apporte des performances d'IA considérablement améliorées par rapport aux générations précédentes. Le tableau ci-dessous compare quelques-uns des appareils Jetson de l'écosystème.

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 275 TOPS 100 TOPS 67 TOPs 32 TOPS 21 TOPS 472 GFLOPS
GPU 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,3 GHz 918 MHz 1020 MHz 1377 MHz 1100 MHz 921 MHz
CPU 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,2 GHz 2,0 GHz 1,7 GHz 2,2 GHz 1,9 GHz 1,43 GHz
Mémoire 64 Go LPDDR5 256 bits 204,8 Go/s 16 Go LPDDR5 128 bits 102,4 Go/s 8 Go LPDDR5 128 bits 102 Go/s 32 Go LPDDR4x 256 bits 136,5 Go/s 8 Go LPDDR4x 128 bits 59,7 Go/s 4 Go 64 bits LPDDR4 25,6 Go/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 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.

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

Remarque

Pour les méthodes 3 et 4 ci-dessus, après avoir flashé le système et démarré l'appareil, veuillez entrer « sudo apt update && sudo apt install nvidia-jetpack -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
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

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 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.

  1. 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 pip

  2. Installer ultralytics Paquet pip avec des dépendances optionnelles

    pip install ultralytics[export]

  3. Redémarrez l'appareil

    sudo reboot

Installer PyTorch et Torchvision

L'installation d'Ultralytics ci-dessus installera Torch et Torchvision. Cependant, ces 2 packages 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 la roue pip PyTorch pré-construite et compiler/installer Torchvision à partir de la source.

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.

  1. 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 pip

  2. Installer ultralytics Paquet pip avec des dépendances optionnelles

    pip install ultralytics[export]

  3. Redémarrez l'appareil

    sudo reboot

Installer PyTorch et Torchvision

L'installation d'Ultralytics ci-dessus installera Torch et Torchvision. Cependant, ces 2 packages 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 la roue pip PyTorch pré-construite et compiler/installer Torchvision à partir de la source.

  1. Désinstaller PyTorch et Torchvision actuellement installés

    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

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 Orin YOLO11

Les benchmarks YOLO11 ont été exécutés par l'équipe Ultralytics sur 10 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. Les benchmarks ont été exécutés sur NVIDIA Jetson AGX Orin Developer Kit (64 Go), NVIDIA Jetson Orin Nano Super Developer Kit et Seeed Studio reComputer J4012 alimenté par un appareil Jetson Orin NX 16 Go à une 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 Orin (64 Go)

Bancs d’essai Jetson AGX Orin
Étalonné avec Ultralytics 8.3.157

Kit de super développement NVIDIA Jetson Orin Nano

Benchmarks Jetson Orin Nano Super
Étalonné avec Ultralytics 8.3.157

NVIDIA Jetson Orin NX 16GB

Benchmarks Jetson Orin NX 16 Go
Étalonné avec Ultralytics 8.3.157

Tableaux comparatifs détaillés

Le tableau ci-dessous représente les résultats de référence pour cinq modèles différents (YOLO11n, YOLO11s, YOLO11m, YOLO11l, YOLO11x) dans dix formats différents (PyTorch, TorchScript, ONNX, OpenVINO, TensorRT, TF SavedModel, TF GraphDef, TF Lite, MNN, NCNN), 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 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.

  1. 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 0

  2. Activer 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_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 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

Jetson Stats

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 :

  1. Activez le mode de puissance MAX pour utiliser tous les cœurs CPU et GPU.
  2. Activez les horloges Jetson pour exécuter tous les cœurs à leur fréquence maximale.
  3. 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.



📅 Créé il y a 1 an ✏️ Mis à jour il y a 2 mois
glenn-jocher lakshanthad RizwanMunawar Burhan-Q picsalex Y-T-G Laughing-q justincdavis MatthewNoyce UltralyticsAssistant Ahelsamahy

Commentaires