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 :

# Install the required package for YOLOv8
pip install ultralytics

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.

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")

# Export a YOLOv8n PyTorch model to TensorRT format
yolo export model=yolov8n.pt format=engine  # creates 'yolov8n.engine''

# Run inference with the exported model
yolo predict model=yolov8n.engine source='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.

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'un workspace 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 petite workspace 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=Nonequi 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 de workspace est supérieure à la mémoire disponible dans l'appareil, ce qui signifie que la valeur de workspace 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 fonction None pour l'auto-allocation ou en réduisant les valeurs de imgsz et batch 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.

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.

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")

# 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'

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.

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 les mAP50 et mAP50-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

GPU grand public

Dispositifs embarqués

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.

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"
)

import cv2

from ultralytics import YOLO

model = YOLO("yolov8n.engine")
img = cv2.imread("path/to/image.jpg")

for _ in range(100):
    result = model.predict(
        [img] * 8,  # batch=8 of the same image
        verbose=False,
        device="cuda",
    )

from ultralytics import YOLO

model = YOLO("yolov8n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet, or DOTAv1 for appropriate model task
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

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 :

1. Installez le paquet requis:

   pip install ultralytics
   

2. Exportez votre modèle YOLOv8 :

   from ultralytics import YOLO
   
   model = YOLO("yolov8n.pt")
   model.export(format="engine")  # creates 'yolov8n.engine'
   
   # Run inference
   model = YOLO("yolov8n.engine")
   results = model("https://ultralytics.com/images/bus.jpg")
   

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 :

1. Exporter avec INT8:

   from ultralytics import YOLO
   
   model = YOLO("yolov8n.pt")
   model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml")
   

2. Exécuter l'inférence:

   from ultralytics import YOLO
   
   model = YOLO("yolov8n.engine", task="detect")
   result = model.predict("https://ultralytics.com/images/bus.jpg")
   

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.

📅C réé il y a 10 mois ✏️ Mis à jour il y a 8 jours

Commentaires