Exportation TensorRT pour les modèles YOLO26

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 tu déploies ton modèle sur des GPU NVIDIA.

En utilisant le format d'exportation TensorRT, tu peux optimiser tes modèles Ultralytics YOLO26 pour une inférence rapide et efficace sur le matériel NVIDIA. Ce guide te fournira des étapes simples à suivre pour le processus de conversion et t'aidera à tirer le meilleur parti de la technologie avancée de NVIDIA dans tes 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 de deep learning à haute vitesse. Il est particulièrement adapté aux applications en temps réel comme la détection d'objets.

Ce kit d'outils optimise les modèles de deep learning pour les GPU NVIDIA, ce qui permet des opérations plus rapides et plus efficaces. Les modèles TensorRT subissent une optimisation TensorRT, qui inclut des techniques telles que la fusion de couches, la calibration de précision (INT8 et FP16), la gestion dynamique de la mémoire des tenseurs et l'auto-tuning des noyaux. La conversion des modèles de deep learning au format TensorRT permet aux développeurs d'exploiter 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 intégrer et optimiser des modèles issus de différents frameworks. Cette polyvalence permet un déploiement de modèle efficace sur divers environnements matériels et logiciels.

Fonctionnalités clés des modèles TensorRT

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

• Calibration de précision : TensorRT prend en charge la calibration de précision, permettant d'ajuster les modèles selon des exigences de précision spécifiques. Cela inclut la prise en charge de formats à précision réduite comme INT8 et FP16, ce qui peut encore augmenter la vitesse d'inférence tout en maintenant des niveaux de précision acceptables.

• Fusion de couches : Le processus d'optimisation TensorRT inclut la fusion de couches, où plusieurs couches d'un réseau de neurones sont combinées en une seule opération. Cela réduit la surcharge computationnelle et améliore la vitesse d'inférence en minimisant les accès mémoire et les calculs.

• Gestion dynamique de la mémoire des tenseurs : TensorRT gère efficacement l'utilisation de la mémoire des tenseurs pendant l'inférence, réduisant la surcharge mémoire et optimisant l'allocation mémoire. Cela se traduit par une utilisation plus efficace de la mémoire GPU.

• Auto-tuning des noyaux : TensorRT applique un auto-tuning des noyaux 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 du GPU.

Options de déploiement dans TensorRT

Avant de regarder le code pour exporter les modèles YOLO26 au format TensorRT, comprenons où les modèles TensorRT sont habituellement 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 avec TensorFlow : Cette méthode intègre TensorRT dans TensorFlow, permettant aux modèles optimisés de s'exécuter dans un environnement TensorFlow familier. C'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 Runtime TensorRT autonome : Offre un contrôle granulaire, idéal pour les applications critiques en termes de performance. C'est plus complexe mais permet une implémentation personnalisée des opérateurs non pris en charge.

• NVIDIA Triton Inference Server : 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 fournit des fonctionnalités telles que l'exécution concurrente de modèles et l'analyse de modèles.

Exportation des modèles YOLO26 vers TensorRT

Tu peux améliorer l'efficacité de l'exécution et optimiser les performances en convertissant les modèles YOLO26 au format TensorRT.

Installation

Pour installer le package requis, exécute :

# Install the required package for YOLO26
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installation YOLO26. Si tu rencontres des difficultés lors de l'installation des packages nécessaires pour YOLO26, consulte notre guide des problèmes courants pour des solutions et des astuces.

Utilisation

Avant de plonger dans les instructions d'utilisation, assure-toi de consulter la gamme de modèles YOLO26 proposés par Ultralytics. Cela t'aidera à choisir le modèle le plus approprié pour les besoins de ton projet.

from ultralytics import YOLO

# Load the YOLO26 model
model = YOLO("yolo26n.pt")

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

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

# Run inference
results = tensorrt_model("https://ultralytics.com/images/bus.jpg")

Arguments d'exportation

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

Exportation TensorRT avec quantification INT8

L'exportation des modèles Ultralytics YOLO utilisant TensorRT avec une précision INT8 exécute une quantification post-entraînement (PTQ). TensorRT utilise la calibration pour la PTQ, qui mesure la distribution des activations au sein de chaque tenseur d'activation pendant que 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 candidat à la quantification a une échelle associée qui est déduite par un processus de calibration.

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 possède des échelles de quantification assignées sur ses entrées et sorties de données, alors un noyau avec une précision INT8 est assigné à cette couche ; sinon, TensorRT sélectionne une précision FP32 ou FP16 pour le noyau en fonction de celle qui donne le temps d'exécution le 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 influenceront grandement les performances du modèle exporté. Ils devront également être sélectionnés en fonction des ressources disponibles sur l'appareil, bien que les arguments par défaut devraient fonctionner pour la plupart des GPU discrets NVIDIA Ampere (ou plus récents). L'algorithme de calibration utilisé est "MINMAX_CALIBRATION" et tu peux lire plus de détails sur les options disponibles dans le Guide du développeur TensorRT. Les tests d'Ultralytics ont montré que "MINMAX_CALIBRATION" é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 mémoire de l'appareil lors de la conversion des poids du modèle.

  • Ajuste la valeur de workspace selon tes besoins de calibration et la disponibilité des ressources. Bien qu'un workspace plus grand puisse augmenter le temps de calibration, il permet à TensorRT d'explorer une plus large gamme de tactiques d'optimisation, améliorant potentiellement les performances et la précision du modèle. Inversement, un workspace plus petit peut réduire le temps de calibration 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 la mémoire ; lors d'une configuration manuelle, cette valeur peut devoir être augmentée si la calibration plante (se ferme sans avertissement).

  • TensorRT signalera UNSUPPORTED_STATE lors de l'exportation si la valeur de workspace est supérieure à la mémoire disponible sur l'appareil, ce qui signifie que la valeur de workspace doit être réduite ou définie sur None.

  • Si workspace est réglé sur la valeur maximale et que la calibration échoue/plante, envisage d'utiliser None pour l'auto-allocation ou en réduisant les valeurs de imgsz et batch pour diminuer les besoins en mémoire.

  • Souviens-toi que la calibration pour INT8 est spécifique à chaque appareil ; emprunter un GPU "haut de gamme" pour la calibration pourrait entraîner de mauvaises performances lors de l'exécution de l'inférence sur un autre appareil.

• batch : La taille de lot (batch-size) maximale 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 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 directive et non d'une exigence stricte, et tu devras expérimenter ce qui est nécessaire pour obtenir de bons résultats avec ton jeu de données. Puisque les données de calibration sont requises pour la calibration INT8 avec TensorRT, assure-toi d'utiliser l'argument data lorsque int8=True pour TensorRT et utilise data="my_dataset.yaml", ce qui utilisera les images de validation pour calibrer. Lorsqu'aucune valeur n'est passée pour data avec une exportation vers TensorRT avec quantification INT8, le comportement par défaut sera d'utiliser l'un des jeux de données "petits" exemples basés sur la tâche du modèle au lieu de générer une erreur.

from ultralytics import YOLO

model = YOLO("yolo26n.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("yolo26n.engine", task="detect")

# Run inference
result = model.predict("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 vers INT8 peut réduire la taille du modèle par 4 (sur disque ou en mémoire), conduisant à des temps de téléchargement plus rapides, des besoins de stockage moindres et une empreinte mémoire réduite lors du déploiement d'un modèle.

• Consommation d'énergie réduite : Les opérations à précision réduite pour les modèles YOLO exportés en INT8 peuvent consommer moins d'énergie par rapport aux modèles FP32, surtout pour les appareils fonctionnant sur batterie.

• Vitesses d'inférence améliorées : TensorRT optimise le modèle pour le matériel cible, conduisant potentiellement à 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

• Diminution des métriques d'évaluation : L'utilisation d'une précision inférieure signifie que le mAP, la Precision, le Recall ou toute autre métrique utilisée pour évaluer les performances du modèle seront probablement quelque peu dégradés. Voir la section sur les résultats de performance pour comparer les différences de mAP50 et mAP50-95 lors de l'exportation en INT8 sur un petit échantillon de divers appareils.

• Délais de développement accrus : Trouver les paramètres "optimaux" pour la calibration INT8 pour un jeu de données et un appareil peut prendre une quantité significative de tests.

• Dépendance matérielle : La calibration et les gains de performance pourraient être très dépendants du matériel et les poids du modèle sont moins transférables.

Performance de l'exportation Ultralytics YOLO TensorRT

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("yolo26n.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("yolo26n.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("yolo26n.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 YOLO26 TensorRT exportés

Une fois tes modèles Ultralytics YOLO26 exportés avec succès au format TensorRT, tu es prêt à les déployer. Pour des instructions détaillées sur le déploiement de tes modèles TensorRT dans divers environnements, jette un œil aux ressources suivantes :

• Déployer Ultralytics avec un serveur Triton : Notre guide sur l'utilisation du serveur Triton Inference de NVIDIA (anciennement TensorRT Inference Server) spécifiquement pour les modèles Ultralytics YOLO.

• Déployer des réseaux de neurones profonds avec NVIDIA TensorRT : Cet article explique comment utiliser NVIDIA TensorRT pour déployer efficacement des réseaux de neurones profonds sur des plateformes basées sur GPU.

• IA de bout en bout pour les PC basés sur NVIDIA : déploiement 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 équipés de matériel NVIDIA.

• Dépôt GitHub pour NVIDIA TensorRT : : Voici 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 YOLO26 vers le format de modèle TensorRT de NVIDIA. Cette étape de conversion est cruciale pour améliorer l'efficacité et la vitesse des modèles YOLO26, les rendant plus efficaces et adaptés à divers environnements de déploiement.

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

Si tu es curieux de découvrir d'autres intégrations d'Ultralytics YOLO26, notre page de guide d'intégration propose une vaste sélection de ressources et d'informations pertinentes.

FAQ

Comment convertir des modèles YOLO26 au format TensorRT ?

Pour convertir tes modèles Ultralytics YOLO26 au format TensorRT pour une inférence optimisée sur GPU NVIDIA, suis ces étapes :

1. Installe le paquet requis :

   pip install ultralytics

2. Exporte ton modèle YOLO26 :

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

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

Quels sont les avantages d'utiliser TensorRT pour les modèles YOLO26 ?

Utiliser TensorRT pour optimiser les modèles YOLO26 offre plusieurs avantages :

• Vitesse d'inférence plus rapide : TensorRT optimise les couches du modèle et utilise la calibration de précision (INT8 et FP16) pour accélérer l'inférence sans sacrifier significativement la précision.
• Efficacité mémoire : TensorRT gère la mémoire des tenseurs dynamiquement, réduisant les surcharges et améliorant l'utilisation de la mémoire GPU.
• Fusion de couches : Combine plusieurs couches en opérations uniques, réduisant la complexité computationnelle.
• Auto-ajustement des noyaux (Kernel Auto-Tuning) : Sélectionne automatiquement les noyaux GPU optimisés pour chaque couche du modèle, garantissant des performances maximales.

Pour en savoir plus, explore la documentation officielle de TensorRT de NVIDIA et notre aperçu approfondi de TensorRT.

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

Oui, tu peux exporter des modèles YOLO26 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("yolo26n.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("yolo26n.engine", task="detect")
   result = model.predict("https://ultralytics.com/images/bus.jpg")

Pour plus de détails, réfère-toi à la section sur l'exportation TensorRT avec quantification INT8.

Comment déployer des modèles YOLO26 TensorRT sur un serveur NVIDIA Triton Inference ?

Le déploiement de modèles YOLO26 TensorRT sur un serveur NVIDIA Triton Inference peut être effectué en utilisant les ressources suivantes :

• Déploie Ultralytics YOLO26 avec Triton Server : Guide étape par étape pour configurer et utiliser Triton Inference Server.
• Documentation de NVIDIA Triton Inference Server : Documentation officielle de NVIDIA pour des options de déploiement et des configurations détaillées.

Ces guides t'aideront à intégrer tes modèles YOLO26 efficacement dans divers environnements de déploiement.

Quelles sont les améliorations de performance observées avec les modèles YOLO26 exportés vers TensorRT ?

Les améliorations de performance avec TensorRT peuvent varier en fonction du matériel utilisé. Voici quelques benchmarks 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 du mAP avec la précision INT8, mais une amélioration significative de la vitesse.

• GPU grand public (par ex. 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 analyses plus approfondies sur les performances de TensorRT, consulte la documentation Ultralytics et nos rapports d'analyse de performance.