Guide de démarrage rapide : NVIDIA Jetson avec Ultralytics YOLOv8
Ce guide complet fournit une marche à suivre détaillée pour déployer Ultralytics YOLOv8 sur les appareils NVIDIA Jetson. En outre, il présente des repères de performance pour démontrer les capacités de YOLOv8 sur ces petits et puissants appareils.
Note
Ce guide a été testé avec le Seeed Studio reComputer J4012 qui est basé sur la NVIDIA Jetson Orin NX 16GB exécutant la dernière version stable de JetPack, JP5.1.3. L'utilisation de ce guide pour des appareils Jetson plus anciens tels que le Jetson Nano (qui n'est compatible qu'avec JP4.6.4) n'est pas garantie. Cependant, ce guide devrait fonctionner sur tous les appareils Jetson Orin, Xavier NX, AGX Xavier fonctionnant avec JP5.1.3.
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 les ressources informatiques du cloud. 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 moindre par rapport aux appareils traditionnels de calcul par le GPU.
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 drastiquement améliorées par rapport aux générations précédentes. Le tableau ci-dessous a comparé quelques appareils Jetson dans l'écosystème.
Jetson AGX Orin 64GB | Jetson Orin NX 16GB | Jetson Orin Nano 8GB | Jetson AGX Xavier | Jetson Xavier NX | Jetson Nano | |
---|---|---|---|---|---|---|
Performance de l'IA | 275 TOPS | 100 TOPS | 40 TOPs | 32 TOPS | 21 TOPS | 472 GFLOPS |
GPU | GPU NVIDIA Ampere à 2048 cœurs avec 64 cœurs Tensor | GPU NVIDIA Ampere à 1024 cœurs avec 32 cœurs Tensor | GPU NVIDIA Ampere à 1024 cœurs avec 32 cœurs Tensor | GPU NVIDIA Volta à 512 cœurs avec 64 cœurs Tensor | GPU à 384 cœurs de l'architecture NVIDIA Volta™ avec 48 cœurs Tensor . | GPU à 128 cœurs de l'architecture NVIDIA Maxwell™ |
Fréquence maximale du GPU | 1,3 GHz | 918 MHz | 625 MHz | 1377 MHz | 1100 MHz | 921MHz |
UNITÉ CENTRALE | CPU 64 bits NVIDIA Arm® Cortex A78AE v8.2 à 12 cœurs 3 Mo L2 + 6 Mo L3 | CPU 64 bits NVIDIA Arm® Cortex A78AE v8.2 à 8 cœurs 2 Mo L2 + 4 Mo L3 | CPU Arm® Cortex®-A78AE v8.2 64 bits à 6 cœurs 1,5 Mo L2 + 4 Mo L3 | CPU NVIDIA Carmel Arm®v8.2 64 bits à 8 cœurs 8 Mo L2 + 4 Mo L3 | CPU 64 bits NVIDIA Carmel Arm®v8.2 à 6 cœurs 6 Mo L2 + 4 Mo L3 | Processeur quadricœur Arm® Cortex®-A57 MPCore |
Fréquence maximale du CPU | 2,2 GHz | 2.0 GHz | 1,5 GHz | 2,2 GHz | 1,9 GHz | 1,43 GHz |
MĂ©moire | 64 Go LPDDR5 256 bits 204,8 Go/s | 16GB 128-bit LPDDR5 102.4GB/s | 8GB 128-bit LPDDR5 68 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é, visite la section Spécifications techniques de la page officielle de NVIDIA Jetson.
Qu'est-ce que NVIDIA JetPack ?
Le SDK NVIDIA JetPack qui alimente les modules Jetson est la solution la plus complète et fournit un environnement de développement complet pour créer des applications 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 par le 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 le NVIDIA JetPack sur l'appareil. Il existe plusieurs façons de flasher les appareils NVIDIA Jetson.
- Si tu possèdes un kit de développement NVIDIA officiel tel que le kit de développement Jetson Orin Nano, tu peux visiter ce lien pour télécharger une image et préparer une carte SD avec JetPack pour démarrer l'appareil.
- Si tu possèdes un autre kit de développement NVIDIA, tu peux visiter ce lien pour flasher JetPack sur l'appareil à l'aide du SDK Manager.
- Si tu possèdes un appareil Seeed Studio reComputer J4012, tu peux visiter ce lien pour flasher JetPack sur le SSD inclus.
- Si tu possèdes un autre appareil tiers alimenté par le module NVIDIA Jetson, il est recommandé de suivre le flashage en ligne de commande en visitant ce lien.
Note
Pour les méthodes 3 et 4 ci-dessus, après avoir flashé le système et démarré l'appareil, entre "sudo apt update && sudo apt install nvidia-jetpack -y" sur le terminal de l'appareil pour installer tous les autres composants JetPack nécessaires.
Mise en place Ultralytics
Il y a deux façons de configurer le paquet Ultralytics sur NVIDIA Jetson pour construire ton prochain projet de vision par ordinateur. Tu peux utiliser l'une ou l'autre.
Commence avec Docker
La façon la plus rapide de commencer avec Ultralytics YOLOv8 sur NVIDIA Jetson est de fonctionner avec une image docker préconstruite pour Jetson.
Exécute la commande ci-dessous pour tirer le conteneur Docker et l'exécuter sur Jetson. Ceci est basé sur l'image docker l4t-pytorch qui contient PyTorch et Torchvision dans un environnement Python3.
t=ultralytics/ultralytics:latest-jetson && sudo docker pull $t && sudo docker run -it --ipc=host --runtime=nvidia $t
Une fois que c'est fait, passe Ă la section Utiliser TensorRT sur NVIDIA Jetson.
DĂ©marrer sans Docker
Installer le paquet Ultralytics
Ici, nous allons installer le paquet ultralyics 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 TensoRT 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.
-
Installer
ultralytics
paquet pip avec dépendances optionnelles -
Redémarre l'appareil
Installe 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.
-
Désinstalle les versions actuellement installées de PyTorch et Torchvision.
-
Installe PyTorch 2.1.0 conformément à JP5.1.3
sudo apt-get install -y libopenblas-base libopenmpi-dev wget https://developer.download.nvidia.com/compute/redist/jp/v512/pytorch/torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl -O torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl pip install torch-2.1.0a0+41361538.nv23.06-cp38-cp38-linux_aarch64.whl
-
Installe Torchvision v0.16.2 selon PyTorch v2.1.0
Visite la pagePyTorch pour Jetson pour accéder à toutes les différentes versions de PyTorch pour les différentes versions de JetPack. Pour une liste plus détaillée des compatibilités PyTorch et Torchvision, visite 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
pour le JetPack que nous utilisons dans ce guide.
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 rétablir la version la plus récente de numpy. Nous devons donc réinstaller numpy à 1.23.5
pour résoudre un problème en l'exécutant :
pip install numpy==1.23.5
Utilise 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 des appareils NVIDIA Jetson 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 YOLOv8n au format PyTorch est converti en TensorRT pour effectuer une inférence avec le modèle exporté.
Exemple
from ultralytics import YOLO
# Load a YOLOv8n PyTorch model
model = YOLO('yolov8n.pt')
# Export the model
model.export(format='engine') # creates 'yolov8n.engine'
# Load the exported TensorRT model
trt_model = YOLO('yolov8n.engine')
# Run inference
results = trt_model('https://ultralytics.com/images/bus.jpg')
Note
Visite la page Exportation pour accéder à des arguments supplémentaires lors de l'exportation de modèles vers différents formats de modèles.
NVIDIA Jetson Orin YOLOv8 Benchmarks
YOLOv8 Des tests ont été effectués par l'équipe de Ultralytics sur 10 modèles de formats différents pour mesurer 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 le Seeed Studio reComputer J4012 équipé d'un appareil Jetson Orin NX de 16 Go avec une précision FP32 et une taille d'image d'entrée par défaut de 640.
Tableau de comparaison
Bien que tous les modèles exportés fonctionnent avec la NVIDIA Jetson, nous n'avons inclus que PyTorch, TorchScript, TensorRT dans le tableau comparatif ci-dessous parce qu'ils utilisent le GPU de la Jetson et qu'ils sont garantis de produire les meilleurs résultats. Toutes les autres exportations n'utilisent que le processeur et les performances ne sont pas aussi bonnes que celles des trois exportations ci-dessus. Tu trouveras des repères pour toutes les exportations dans la section qui suit ce tableau.
Tableau comparatif détaillé
Le tableau ci-dessous représente les résultats du benchmark pour cinq modèles différents (YOLOv8n, YOLOv8s, YOLOv8m, YOLOv8l, YOLOv8x) 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.
Performance
Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d'inférence (ms/im) |
---|---|---|---|---|
PyTorch | âś… | 6.2 | 0.6381 | 14.3 |
TorchScript | âś… | 12.4 | 0.6117 | 13.3 |
ONNX | âś… | 12.2 | 0.6092 | 70.6 |
OpenVINO | âś… | 12.3 | 0.6092 | 104.2 |
TensorRT | âś… | 13.6 | 0.6117 | 8.9 |
TF SavedModel | âś… | 30.6 | 0.6092 | 141.74 |
TF GraphDef | âś… | 12.3 | 0.6092 | 199.93 |
TF Lite | âś… | 12.3 | 0.6092 | 349.18 |
PaddlePaddle | âś… | 24.4 | 0.6030 | 555 |
NCNN | âś… | 12.2 | 0.6092 | 32 |
Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d'inférence (ms/im) |
---|---|---|---|---|
PyTorch | âś… | 21.5 | 0.6967 | 18 |
TorchScript | âś… | 43.0 | 0.7136 | 23.81 |
ONNX | âś… | 42.8 | 0.7136 | 185.55 |
OpenVINO | âś… | 42.9 | 0.7136 | 243.97 |
TensorRT | âś… | 44.0 | 0.7136 | 14.82 |
TF SavedModel | âś… | 107 | 0.7136 | 260.03 |
TF GraphDef | âś… | 42.8 | 0.7136 | 423.4 |
TF Lite | âś… | 42.8 | 0.7136 | 1046.64 |
PaddlePaddle | âś… | 85.5 | 0.7140 | 1464 |
NCNN | âś… | 42.7 | 0.7200 | 63 |
Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d'inférence (ms/im) |
---|---|---|---|---|
PyTorch | âś… | 49.7 | 0.7370 | 36.4 |
TorchScript | âś… | 99.2 | 0.7285 | 53.58 |
ONNX | âś… | 99 | 0.7280 | 452.09 |
OpenVINO | âś… | 99.1 | 0.7280 | 544.36 |
TensorRT | âś… | 100.3 | 0.7285 | 33.21 |
TF SavedModel | âś… | 247.5 | 0.7280 | 543.65 |
TF GraphDef | âś… | 99 | 0.7280 | 906.63 |
TF Lite | âś… | 99 | 0.7280 | 2758.08 |
PaddlePaddle | âś… | 197.9 | 0.7280 | 3678 |
NCNN | âś… | 98.9 | 0.7260 | 135 |
Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d'inférence (ms/im) |
---|---|---|---|---|
PyTorch | âś… | 83.7 | 0.7768 | 61.3 |
TorchScript | âś… | 167.2 | 0.7554 | 87.9 |
ONNX | âś… | 166.8 | 0.7551 | 852.29 |
OpenVINO | âś… | 167 | 0.7551 | 1012.6 |
TensorRT | âś… | 168.4 | 0.7554 | 51.23 |
TF SavedModel | âś… | 417.2 | 0.7551 | 990.45 |
TF GraphDef | âś… | 166.9 | 0.7551 | 1649.86 |
TF Lite | âś… | 166.9 | 0.7551 | 5652.37 |
PaddlePaddle | âś… | 333.6 | 0.7551 | 7114.67 |
NCNN | âś… | 166.8 | 0.7685 | 231.9 |
Format | Statut | Taille sur le disque (MB) | mAP50-95(B) | Temps d'inférence (ms/im) |
---|---|---|---|---|
PyTorch | âś… | 130.5 | 0.7759 | 93 |
TorchScript | âś… | 260.7 | 0.7472 | 135.1 |
ONNX | âś… | 260.4 | 0.7479 | 1296.13 |
OpenVINO | âś… | 260.6 | 0.7479 | 1502.15 |
TensorRT | âś… | 261.8 | 0.7469 | 84.53 |
TF SavedModel | âś… | 651.1 | 0.7479 | 1451.76 |
TF GraphDef | âś… | 260.5 | 0.7479 | 4029.36 |
TF Lite | âś… | 260.4 | 0.7479 | 8772.86 |
PaddlePaddle | âś… | 520.8 | 0.7479 | 10619.53 |
NCNN | âś… | 260.4 | 0.7646 | 376.38 |
Consulte ce lien pour découvrir d'autres analyses comparatives réalisées par Seeed Studio sur différentes versions du matériel NVIDIA Jetson.
Reproduis nos résultats
Pour reproduire les repères ci-dessus Ultralytics sur tous les formats d' exportation, exécute ce code :
Exemple
Note que les résultats des analyses comparatives 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 des analyses comparatives. Pour obtenir les résultats les plus fiables, utilise un ensemble de données contenant un grand nombre d'images, c'est-à -dire data='coco8.yaml' (4 val images), or
data='coco.yaml'` (5000 val images).
Meilleures pratiques lors de l'utilisation de NVIDIA Jetson
Lorsque tu utilises la NVIDIA Jetson, il y a quelques bonnes pratiques Ă suivre afin d'obtenir des performances maximales sur la NVIDIA Jetson fonctionnant sur YOLOv8.
-
Activer le mode d'alimentation MAX
L'activation du mode d'alimentation MAX sur la Jetson permet de s'assurer que tous les cœurs du processeur et du GPU sont activés.
-
Activer les horloges Jetson
L'activation des horloges Jetson permettra de s'assurer que tous les cœurs du CPU et du GPU sont cadencés à leur fréquence maximale.
-
Installe 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'affichage de l'utilisation du CPU, du GPU, de la RAM, le changement des modes d'alimentation, le réglage des horloges maximales, la vérification des informations JetPack.
Prochaines Ă©tapes
Félicitations pour avoir réussi à installer YOLOv8 sur ta NVIDIA Jetson ! Pour en savoir plus et obtenir de l'aide, consulte le guide suivant : Ultralytics YOLOv8 Docs!
Créé le 2024-04-02, Mis à jour le 2024-05-08
Auteurs : Burhan-Q (2), lakshanthad (2), glenn-jocher (2)