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

Le déploiement de modèles de computer vision 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 particulièrement adapté aux applications en temps réel comme la object detection.

Ce toolkit 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-ajustement des noyaux. 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 un model deployment efficace à travers divers environnements matériels et logiciels.

Link to this sectionCaractéristiques principales 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 ajustés selon des exigences de précision spécifiques. Cela inclut la prise en charge de formats de précision réduite tels que INT8 et FP16, qui peuvent augmenter 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 neural network 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. Il en résulte une utilisation plus efficace de la mémoire GPU.

• Auto-ajustement des noyaux (Automatic Kernel Tuning) : TensorRT applique un auto-ajustement 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 avec 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 (Standalone Runtime API) : 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é à l'inférence cloud ou edge, il fournit des fonctionnalités telles que 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. Lors de l'installation des packages requis pour YOLO26, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour des solutions et astuces.

Link to this sectionUtilisation#

Avant de plonger dans les instructions d'utilisation, assure-toi de jeter un œil à 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, visite la page de documentation Ultralytics sur l'exportation.

Link to this sectionExporter TensorRT avec quantification INT8#

L'exportation des modèles Ultralytics YOLO utilisant TensorRT avec une precision INT8 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 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 a une échelle associée qui est déduite par un processus de calibration.

Lors du traitement de réseaux quantifiés implicitement, 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 en fonction de ce qui résulte en un temps d'exécution plus rapide pour cette couche.

Link to this sectionConfigurer 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" 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 en fonction de tes besoins de calibration et de la disponibilité des ressources. Bien qu'un workspace plus grand puisse augmenter le temps de calibration, il permet à TensorRT d'explorer une gamme plus large de tactiques d'optimisation, améliorant potentiellement les performances et l'accuracy du modèle. À l'inverse, 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 pour workspace doit être diminuée 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 en réduisant les valeurs pour imgsz et batch afin de 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 faibles performances lorsque l'inférence sera 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 menée par NVIDIA les a conduits à recommander d'utiliser 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 ligne directrice et non d'une exigence stricte, et tu devras expérimenter ce qui est nécessaire pour obtenir de bonnes performances 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 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 transmise pour data avec l'exportation vers TensorRT avec 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")

Link to this sectionAvantages 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 par 4 (sur disque ou en mémoire), conduisant à 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 alimentés par 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.

Link to this sectionInconvé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 la mAP, la Precision, le Recall ou toute autre métrique utilisée pour évaluer les performances du modèle sera probablement légèrement moins bonne. Voir la section des résultats de performance pour comparer les différences de mAP50 et mAP50-95 lors de l'exportation avec INT8 sur un petit échantillon de divers appareils.

• Temps 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 hautement 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 plus d'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 en TensorRT#

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 au format TensorRT, tu es maintenant 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 NVIDIA Triton Inference (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 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 : : Ceci est le dépôt GitHub officiel contenant 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, jette un œil à la documentation officielle de TensorRT.

Si tu es curieux à propos d'autres intégrations Ultralytics YOLO26, notre page de guide d'intégration fournit une vaste sélection de ressources informatives et d'aperçus.

Link to this sectionFAQ#

Link to this sectionComment convertir les 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, consulte le guide d'installation de YOLO26 et la documentation sur l'exportation.

Link to this sectionQuels sont les avantages d'utiliser TensorRT pour les modèles YOLO26 ?#

L'utilisation de 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é 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-ajustement des noyaux : Sélectionne automatiquement les noyaux GPU optimisés pour chaque couche de modèle, garantissant une performance maximale.

Pour en savoir plus, explore la documentation officielle de TensorRT de 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 les modèles YOLO26 en utilisant TensorRT avec la quantification INT8. Ce processus implique la quantification post-entraînement (PTQ) et la 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 les modèles YOLO26 TensorRT sur un serveur NVIDIA Triton Inference Server ?#

Le déploiement des modèles YOLO26 TensorRT sur un NVIDIA Triton Inference Server peut être effectué 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.
• Déployer des 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 de déploiement 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 selon le 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 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 se trouvent dans la section performance.

Pour des aperçus plus complets sur les performances de TensorRT, reporte-toi à la documentation Ultralytics et à nos rapports d'analyse de performance.