Exportation TensorRT pour les modèles YOLO11

Le déploiement de modèles de vision par ordinateur dans des environnements à hautes performances peut nécessiter un format qui maximise la vitesse et l'efficacité. Cela est particulièrement vrai lorsque vous déployez votre modèle sur des GPU NVIDIA.

En utilisant le format d'exportation TensorRT, vous pouvez améliorer vos modèles Ultralytics YOLO11 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 de deep learning.

TensorRT

TensorRT, développé par NVIDIA, est un kit de développement logiciel (SDK) avancé conçu pour l'inférence d'apprentissage profond à haute vitesse. Il est bien adapté aux applications en temps réel comme 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 de couches, l'étalonnage de la précision (INT8 et FP16), la gestion dynamique de la mémoire tensorielle et l'auto-tuning du noyau. La conversion des modèles d'apprentissage profond au format TensorRT permet aux développeurs de réaliser pleinement le potentiel des GPU NVIDIA.

TensorRT est reconnu pour sa compatibilité avec divers formats de modèles, notamment TensorFlow, PyTorch et ONNX, offrant aux développeurs une solution flexible pour l'intégration et l'optimisation de modèles provenant de différents frameworks. Cette polyvalence permet un déploiement de modèles efficace dans divers environnements matériels et logiciels.

Principales caractéristiques des modèles TensorRT

Les modèles TensorRT offrent une gamme de fonctionnalités clés qui contribuent à leur efficacité et à leur efficacité dans l'inférence d'apprentissage profond à haute vitesse :

• Calibration de précision : TensorRT prend en charge la calibration de précision, permettant d'affiner les modèles pour des exigences de précision spécifiques. Cela inclut la prise en charge des formats de précision réduite comme INT8 et FP16, ce qui peut encore améliorer 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 réduit la surcharge de calcul et améliore la vitesse d’inférence en minimisant l’accès à la mémoire et le calcul.

• Gestion dynamique de la mémoire tensorielle : TensorRT gère efficacement l'utilisation de la mémoire tensorielle pendant l'inférence, réduisant ainsi la surcharge de mémoire et optimisant l'allocation de mémoire. Il en résulte une utilisation plus efficace de la mémoire du GPU.

• Réglage automatique du noyau : TensorRT applique un 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 des GPU.

Options de déploiement dans TensorRT

Avant d'examiner le code d'exportation des modèles YOLO11 au format TensorRT, comprenons où les modèles 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é :

• Déploiement dans TensorFlow : Cette méthode intègre TensorRT dans TensorFlow, ce qui permet d’exécuter des modèles optimisés 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.

• API d'exécution TensorRT autonome : Offre un contrôle granulaire, idéal pour les applications critiques en termes de performances. Elle est plus complexe, mais permet une implémentation personnalisée des opérateurs non pris en charge.

• Serveur d’inférence NVIDIA Triton : Une option qui prend en charge les modèles de divers frameworks. Particulièrement adapté à l’inférence dans le cloud ou en périphérie, il offre des fonctionnalités telles que l’exécution simultanée de modèles et l’analyse de modèles.

Exporter des modèles YOLO11 vers TensorRT

Vous pouvez améliorer l'efficacité de l'exécution et optimiser les performances en convertissant les modèles YOLO11 au format TensorRT.

Installation

Pour installer le paquet requis, exécutez :

# Install the required package for YOLO11
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques relatives au processus d'installation, consultez notre guide d'installation YOLO11. Si vous rencontrez des difficultés lors de l'installation des packages requis pour YOLO11, consultez notre guide des problèmes courants pour obtenir des solutions et des conseils.

Utilisation

Avant de plonger dans les instructions d'utilisation, assurez-vous de consulter la gamme de modèles YOLO11 proposés par Ultralytics. Cela vous aidera à choisir le modèle le plus approprié pour les exigences de votre projet.

from ultralytics import YOLO

# Load the YOLO11 model
model = YOLO("yolo11n.pt")

# Export the model to TensorRT format
model.export(format="engine")  # creates 'yolo11n.engine'

# Load the exported TensorRT model
tensorrt_model = YOLO("yolo11n.engine")

# Run inference
results = tensorrt_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'

Arguments d'exportation

Pour plus de détails sur le processus d'exportation, consultez la page de la documentation Ultralytics sur l'exportation.

Exporter TensorRT avec la quantification INT8

L'exportation de modèles Ultralytics YOLO à l'aide de TensorRT avec une précision INT8 exécute la quantification post-entraînement (PTQ). TensorRT utilise la calibration pour la PTQ, qui mesure la distribution des activations dans chaque tenseur d'activation lorsque le modèle YOLO traite l'inférence sur des données d'entrée représentatives, puis utilise cette distribution pour estimer les valeurs d'échelle pour chaque tenseur. Chaque tenseur d'activation qui est un candidat à la quantification a une échelle associée qui est déduite par un processus de calibration.

Lors du traitement des réseaux quantifiés implicitement, 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 a des échelles de quantification attribuées sur ses entrées et sorties de données, alors un noyau avec une précision INT8 est attribué à cette couche, sinon TensorRT sélectionne une précision de FP32 ou FP16 pour le noyau en fonction de ce qui entraîne un temps d'exécution plus rapide pour cette couche.

Configuration de l'exportation INT8

Les arguments fournis lors de l'utilisation de export 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 disponibles sur l'appareil, cependant les arguments par défaut devrait fonctionne pour la plupart Processeurs graphiques discrets NVIDIA Ampere (ou plus récents). L'algorithme d'étalonnage utilisé est "MINMAX_CALIBRATION" et vous pouvez lire plus de détails sur les options disponibles dans le Guide du développeur TensorRT. Les tests Ultralytics ont révélé que "MINMAX_CALIBRATION" était le meilleur choix et les exportations sont corrigées pour utiliser cet algorithme.

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

  • Ajuster le workspace valeur en fonction de vos besoins d'étalonnage et de la disponibilité des ressources. Bien qu'une plus grande workspace peut augmenter le temps d'étalonnage, mais permet à TensorRT d'explorer un plus large éventail de tactiques d'optimisation, améliorant potentiellement les performances du modèle et précision. Inversement, un plus petit workspace peut réduire le temps d'étalonnage, mais peut limiter les stratégies d'optimisation, affectant la qualité du modèle quantifié.

  • La valeur par défaut est workspace=None, ce qui permettra à TensorRT d'allouer automatiquement de la mémoire. Lors d'une configuration manuelle, cette valeur peut devoir être augmentée si l'étalonnage plante (se termine sans avertissement).

  • TensorRT signalera UNSUPPORTED_STATE pendant l'exportation si la valeur de workspace est supérieur à la mémoire disponible pour l'appareil, ce qui signifie que la valeur de workspace doit être abaissée ou réglée sur None.

  • Si workspace est définie sur la valeur maximale et l'étalonnage échoue/plante, envisagez d'utiliser None pour l'allocation automatique ou en réduisant les valeurs de imgsz et batch afin de réduire les besoins en mémoire.

  • N’oubliez pas que l’étalonnage pour INT8 est spécifique à chaque appareil, emprunter un GPU « haut de gamme » pour l’étalonnage peut entraîner de mauvaises performances lorsque l’inférence est exécutée sur un autre appareil.

• batch : La taille maximale de 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 par NVIDIA les a amenés à recommander l'utilisation d'au moins 500 images d'étalonnage qui sont représentatives des données de votre modèle, avec un étalonnage de quantification INT8. Il s'agit d'une directive et non d'une difficile exigence, et vous devrez expérimenter avec ce qui est nécessaire pour bien performer pour votre ensemble de données. Étant donné que les données d'étalonnage sont nécessaires pour l'étalonnage INT8 avec TensorRT, assurez-vous d'utiliser les data argument lorsque int8=True pour TensorRT et utiliser data="my_dataset.yaml", qui utilisera les images de validation pour calibrer. Lorsqu'aucune valeur n'est passée pour data avec l'exportation vers TensorRT avec la quantification INT8, la valeur par défaut sera d'utiliser l'un des des ensembles de données d'exemple « petits » basés sur la tâche du modèle au lieu de générer 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 YOLO11n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolo11n.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 de modèle réduite : La quantification de FP32 à INT8 peut réduire la taille du modèle de 4x (sur le disque ou en mémoire), ce qui entraîne des temps de téléchargement plus rapides, des exigences de stockage plus faibles et une empreinte mémoire réduite 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.

• Vitesses d'inférence améliorées : TensorRT optimise le modèle pour le matériel cible, ce qui peut entraîner des vitesses d'inférence plus rapides sur les GPU, les appareils embarqués et les accélérateurs.

Inconvénients de l'utilisation de YOLO avec TensorRT INT8

• Diminutions des métriques d'évaluation : L'utilisation d'une précision inférieure signifiera que mAP, Precision, Recall ou tout autre mesure utilisée pour évaluer les performances du modèle risque d'être légèrement moins bonne. Voir le Section des résultats de performance pour comparer les différences dans 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 INT8 pour l'ensemble de données et l'appareil peut prendre beaucoup de tests.

• Dépendance matérielle : L’étalonnage et les gains de performance pourraient être fortement dépendants du matériel et les poids du modèle sont moins transférables.

Performances de l'exportation Ultralytics YOLO TensorRT

NVIDIA A100

GPU grand public

Appareils 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 de modèles YOLO11 TensorRT exportés

Après avoir exporté avec succès vos modèles Ultralytics YOLO11 au format TensorRT, vous êtes maintenant prêt à les déployer. Pour 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 d'inférence Triton de NVIDIA (anciennement TensorRT Inference) spécifiquement pour une utilisation avec les modèles Ultralytics YOLO.

• Déploiement de 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 : Déploiement de NVIDIA TensorRT : 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.

• Référentiel GitHub pour NVIDIA TensorRT:: Il s'agit du référentiel GitHub officiel qui contient le code source et la documentation de NVIDIA TensorRT.

Résumé

Dans ce guide, nous nous sommes concentrés sur la conversion des modèles Ultralytics YOLO11 au format de modèle TensorRT de NVIDIA. Cette étape de conversion est essentielle pour améliorer l'efficacité et la vitesse des modèles YOLO11, les rendant plus efficaces et adaptés à divers environnements de déploiement.

Pour plus d'informations sur les détails d'utilisation, consultez la documentation officielle de TensorRT.

Si vous êtes curieux de connaître les intégrations supplémentaires d'Ultralytics YOLO11, notre page de guide d'intégration fournit une vaste sélection de ressources et d'informations utiles.

FAQ

Comment convertir les modèles YOLO11 au format TensorRT ?

Pour convertir vos modèles Ultralytics YOLO11 au format TensorRT pour une inférence NVIDIA GPU optimisée, suivez ces étapes :

1. Installer le paquet requis :

   pip install ultralytics
   

2. Exporter votre modèle YOLO11 :

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

Pour plus de détails, consultez le guide d'installation de YOLO11 et la documentation sur l'exportation.

Quels sont les avantages de l'utilisation de TensorRT pour les modèles YOLO11 ?

L'utilisation de TensorRT pour optimiser les modèles YOLO11 offre plusieurs avantages :

• Vitesse d'inférence plus rapide : TensorRT optimise les couches du modèle et utilise l'étalonnage 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 des tenseurs de manière dynamique, réduisant ainsi la surcharge et améliorant l'utilisation de la mémoire du GPU.
• Fusion de couches : Combine plusieurs couches en opérations uniques, réduisant ainsi la complexité computationnelle.
• Réglage automatique du noyau : Sélectionne automatiquement les noyaux GPU optimisés pour chaque couche de modèle, assurant ainsi une performance maximale.

Pour en savoir plus, consultez la documentation TensorRT officielle de NVIDIA et notre présentation détaillée de TensorRT.

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

Oui, vous pouvez exporter des modèles YOLO11 en utilisant TensorRT avec la quantification INT8. Ce processus implique une quantification post-entraînement (PTQ) et un étalonnage :

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, consultez la section sur l'exportation TensorRT avec quantification INT8.

Comment déployer les modèles YOLO11 TensorRT sur un serveur d'inférence NVIDIA Triton ?

Le déploiement de modèles YOLO11 TensorRT sur un serveur d'inférence NVIDIA Triton peut être effectué à l'aide des ressources suivantes :

• Déployer Ultralytics YOLOv8 avec le serveur Triton : Instructions étape par étape sur la configuration et l'utilisation du serveur d'inférence Triton.
• Documentation du serveur d'inférence NVIDIA Triton : Documentation NVIDIA officielle 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 ?

Les améliorations de performance avec TensorRT peuvent varier en fonction du matériel utilisé. Voici quelques bancs d'essai typiques :

• NVIDIA A100 :

  • Inférence FP32 : ~0,52 ms / image
  • Inférence FP16 : ~0,34 ms / image
  • Inférence INT8 : ~0,28 ms / image
  • Légère réduction de la mAP avec la précision INT8, mais amélioration significative de la vitesse.

• Processeurs graphiques grand public (par exemple, RTX 3080) :

  • Inférence FP32 : ~1,06 ms / image
  • Inférence FP16 : ~0,62 ms / image
  • Inférence INT8 : ~0,52 ms / image

Des benchmarks de performance détaillés pour différentes configurations matérielles sont disponibles dans la section performance.

Pour des informations plus complètes sur les performances de TensorRT, consultez la documentation Ultralytics et nos rapports d'analyse des performances.

📅 Créé il y a 1 an ✏️ Mis à jour il y a 2 mois

Commentaires