TensorRT Exportation pour les modèles YOLOv8

Deploying computer vision models in high-performance environments can require a format that maximizes speed and efficiency. This is especially true when you are deploying your model on NVIDIA GPUs.

By using the TensorRT export format, you can enhance your Ultralytics YOLOv8 models for swift and efficient inference on NVIDIA hardware. This guide will give you easy-to-follow steps for the conversion process and help you make the most of NVIDIA's advanced technology in your deep learning projects.

TensorRT

TensorRT, developed by NVIDIA, is an advanced software development kit (SDK) designed for high-speed deep learning inference. It's well-suited for real-time applications like object detection.

Cette boîte à outils optimise les modèles d'apprentissage profond pour les GPU NVIDIA et permet d'obtenir 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, l'étalonnage 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 is known for its compatibility with various model formats, including TensorFlow, PyTorch, and ONNX, providing developers with a flexible solution for integrating and optimizing models from different frameworks. This versatility enables efficient model deployment across diverse hardware and software environments.

Caractéristiques principales des modèles TensorRT

TensorRT Les modèles offrent une gamme 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 d'exigences spécifiques en matière de précision. 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.

• Layer Fusion: The TensorRT optimization process includes layer fusion, where multiple layers of a neural network are combined into a single operation. This reduces computational overhead and improves inference speed by minimizing memory access and computation.

• 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 la mémoire et en optimisant l'allocation de la mémoire. Il en résulte une utilisation plus efficace de la mémoire de GPU .

• Réglage automatique du noyau: TensorRT applique le réglage automatique du noyau pour 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 de regarder le code pour l’exportation YOLOv8 modèles à la TensorRT format, comprenons où TensorRT sont normalement utilisés.

TensorRT offre plusieurs options de déploiement, et chaque option équilibre différemment la facilité d'intégration, l'optimisation des performances et la flexibilité :

• Deploying within TensorFlow: This method integrates TensorRT into TensorFlow, allowing optimized models to run in a familiar TensorFlow environment. It's useful for models with a mix of supported and unsupported layers, as TF-TRT can handle these efficiently.

• API d'exécution autonome TensorRT : 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 frameworks. Particulièrement adaptée à l'inférence dans le cloud 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.

Exporter les modèles YOLOv8 vers TensorRT

Tu peux 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écute :

# 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, consulte notre guide d'installationYOLOv8 . Pendant l'installation des paquets requis pour YOLOv8, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour trouver des solutions et des conseils.

Utilisation

Avant de te plonger dans les instructions d'utilisation, n'oublie pas de consulter la gamme de modèlesYOLOv8 proposée par Ultralytics. Cela t'aidera à choisir le modèle le plus approprié aux exigences de ton 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, visite la page de documentationUltralytics sur l'exportation.

Exporter TensorRT avec la quantification INT8

Exporting Ultralytics YOLO models using TensorRT with INT8 precision executes post-training quantization (PTQ). TensorRT uses calibration for PTQ, which measures the distribution of activations within each activation tensor as the YOLO model processes inference on representative input data, and then uses that distribution to estimate scale values for each tensor. Each activation tensor that is a candidate for quantization has an associated scale that is deduced by a calibration process.

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. Sinon, 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 exporter 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, cependant les arguments par défaut. doit fonctionne pour la plupart Ampere (ou plus récent) NVIDIA GPU discrets. L'algorithme de calibrage utilisé est "ENTROPY_CALIBRATION_2" et tu peux lire plus de détails sur les options disponibles dans le guide du développeur TensorRT. Ultralytics Les tests ont révélé que "ENTROPY_CALIBRATION_2" était le meilleur choix et les exportations sont fixées à l'utilisation de cet algorithme.

• workspace : Contrôle la taille (en GiB) de l'allocation de la mémoire du périphérique lors de la conversion des poids du modèle.

  • Ajuste le workspace en fonction de tes besoins d'étalonnage et de la disponibilité des ressources. Bien qu'un workspace may increase calibration time, it allows TensorRT to explore a wider range of optimization tactics, potentially enhancing model performance and accuracy. Conversely, a smaller 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=4 (GiB), il se peut que cette valeur doive être augmentée si l'étalonnage se bloque (se termine sans avertissement).

  • TensorRT rapportera UNSUPPORTED_STATE lors de l'exportation si la valeur de workspace est plus grande que la mémoire dont dispose l'appareil, ce qui signifie que la valeur de workspace doit être abaissée.

  • Si workspace est réglée sur la valeur maximale et que l'étalonnage échoue, envisage de réduire les valeurs de imgsz et batch pour réduire les besoins en mémoire.

  • N'oublie pas que l'étalonnage pour 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 ce qui est spécifié.

L'expérimentation menée par NVIDIA les a conduits à recommander l'utilisation d'au moins 500 images de calibration représentatives des données de ton modèle, avec une calibration de quantification INT8. Il s'agit d'une ligne directrice et non d'une dur exigence, et tu devras expérimenter ce qui est nécessaire pour obtenir de bons résultats avec ton ensemble de données. Comme les données d'étalonnage sont nécessaires pour l'étalonnage de l'INT8 avec TensorRT, assure-toi d'utiliser l'option data argument lorsque int8=True pour TensorRT et utilise data="my_dataset.yaml"qui utilisera les images de validation pour l'étalonnage. Si aucune valeur n'est transmise pour data avec l'exportation vers TensorRT avec une quantification INT8, la valeur par défaut sera d'utiliser l'une des options suivantes "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 4 (sur disque ou en mémoire), ce qui permet d'accélérer les temps de téléchargement, de réduire les besoins en stockage et de réduire 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 par INT8 peuvent consommer moins d'énergie que les modèles FP32, en particulier pour les appareils alimentés par batterie.

• Vitesse d'inférence améliorée : 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 probablement un peu pire. Voir les 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 : Trouver les 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 performances 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

Appareils embarqués

Méthodes d'évaluation

Développe les sections ci-dessous pour obtenir des informations sur la façon 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 tes modèles Ultralytics YOLOv8 au format TensorRT , tu es maintenant prêt à les déployer. Pour obtenir des instructions détaillées sur le déploiement de tes modèles TensorRT dans différents contextes, jette un coup d'œil aux ressources suivantes :

• Déployer Ultralytics avec un serveur Triton : Notre guide sur l'utilisation du serveur NVIDIA's Triton Inference (anciennement TensorRT Inference) 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.

• L'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 GitHub officiel 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, jette un coup d'œil à la documentation officielle deTensorRT .

Si tu es curieux de connaître d'autres intégrations de Ultralytics YOLOv8 , notre page de guide d'intégration fournit une vaste sélection de ressources et d'informations.

FAQ

Comment convertir les modèles YOLOv8 au format TensorRT ?

Pour convertir tes modèles Ultralytics YOLOv8 au format TensorRT afin d'optimiser l'inférence NVIDIA GPU , suis les étapes suivantes :

1. Installe le paquetage requis:

   pip install ultralytics
   

2. Exporte ton 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, consulte le guide d'installationYOLOv8 et la documentation d'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 offre 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 façon 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, ce qui garantit des performances maximales.

Pour plus d'informations, explore les caractéristiques détaillées de TensorRT ici et lis notre section d'aperçu deTensorRT .

Puis-je utiliser la quantification INT8 avec TensorRT pour les modèles YOLOv8 ?

Oui, tu peux exporter des modèles YOLOv8 en utilisant TensorRT avec une quantification INT8. Ce processus implique une quantification post-entraînement (PTQ) et un calibrage :

1. Exporte 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écute 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, reporte-toi à la section sur l'exportation de 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 le serveur Triton : Guide étape par étape sur la configuration 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 t'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:

  • Inférence FP32: ~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 repères de performance détaillés pour différentes configurations matérielles se trouvent dans la section sur les performances.

Pour obtenir des informations plus complètes sur les performances de TensorRT , reporte-toi à la documentation deUltralytics et à nos rapports d'analyse des performances.

📅 Created 8 months ago ✏️ Updated 20 days ago

Commentaires