Exportation TensorRT pour les modèles YOLO26

Déployer des computer vision les modèles dans des environnements à haute performance peuvent 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 améliorer tes Ultralytics YOLO26 modèles pour une inférence rapide et efficace sur le matériel NVIDIA. Ce guide te donnera des étapes simples à suivre pour le processus de conversion et t'aidera à tirer le meilleur parti de la technologie avancée de NVIDIA dans ton deep learning projets.

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 bien adapté aux applications en temps réel comme object detection.

Ce toolkit optimise les modèles de deep learning pour les GPU NVIDIA et permet des opérations plus rapides et plus efficaces. Les modèles TensorRT subissent une optimisation TensorRT, qui inclut des techniques comme la fusion de couches, la calibration de précision (INT8 et FP16), la gestion dynamique de la mémoire des tenseurs et l'auto-ajustement des noyaux (kernel auto-tuning). Convertir des modèles de deep learning au format TensorRT permet aux développeurs de réaliser pleinement le potentiel des GPU NVIDIA.

TensorRT est connu 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 une model deployment efficace à travers 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 aux modèles d'être affinés pour des exigences de précision spécifiques. Cela inclut la prise en charge de formats de précision réduite comme INT8 et FP16, qui peuvent 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éseaux 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 l'accès à la 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-ajustement des noyaux (Kernel): TensorRT applique un ajustement automatique des noyaux pour sélectionner le kernel GPU le plus optimisé pour chaque couche du modèle. Cette approche adaptative garantit que le modèle tire pleinement parti de la puissance computationnelle du GPU.

Options de déploiement dans TensorRT

Avant de regarder le code pour exporter des modèles YOLO26 vers le 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, permettant aux modèles optimisés de s'exécuter dans un environnement TensorFlow familier. C'est utile pour les modèles avec 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 où la performance est critique. 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 (edge), elle fournit des fonctionnalités comme 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. Lors de l'installation des paquets requis pour YOLO26, si tu rencontres des difficultes, consulte notre guide des problemes courants pour des solutions et astuces.

Utilisation

Avant de plonger dans les instructions d'utilisation, assure-toi de verifier la gamme de modèles YOLO26 proposés par Ultralytics. Cela t'aidera à choisir le modèle le plus approprié aux exigences 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 le page de documentation Ultralytics sur l'exportation.

Exporter TensorRT avec quantification INT8

Exporter des modèles Ultralytics YOLO utilisant TensorRT avec INT8 précision exécute une quantification post-entraînement (PTQ). TensorRT utilise la calibration pour le 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 possède une échelle associée qui est déduite par un processus de calibration.

Lors du traitement de réseaux implicitement quantifiés, TensorRT utilise l'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 précision INT8 est assigné à cette couche ; sinon, TensorRT sélectionne une précision FP32 ou FP16 pour le noyau en fonction de ce qui permet 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 vont grandement influencer 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 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 workspace selon tes besoins de calibration et la disponibilité des ressources. Bien qu'une valeur plus grande workspace puisse augmenter le temps de calibration, elle permet à TensorRT d'explorer un plus large éventail de tactiques d'optimisation, améliorant potentiellement les performances du modèle et la précision. Inversement, une valeur plus petite workspace 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 de la configuration manuelle, cette valeur peut avoir besoin d'être augmentée si la calibration plante (se termine sans avertissement).

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

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

  • N'oublie pas 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 lorsque l'inférence est exécutée 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 pour ton modèle, avec la calibration par 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 pour 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 lors de int8=True pour TensorRT et d'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 "petits" jeux de données d'exemple basés sur la tâche du modèle au lieu de renvoyer 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

• Réduction de la taille du modèle :La quantification de FP32 vers INT8 peut réduire la taille du modèle par 4 (sur disque ou en mémoire), ce qui permet des temps de téléchargement plus rapides, des besoins de stockage réduits et une empreinte mémoire allégée 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 que les modèles FP32, surtout 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 mener à des vitesses d'inférence plus rapides sur GPU, appareils embarqués et 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 mAP, Precision, Recall ou toute autre métrique utilisée pour évaluer les performances du modèle sera probablement un peu moins bonne. Consulte la section Résultats de performance pour comparer les différences de mAP50 et en mAP50-95 lors de l'exportation en INT8 sur un petit échantillon de divers appareils.

• Temps de développement accrus :Trouver les paramètres "optimaux" pour le calibrage INT8 selon le jeu de données et l'appareil peut demander une quantité importante de tests.

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

Performance d'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

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 au format TensorRT, tu es prêt à les déployer. Pour des instructions approfondies 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 la façon d'utiliser le serveur Triton Inference (anciennement TensorRT Inference) de NVIDIA spécifiquement pour 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 avec 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 :: Il s'agit du dépôt 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 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 performants et adaptés à divers environnements de déploiement.

Pour plus d'informations sur les détails d'utilisation, jette un œil à la documentation officielle de TensorRT.

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

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 package 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 de l'documentation d'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 le calibrage 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 de manière dynamique, 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-tuning des kernels: Sélectionne automatiquement les kernels 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 présentation approfondie 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 un calibrage :

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, reporte-toi à la section 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 réalisé en utilisant les ressources suivantes :

• Déployer Ultralytics YOLO26 avec Triton Server: Guide étape par étape sur la configuration et l'utilisation de Triton Inference Server.
• Documentation de NVIDIA Triton Inference Server: Documentation officielle de NVIDIA pour des options et configurations de déploiement détaillées.

Ces guides t'aideront à intégrer efficacement les modèles YOLO26 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:

  • FP32 Inférence : ~0.52 ms / image
  • FP16 Inférence : ~0.34 ms / image
  • INT8 Inférence : ~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 (ex: RTX 3080):

  • FP32 Inférence : ~1.06 ms / image
  • FP16 Inférence : ~0.62 ms / image
  • INT8 Inférence : ~0.52 ms / image

Des benchmarks de performance détaillés pour différentes configurations matérielles peuvent être trouvés dans la section performance.

Pour des analyses plus complètes sur les performances de TensorRT, réfère-toi à la La documentation d'Ultralytics et à nos rapports d'analyse de performance.