Link to this sectionExportation TensorRT pour les modèles YOLO26#

Déployer des 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.

Link to this sectionTensorRT#

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 parfaitement 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 du noyau. 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 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 à travers divers environnements matériels et logiciels.

Link to this sectionFonctionnalité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 pour 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 ajustés finement selon 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 booster davantage 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 charge 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 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. Il en résulte 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.

Link to this sectionOptions de déploiement dans TensorRT#

Avant de regarder le code pour exporter des modèles YOLO26 au format TensorRT, comprenons où les modèles TensorRT sont habituellement utilisés.

TensorRT propose 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 ayant 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 autonome TensorRT : 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.

• Serveur d'inférence NVIDIA Triton : 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 offre des fonctionnalités comme l'exécution concurrente de modèles et l'analyse de modèles.

Link to this sectionExporter 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.

Link to this sectionInstallation#

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 requis pour YOLO26, consulte notre guide des problèmes courants pour des solutions et astuces.

Link to this sectionUtilisation#

Avant de te lancer 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 exigences de ton projet.

Le format TensorRT prend en charge les modes Export, Predict et Validate. L'inférence et la validation nécessitent un GPU NVIDIA. Exporte ton modèle, puis charge le modèle exporté pour exécuter l'inférence ou valider sa précision.

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

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

from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Link to this sectionArguments d'exportation#

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

Link to this sectionExporter vers TensorRT avec quantification INT8#

Exporter des modèles Ultralytics YOLO en 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 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 candidat à la quantification possède une échelle associée 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 une précision INT8 est assigné à cette couche ; sinon, TensorRT sélectionne une précision FP32 ou FP16 pour le noyau, selon celle qui résulte en un temps d'exécution plus rapide pour cette couche.

Link to this sectionConfiguration 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 ; 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" pour les exportations GPU, tandis que les exportations DLA sur NVIDIA Jetson utilisent "ENTROPY_CALIBRATION_2". 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" est le meilleur choix pour les exportations GPU, et l'algorithme est sélectionné automatiquement en fonction de l'appareil d'exportation.

• 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'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. À l'inverse, un workspace plus petit peut réduire le temps de calibration mais 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 devra peut-être être augmentée si la calibration plante (se ferme sans avertissement).

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

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

  • N'oublie pas que la calibration pour l'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 de ton modèle avec la calibration de quantification INT8. Il s'agit d'une recommandation et non d'une exigence stricte, et tu devras expérimenter pour savoir ce qui est nécessaire pour obtenir de bonnes performances sur ton jeu de données. Comme 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 lors de l'exportation vers TensorRT avec une quantification INT8, la valeur par défaut sera d'utiliser l'un des jeux de données exemples "petits" 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")

Link to this sectionAvantages 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 le disque ou en mémoire), menant à 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 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, menant potentiellement à des vitesses d'inférence plus rapides sur les GPU, les appareils embarqués et les accélérateurs.

Link to this sectionInconvénients de l'utilisation de YOLO avec TensorRT INT8#

• Decreases in evaluation metrics: Using a lower precision will mean that mAP, Precision, Recall or any other metric used to evaluate model performance is likely to be somewhat worse. See the Performance results section to compare the differences in mAP50 and mAP50-95 when exporting with INT8 on small sample of various devices.

• Augmentation des temps de développement : Trouver les paramètres "optimaux" pour la calibration INT8 pour un jeu de données et un appareil donnés peut demander une quantité significative de tests.

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

Link to this sectionPerformances d'exportation Ultralytics YOLO TensorRT#

Link to this sectionNVIDIA A100#

Link to this sectionGPU grand public#

Link to this sectionAppareils embarqués#

Link to this sectionMé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",
)

Link to this sectionDéploiement de modèles YOLO26 exportés vers TensorRT#

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 vers le 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 l'utilisation du serveur NVIDIA Triton Inference (anciennement TensorRT Inference Server) spécifiquement pour les modèles Ultralytics YOLO.

• Déploiement de 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 PC équipés 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 NVIDIA.

• Référentiel GitHub pour NVIDIA TensorRT : : Ceci est le référentiel GitHub officiel qui contient le code source et la documentation pour NVIDIA TensorRT.

Link to this sectionRé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, consulte la documentation officielle de TensorRT.

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

Link to this sectionFAQ#

Link to this sectionComment 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 la documentation d'exportation.

Link to this sectionQuels 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 une calibration de précision (INT8 et FP16) pour accélérer l'inférence sans sacrifier significativement la précision.
• Efficacité de la mémoire : TensorRT gère dynamiquement la mémoire des tenseurs, réduisant la surcharge 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 noyaux (kernels) : Sélectionne automatiquement les noyaux GPU optimisés pour chaque couche de modèle, assurant une performance maximale.

Pour en savoir plus, explore la documentation officielle de TensorRT par NVIDIA et notre présentation approfondie de TensorRT.

Link to this sectionPuis-je utiliser la quantification INT8 avec TensorRT pour les modèles YOLO26 ?#

Oui, tu peux exporter des modèles YOLO26 en utilisant TensorRT avec la 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, reporte-toi à la section sur l'exportation TensorRT avec quantification INT8.

Link to this sectionComment déployer des modèles YOLO26 TensorRT sur un serveur NVIDIA Triton Inference Server ?#

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

• Déployer Ultralytics YOLO26 avec Triton Server : Conseils étape par étape sur la configuration et l'utilisation de Triton Inference Server.
• Déploiement de réseaux de neurones profonds avec NVIDIA TensorRT : Guide de NVIDIA sur le déploiement de modèles d'apprentissage profond avec TensorRT pour des options et configurations détaillées.

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

Link to this sectionQuelles 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 de la mAP avec la précision INT8, mais amélioration significative de la vitesse.

• GPU grand public (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 peuvent être trouvés dans la section performance.

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