TensorRT Exportation pour les modèles YOLOv8
Le déploiement de modèles de vision par ordinateur dans des environnements à haute performance peut nécessiter un format qui maximise la vitesse et l'efficacité. C'est particulièrement vrai lorsque vous déployez votre modèle sur les GPU NVIDIA .
En utilisant le format d'exportation TensorRT , vous pouvez améliorer vos modèles pour une inférence rapide et efficace sur le matériel . Ultralytics YOLOv8 pour une inférence rapide et efficace sur le matériel NVIDIA . Ce guide vous fournira des étapes faciles à suivre pour le processus de conversion et vous aidera à tirer le meilleur parti de la technologie avancée de NVIDIA dans vos projets d'apprentissage profond.
TensorRT
TensorRTdéveloppé par NVIDIA, est un kit de développement logiciel (SDK) avancé conçu pour l'inférence d'apprentissage profond à grande vitesse. Il est bien adapté aux applications en temps réel telles que la détection d'objets.
Cette boîte à outils optimise les modèles d'apprentissage profond pour les GPU NVIDIA et permet des opérations plus rapides et plus efficaces. Les modèles TensorRT subissent une optimisation TensorRT , qui comprend des techniques telles que la fusion des couches, le calibrage de la précision (INT8 et FP16), la gestion dynamique de la mémoire tensor et l'auto-réglage du noyau. La conversion des modèles d'apprentissage profond au format TensorRT permet aux développeurs d'exploiter pleinement le potentiel des GPU NVIDIA .
TensorRT est connu pour sa compatibilité avec divers formats de modèles, notamment TensorFlow, PyTorchet ONNX, offrant aux développeurs une solution flexible pour l'intégration et l'optimisation de modèles provenant de différents cadres. Cette polyvalence permet un déploiement efficace des modèles dans divers environnements matériels et logiciels.
Principales caractéristiques des modèles TensorRT
TensorRT offrent une série de caractéristiques clés qui contribuent à leur efficacité et à leur efficience dans l'inférence d'apprentissage profond à grande vitesse :
-
Étalonnage de précision: TensorRT prend en charge l'étalonnage de précision, ce qui permet d'affiner les modèles en fonction des exigences de précision spécifiques. Cela inclut la prise en charge des formats de précision réduite tels que INT8 et FP16, qui permettent d'augmenter la vitesse d'inférence tout en maintenant des niveaux de précision acceptables.
-
Fusion de couches: Le processus d'optimisation TensorRT comprend la fusion de couches, où plusieurs couches d'un réseau neuronal sont combinées en une seule opération. Cela permet de réduire la charge de calcul et d'améliorer la vitesse d'inférence en minimisant l'accès à la mémoire et les calculs.
-
Gestion dynamique de la mémoire Tensor : TensorRT gère efficacement l'utilisation de la mémoire tensor pendant l'inférence, en réduisant la surcharge de mémoire et en optimisant l'allocation de mémoire. Il en résulte une utilisation plus efficace de la mémoire de GPU .
-
Ajustement automatique du noyau: TensorRT applique un ajustement automatique du noyau afin de sélectionner le noyau GPU le plus optimisé pour chaque couche du modèle. Cette approche adaptative garantit que le modèle tire pleinement parti de la puissance de calcul de GPU.
Options de déploiement dans TensorRT
Avant d'examiner le code permettant d'exporter les modèles YOLOv8 vers le format TensorRT , il convient de comprendre où les modèles TensorRT sont normalement utilisés.
TensorRT offre plusieurs options de déploiement, chaque option équilibrant différemment la facilité d'intégration, l'optimisation des performances et la flexibilité :
- Déploiement dans TensorFlow: Cette méthode intègre TensorRT dans TensorFlow, ce qui permet aux modèles optimisés de fonctionner dans un environnement TensorFlow familier. Elle est utile pour les modèles comportant un mélange de couches prises en charge et non prises en charge, car TF-TRT peut les gérer efficacement.
-
Site autonome TensorRT Runtime API: Offre un contrôle granulaire, idéal pour les applications dont les performances sont critiques. Elle est plus complexe mais permet la mise en œuvre personnalisée d'opérateurs non pris en charge.
-
NVIDIA Triton Serveur d'inférence: Une option qui prend en charge les modèles de divers cadres. Particulièrement adaptée à l'inférence en nuage ou en périphérie, elle offre des fonctionnalités telles que l'exécution de modèles simultanés et l'analyse de modèles.
Exportation des modèles YOLOv8 vers TensorRT
Vous pouvez améliorer l'efficacité de l'exécution et optimiser les performances en convertissant les modèles YOLOv8 au format TensorRT .
Installation
Pour installer le paquetage requis, exécutez :
Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consultez notre guide d'installationYOLOv8 . Lors de l'installation des paquets requis pour YOLOv8, si vous rencontrez des difficultés, consultez notre guide des problèmes courants pour obtenir des solutions et des conseils.
Utilisation
Avant de vous plonger dans les instructions d'utilisation, n'oubliez pas de consulter la gamme de modèlesYOLOv8 proposée par Ultralytics. Cela vous aidera à choisir le modèle le plus approprié aux exigences de votre projet.
Utilisation
from ultralytics import YOLO
# Load the YOLOv8 model
model = YOLO("yolov8n.pt")
# Export the model to TensorRT format
model.export(format="engine") # creates 'yolov8n.engine'
# Load the exported TensorRT model
tensorrt_model = YOLO("yolov8n.engine")
# Run inference
results = tensorrt_model("https://ultralytics.com/images/bus.jpg")
Pour plus de détails sur le processus d'exportation, consultez la page de documentationUltralytics sur l'exportation.
Exportation de TensorRT avec quantification INT8
L'exportation des modèles Ultralytics YOLO à l'aide de TensorRT avec une précision INT8 exécute la quantification post-entraînement (PTQ). TensorRT utilise le calibrage pour PTQ, qui mesure la distribution des activations au sein de chaque activation tensor lorsque le modèle YOLO traite l'inférence sur des données d'entrée représentatives, et utilise ensuite cette distribution pour estimer les valeurs d'échelle pour chaque tensor. Chaque activation tensor candidate à la quantification a une échelle associée qui est déduite par un processus d'étalonnage.
Lors du traitement de réseaux implicitement quantifiés, TensorRT utilise INT8 de manière opportuniste pour optimiser le temps d'exécution des couches. Si une couche s'exécute plus rapidement en INT8 et que des échelles de quantification ont été attribuées à ses entrées et sorties de données, un noyau avec une précision INT8 est attribué à cette couche. Dans le cas contraire, TensorRT sélectionne une précision FP32 ou FP16 pour le noyau en fonction de celle qui permet d'obtenir un temps d'exécution plus rapide pour cette couche.
Conseil
Il est essentiel de s'assurer que l'appareil qui utilisera les poids du modèle TensorRT pour le déploiement est le même que celui utilisé pour l'exportation avec la précision INT8, car les résultats de l'étalonnage peuvent varier d'un appareil à l'autre.
Configuration de l'exportation INT8
Les arguments fournis lors de l'utilisation de l'exportation pour un modèle Ultralytics YOLO grandement influencent les performances du modèle exporté. Ils devront également être sélectionnés en fonction des ressources de l'appareil disponibles, mais les arguments par défaut sont les suivants devrait fonctionnent pour la plupart Ampere (ou plus récent) NVIDIA GPU discrets. L'algorithme d'étalonnage utilisé est le suivant "ENTROPY_CALIBRATION_2"
et vous pouvez lire plus de détails sur les options disponibles dans le guide du développeur TensorRT. Ultralytics Les tests ont montré que "ENTROPY_CALIBRATION_2"
était le meilleur choix et les exportations sont fixées sur cet algorithme.
-
workspace
: Contrôle la taille (en GiB) de l'allocation de la mémoire du dispositif lors de la conversion des poids du modèle.-
Ajuster le
workspace
en fonction de vos besoins d'étalonnage et de la disponibilité des ressources. Bien qu'unworkspace
peut augmenter le temps d'étalonnage, il permet à TensorRT d'explorer un plus large éventail de tactiques d'optimisation, ce qui peut améliorer la performance du modèle et la qualité des données. précision. Inversement, une plus petiteworkspace
peut réduire le temps d'étalonnage mais peut limiter les stratégies d'optimisation, ce qui affecte la qualité du modèle quantifié. -
La valeur par défaut est
workspace=None
qui permettra à TensorRT d'allouer automatiquement de la mémoire. Lors d'une configuration manuelle, cette valeur peut devoir être augmentée si la calibration se bloque (sort sans avertissement). -
TensorRT rapportera
UNSUPPORTED_STATE
lors de l'exportation si la valeur deworkspace
est supérieure à la mémoire disponible dans l'appareil, ce qui signifie que la valeur deworkspace
doit être abaissée ou fixée àNone
. -
Si
workspace
est réglé sur la valeur maximale et que l'étalonnage échoue ou se bloque, il faut envisager d'utiliser la fonctionNone
pour l'auto-allocation ou en réduisant les valeurs deimgsz
etbatch
pour réduire les besoins en mémoire. -
N'oubliez pas que l'étalonnage de l'INT8 est spécifique à chaque appareil, emprunter un GPU "haut de gamme" pour l'étalonnage peut entraîner des performances médiocres lorsque l'inférence est exécutée sur un autre appareil.
-
-
batch
: La taille maximale du lot qui sera utilisée pour l'inférence. Pendant l'inférence, des lots plus petits peuvent être utilisés, mais l'inférence n'acceptera pas de lots plus grands que ceux spécifiés.
Note
Pendant l'étalonnage, deux fois le batch
La taille fournie sera utilisée. L'utilisation de petits lots peut entraîner une mise à l'échelle imprécise lors de l'étalonnage. En effet, le processus s'ajuste en fonction des données qu'il voit. Les petits lots peuvent ne pas capturer toute la gamme des valeurs, ce qui entraîne des problèmes lors de l'étalonnage final. batch
est automatiquement doublée. Si aucun taille du lot est spécifié batch=1
L'étalonnage sera effectué à batch=1 * 2
pour réduire les erreurs d'échelle d'étalonnage.
L'expérience menée par NVIDIA a conduit à recommander l'utilisation d'au moins 500 images d'étalonnage représentatives des données de votre modèle, avec un étalonnage de quantification INT8. Il s'agit d'une ligne directrice et non d'une dur et vous devrez expérimenter ce qui est nécessaire pour obtenir de bons résultats avec votre ensemble de données. Comme les données d'étalonnage sont nécessaires pour l'étalonnage de l'INT8 avec TensorRT, assurez-vous d'utiliser l'option data
argument lorsque int8=True
pour TensorRT et utiliser data="my_dataset.yaml"
qui utilisera les images de validation pour l'étalonnage. Si aucune valeur n'est transmise pour data
avec exportation vers TensorRT avec une quantification INT8, la valeur par défaut sera d'utiliser l'une des options suivantes de "petits" ensembles de données d'exemple basés sur la tâche du modèle au lieu de provoquer une erreur.
Exemple
from ultralytics import YOLO
model = YOLO("yolov8n.pt")
model.export(
format="engine",
dynamic=True, # (1)!
batch=8, # (2)!
workspace=4, # (3)!
int8=True,
data="coco.yaml", # (4)!
)
# Load the exported TensorRT INT8 model
model = YOLO("yolov8n.engine", task="detect")
# Run inference
result = model.predict("https://ultralytics.com/images/bus.jpg")
- Exporte avec des axes dynamiques, ceci sera activé par défaut lors de l'exportation avec
int8=True
même si elle n'est pas explicitement définie. Voir aussi arguments d'exportation pour plus d'informations. - Définit une taille de lot maximale de 8 pour le modèle exporté, qui se calibre avec
batch = 2 * 8
pour éviter les erreurs d'échelle lors de l'étalonnage. - Alloue 4 GiB de mémoire au lieu d'allouer l'ensemble du périphérique pour le processus de conversion.
- Utilise le jeu de données COCO pour l'étalonnage, en particulier les images utilisées pour la validation (5 000 au total).
# Export a YOLOv8n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolov8n.pt format=engine batch=8 workspace=4 int8=True data=coco.yaml # creates 'yolov8n.engine''
# Run inference with the exported TensorRT quantized model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'
Cache d'étalonnage
TensorRT génère un étalonnage .cache
qui peut être réutilisé pour accélérer l'exportation des poids des modèles futurs en utilisant les mêmes données, mais cela peut entraîner un mauvais calibrage lorsque les données sont très différentes ou si le batch
est modifiée de manière radicale. Dans ces circonstances, les .cache
doit être renommé et déplacé dans un autre répertoire ou supprimé.
Avantages de l'utilisation de YOLO avec TensorRT INT8
-
Taille réduite du modèle : La quantification de FP32 à INT8 peut réduire la taille du modèle par quatre (sur disque ou en mémoire), ce qui accélère les temps de téléchargement, réduit les besoins de stockage et l'empreinte mémoire lors du déploiement d'un modèle.
-
Consommation d'énergie réduite : Les opérations de précision réduite pour les modèles YOLO exportés en INT8 peuvent consommer moins d'énergie que les modèles FP32, en particulier pour les appareils alimentés par batterie.
-
Amélioration de la vitesse d'inférence : TensorRT optimise le modèle pour le matériel cible, ce qui permet d'accélérer la vitesse d'inférence sur les GPU, les appareils embarqués et les accélérateurs.
Note sur les vitesses d'inférence
Les premiers appels d'inférence avec un modèle exporté vers TensorRT INT8 peuvent avoir des temps de prétraitement, d'inférence et/ou de post-traitement plus longs que d'habitude. Cela peut également se produire lorsque l'on modifie imgsz
pendant l'inférence, en particulier lorsque imgsz
n'est pas le même que celui spécifié lors de l'exportation (export imgsz
est défini comme TensorRT profil "optimal").
Inconvénients de l'utilisation de YOLO avec TensorRT INT8
-
Diminution des paramètres d'évaluation : L'utilisation d'une précision inférieure signifie que
mAP
,Precision
,Recall
ou tout autre autre mesure utilisée pour évaluer la performance du modèle est susceptible d'être un peu plus grave. Voir le Section des résultats de performance pour comparer les différences entre lesmAP50
etmAP50-95
lors de l'exportation avec INT8 sur un petit échantillon de divers appareils. -
Augmentation des temps de développement : La recherche des paramètres "optimaux" pour l'étalonnage de l'INT8 en fonction de l'ensemble de données et de l'appareil peut nécessiter un nombre important de tests.
-
Dépendance matérielle : L'étalonnage et les gains de performance peuvent dépendre fortement du matériel et les poids des modèles sont moins transférables.
Ultralytics YOLO TensorRT Performances à l'exportation
NVIDIA A100
Performance
Testé avec Ubuntu 22.04.3 LTS, python 3.10.12
, ultralytics==8.2.4
, tensorrt==8.6.1.post1
Voir Detection Docs pour des exemples d'utilisation de ces modèles formés sur COCO, qui comprennent 80 classes préformées.
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
taille (pixels) |
---|---|---|---|---|---|---|---|
FP32 | Prévoir | 0.52 | 0.51 | 0.56 | 8 | 640 | ||
FP32 | COCOval | 0.52 | 0.52 | 0.37 | 1 | 640 | |
16ÈME PCRD | Prévoir | 0.34 | 0.34 | 0.41 | 8 | 640 | ||
16ÈME PCRD | COCOval | 0.33 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prévoir | 0.28 | 0.27 | 0.31 | 8 | 640 | ||
INT8 | COCOval | 0.29 | 0.47 | 0.33 | 1 | 640 |
Voir Segmentation Docs pour des exemples d'utilisation de ces modèles entraînés sur COCO, qui comprennent 80 classes pré-entraînées.
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n-seg.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
mAPval 50(M) |
mAPval 50-95(M) |
batch |
taille (pixels) |
---|---|---|---|---|---|---|---|---|---|
FP32 | Prévoir | 0.62 | 0.61 | 0.68 | 8 | 640 | ||||
FP32 | COCOval | 0.63 | 0.52 | 0.36 | 0.49 | 0.31 | 1 | 640 | |
16ÈME PCRD | Prévoir | 0.40 | 0.39 | 0.44 | 8 | 640 | ||||
16ÈME PCRD | COCOval | 0.43 | 0.52 | 0.36 | 0.49 | 0.30 | 1 | 640 | |
INT8 | Prévoir | 0.34 | 0.33 | 0.37 | 8 | 640 | ||||
INT8 | COCOval | 0.36 | 0.46 | 0.32 | 0.43 | 0.27 | 1 | 640 |
Voir les documents sur la classification pour des exemples d'utilisation de ces modèles formés sur ImageNet, qui comprennent 1000 classes préformées.
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n-cls.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
top-1 | top-5 | batch |
taille (pixels) |
---|---|---|---|---|---|---|---|
FP32 | Prévoir | 0.26 | 0.25 | 0.28 | 8 | 640 | ||
FP32 | ImageNetval | 0.26 | 0.35 | 0.61 | 1 | 640 | |
16ÈME PCRD | Prévoir | 0.18 | 0.17 | 0.19 | 8 | 640 | ||
16ÈME PCRD | ImageNetval | 0.18 | 0.35 | 0.61 | 1 | 640 | |
INT8 | Prévoir | 0.16 | 0.15 | 0.57 | 8 | 640 | ||
INT8 | ImageNetval | 0.15 | 0.32 | 0.59 | 1 | 640 |
Voir Pose Estimation Docs pour des exemples d'utilisation de ces modèles entraînés sur COCO, qui incluent une classe pré-entraînée, "personne".
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n-pose.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
mAPval 50(P) |
mAPval 50-95(P) |
batch |
taille (pixels) |
---|---|---|---|---|---|---|---|---|---|
FP32 | Prévoir | 0.54 | 0.53 | 0.58 | 8 | 640 | ||||
FP32 | COCOval | 0.55 | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | |
16ÈME PCRD | Prévoir | 0.37 | 0.35 | 0.41 | 8 | 640 | ||||
16ÈME PCRD | COCOval | 0.36 | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | |
INT8 | Prévoir | 0.29 | 0.28 | 0.33 | 8 | 640 | ||||
INT8 | COCOval | 0.30 | 0.90 | 0.68 | 0.78 | 0.47 | 1 | 640 |
Voir Oriented Detection Docs pour des exemples d'utilisation de ces modèles entraînés sur DOTAv1, qui comprend 15 classes pré-entraînées.
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n-obb.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
taille (pixels) |
---|---|---|---|---|---|---|---|
FP32 | Prévoir | 0.52 | 0.51 | 0.59 | 8 | 640 | ||
FP32 | DOTAv1val | 0.76 | 0.50 | 0.36 | 1 | 640 | |
16ÈME PCRD | Prévoir | 0.34 | 0.33 | 0.42 | 8 | 640 | ||
16ÈME PCRD | DOTAv1val | 0.59 | 0.50 | 0.36 | 1 | 640 | |
INT8 | Prévoir | 0.29 | 0.28 | 0.33 | 8 | 640 | ||
INT8 | DOTAv1val | 0.32 | 0.45 | 0.32 | 1 | 640 |
GPU grand public
Performance de détection (COCO)
Testé avec Windows 10.0.19045, python 3.10.9
, ultralytics==8.2.4
, tensorrt==10.0.0b6
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
taille (pixels) |
---|---|---|---|---|---|---|---|
FP32 | Prévoir | 1.06 | 0.75 | 1.88 | 8 | 640 | ||
FP32 | COCOval | 1.37 | 0.52 | 0.37 | 1 | 640 | |
16ÈME PCRD | Prévoir | 0.62 | 0.75 | 1.13 | 8 | 640 | ||
16ÈME PCRD | COCOval | 0.85 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prévoir | 0.52 | 0.38 | 1.00 | 8 | 640 | ||
INT8 | COCOval | 0.74 | 0.47 | 0.33 | 1 | 640 |
Testé avec Windows 10.0.22631, python 3.11.9
, ultralytics==8.2.4
, tensorrt==10.0.1
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
taille (pixels) |
---|---|---|---|---|---|---|---|
FP32 | Prévoir | 1.76 | 1.69 | 1.87 | 8 | 640 | ||
FP32 | COCOval | 1.94 | 0.52 | 0.37 | 1 | 640 | |
16ÈME PCRD | Prévoir | 0.86 | 0.75 | 1.00 | 8 | 640 | ||
16ÈME PCRD | COCOval | 1.43 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prévoir | 0.80 | 0.75 | 1.00 | 8 | 640 | ||
INT8 | COCOval | 1.35 | 0.47 | 0.33 | 1 | 640 |
Testé avec Pop!_OS 22.04 LTS, python 3.10.12
, ultralytics==8.2.4
, tensorrt==8.6.1.post1
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
taille (pixels) |
---|---|---|---|---|---|---|---|
FP32 | Prévoir | 2.84 | 2.84 | 2.85 | 8 | 640 | ||
FP32 | COCOval | 2.94 | 0.52 | 0.37 | 1 | 640 | |
16ÈME PCRD | Prévoir | 1.09 | 1.09 | 1.10 | 8 | 640 | ||
16ÈME PCRD | COCOval | 1.20 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prévoir | 0.75 | 0.74 | 0.75 | 8 | 640 | ||
INT8 | COCOval | 0.76 | 0.47 | 0.33 | 1 | 640 |
Dispositifs embarqués
Performance de détection (COCO)
Testé avec JetPack 6.0 (L4T 36.3) Ubuntu 22.04.4 LTS, python 3.10.12
, ultralytics==8.2.16
, tensorrt==10.0.1
Note
Temps d'inférence indiqués pour mean
, min
(le plus rapide), et max
(le plus lent) pour chaque test en utilisant les poids pré-entraînés yolov8n.engine
Précision | Test d'évaluation | moyenne (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
taille (pixels) |
---|---|---|---|---|---|---|---|
FP32 | Prévoir | 6.11 | 6.10 | 6.29 | 8 | 640 | ||
FP32 | COCOval | 6.17 | 0.52 | 0.37 | 1 | 640 | |
16ÈME PCRD | Prévoir | 3.18 | 3.18 | 3.20 | 8 | 640 | ||
16ÈME PCRD | COCOval | 3.19 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prévoir | 2.30 | 2.29 | 2.35 | 8 | 640 | ||
INT8 | COCOval | 2.32 | 0.46 | 0.32 | 1 | 640 |
Info
Consultez notre guide de démarrage rapide sur NVIDIA Jetson avec Ultralytics YOLO pour en savoir plus sur l'installation et la configuration.
Méthodes d'évaluation
Développez les sections ci-dessous pour obtenir des informations sur la manière dont ces modèles ont été exportés et testés.
Exporter des configurations
Voir le mode d'exportation pour plus de détails sur les arguments de configuration de l'exportation.
from ultralytics import YOLO
model = YOLO("yolov8n.pt")
# TensorRT FP32
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2)
# TensorRT FP16
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, half=True)
# TensorRT INT8 with calibration `data` (i.e. COCO, ImageNet, or DOTAv1 for appropriate model task)
out = model.export(
format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, int8=True, data="coco8.yaml"
)
Prévoir la boucle
Voir le mode prédictif pour plus d'informations.
Configuration de la validation
Voir val
mode pour en savoir plus sur les arguments de configuration de la validation.
Déploiement des modèles exportés YOLOv8 TensorRT
Après avoir exporté avec succès vos modèles Ultralytics YOLOv8 au format TensorRT , vous êtes maintenant prêt à les déployer. Pour obtenir des instructions détaillées sur le déploiement de vos modèles TensorRT dans différents contextes, consultez les ressources suivantes :
-
Déployer Ultralytics avec un serveur Triton : Notre guide sur l'utilisation du serveur Triton Inference (anciennement TensorRT Inference) de NVIDIA spécifiquement pour les modèles Ultralytics YOLO .
-
Déployer des réseaux neuronaux profonds avec NVIDIA TensorRT: Cet article explique comment utiliser NVIDIA TensorRT pour déployer efficacement des réseaux neuronaux profonds sur des plateformes de déploiement basées sur GPU.
-
IA de bout en bout pour les PC basés sur NVIDIA: NVIDIA TensorRT Déploiement: Cet article de blog explique l'utilisation de NVIDIA TensorRT pour optimiser et déployer des modèles d'IA sur des PC basés sur NVIDIA.
-
Dépôt GitHub pour NVIDIA TensorRT :: Ceci est le dépôt officiel GitHub qui contient le code source et la documentation pour NVIDIA TensorRT .
Résumé
Dans ce guide, nous nous sommes concentrés sur la conversion des modèles Ultralytics YOLOv8 au format NVIDIA's TensorRT model. Cette étape de conversion est cruciale pour améliorer l'efficacité et la rapidité des modèles YOLOv8 , ce qui les rend plus efficaces et adaptés à divers environnements de déploiement.
Pour plus d'informations sur les détails d'utilisation, consultez la documentation officielle deTensorRT .
Si vous souhaitez en savoir plus sur les autres intégrations de Ultralytics YOLOv8 , notre guide d'intégration propose une vaste sélection de ressources et d'informations.
FAQ
Comment convertir les modèles YOLOv8 au format TensorRT ?
Pour convertir vos modèles Ultralytics YOLOv8 au format TensorRT afin d'optimiser l'inférence NVIDIA GPU , suivez les étapes suivantes :
-
Installez le paquet requis:
-
Exportez votre modèle YOLOv8 :
Pour plus de détails, consultez le guide d'installationYOLOv8 et la documentation sur l'exportation.
Quels sont les avantages de l'utilisation de TensorRT pour les modèles YOLOv8 ?
L'utilisation de TensorRT pour optimiser les modèles YOLOv8 présente plusieurs avantages :
- Vitesse d'inférence plus rapide: TensorRT optimise les couches du modèle et utilise un calibrage de précision (INT8 et FP16) pour accélérer l'inférence sans sacrifier de manière significative la précision.
- Efficacité de la mémoire: TensorRT gère la mémoire de tensor de manière dynamique, ce qui réduit les frais généraux et améliore l'utilisation de la mémoire de GPU .
- Fusion de couches: Combine plusieurs couches en une seule opération, ce qui réduit la complexité des calculs.
- Ajustement automatique des noyaux: Sélectionne automatiquement des noyaux GPU optimisés pour chaque couche du modèle, garantissant ainsi des performances maximales.
Pour plus d'informations, découvrez les caractéristiques détaillées de TensorRT ici et lisez notre section de présentation deTensorRT .
Puis-je utiliser la quantification INT8 avec TensorRT pour les modèles YOLOv8 ?
Oui, vous pouvez exporter des modèles YOLOv8 en utilisant TensorRT avec une quantification INT8. Ce processus implique une quantification post-entraînement (PTQ) et une calibration :
-
Exporter avec INT8:
-
Exécuter l'inférence:
Pour plus de détails, reportez-vous à la section exportant TensorRT avec une quantification INT8.
Comment déployer les modèles YOLOv8 TensorRT sur un serveur d'inférence NVIDIA Triton ?
Le déploiement des modèles YOLOv8 TensorRT sur un serveur d'inférence NVIDIA Triton peut se faire à l'aide des ressources suivantes :
- Déployer Ultralytics YOLOv8 avec Triton Server: Guide étape par étape sur l'installation et l'utilisation de Triton Inference Server.
- NVIDIA Triton Documentation du serveur d'inférence: Documentation officielle NVIDIA pour les options de déploiement et les configurations détaillées.
Ces guides vous aideront à intégrer efficacement les modèles YOLOv8 dans divers environnements de déploiement.
Quelles sont les améliorations de performance observées avec les modèles YOLOv8 exportés vers TensorRT?
L'amélioration des performances avec TensorRT peut varier en fonction du matériel utilisé. Voici quelques points de repère typiques :
-
NVIDIA A100:
- FP32 Inférence : ~0,52 ms / image
- FP16 Inférence : ~0,34 ms / image
- Inférence INT8: ~0,28 ms / image
- Légère réduction du mAP avec la précision INT8, mais amélioration significative de la vitesse.
-
GPU grand public (par exemple, RTX 3080):
- FP32 Inférence : ~1,06 ms / image
- FP16 Inférence : ~0,62 ms / image
- Inférence INT8: ~0,52 ms / image
Des critères de performance détaillés pour différentes configurations matérielles sont présentés dans la section relative aux performances.
Pour obtenir des informations plus complètes sur les performances de TensorRT , consultez la documentation deUltralytics et nos rapports d'analyse des performances.