Export TensorRT pour les modèles YOLO26#

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

En utilisant le format d'export TensorRT, tu peux optimiser tes modèles Ultralytics YOLO26 pour une inférence rapide et efficace sur du matériel NVIDIA. Ce guide te présente des étapes faciles à suivre pour le processus de conversion et t'aide à 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 deep learning à grande vitesse. Il convient parfaitement aux applications en temps réel comme la détection d'objets.

Cette boîte à outils optimise les modèles deep learning pour les GPU NVIDIA et permet des opérations plus rapides et plus efficaces. Les modèles TensorRT sont soumis à 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-optimisation des kernels. La conversion des modèles deep learning au format TensorRT permet aux développeurs d'exploiter pleinement le potentiel des GPU NVIDIA.

TensorRT est réputé pour sa compatibilité avec différents 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èles efficace dans divers environnements matériels et logiciels.

Fonctionnalités clés des modèles TensorRT#

Les modèles TensorRT offrent plusieurs fonctionnalités clés qui contribuent à leur efficacité et à leurs performances pour l'inférence deep learning à grande vitesse :

• Calibration de précision : TensorRT prend en charge la calibration de précision, ce qui permet d'ajuster finement les modèles pour répondre à des exigences de précision spécifiques. Cela inclut la prise en charge de formats à précision réduite comme INT8 et FP16, qui peuvent encore accélérer l'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 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 limitant les 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 de mémoire. Il en résulte une utilisation plus efficace de la mémoire du GPU.

• Optimisation automatique des kernels : TensorRT applique une optimisation automatique des kernels afin de sélectionner le kernel GPU le plus optimisé pour chaque couche du modèle. Cette approche adaptative garantit que le modèle exploite pleinement la puissance de calcul du GPU.

Options de déploiement dans TensorRT#

Avant d'examiner le code permettant d'exporter des modèles YOLO26 au format TensorRT, voyons où les modèles TensorRT sont généralement utilisés.

TensorRT propose plusieurs options de déploiement, chacune offrant un compromis différent entre facilité d'intégration, optimisation des performances et flexibilité :

• Déploiement dans TensorFlow : cette méthode intègre TensorRT à TensorFlow, ce qui permet aux modèles optimisés de s'exécuter dans un environnement TensorFlow familier. Elle est utile pour les modèles combinant des couches prises en charge et non prises en charge, car TF-TRT peut les gérer efficacement.

• API d'exécution TensorRT autonome : elle offre un contrôle précis, idéal pour les applications où les performances sont critiques. Elle 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 issus de différents frameworks. Particulièrement adapté à l'inférence dans le cloud ou en périphérie, il fournit des fonctionnalités comme l'exécution simultanée de modèles et l'analyse des modèles.

Tâches prises en charge#

L'export TensorRT prend en charge les sept tâches Ultralytics. La segmentation sémantique et l'estimation de profondeur sont disponibles uniquement avec YOLO26, la seule famille à fournir ces têtes.

Exportation des modèles YOLO26 vers TensorRT#

Tu peux améliorer l'efficacité d'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 obtenir des instructions détaillées et connaître les bonnes pratiques liées au processus d’installation, consulte notre guide d’installation de YOLO26. Si tu rencontres des difficultés lors de l’installation des packages requis pour YOLO26, consulte notre guide des problèmes courants pour trouver des solutions et des conseils.

Utilisation#

Avant de passer aux instructions d'utilisation, consulte la gamme de modèles YOLO26 proposés par Ultralytics. Cela t'aidera à choisir le modèle le mieux adapté aux 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")

Arguments d'exportation#

Pour plus de détails sur le processus d’exportation, consulte la page de la documentation Ultralytics consacrée à l’exportation.

Exportation de TensorRT avec quantification INT8#

L'exportation de modèles YOLO d'Ultralytics à l'aide de TensorRT avec la précision INT8 exécute la quantification post-entraînement (PTQ). TensorRT utilise l'étalonnage pour la quantification post-entraînement, 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 candidat à la quantification possède une échelle associée déduite par un processus d'étalonnage. Un point de contrôle affiné avec quantize=8 par le biais de l'entraînement tenant compte de la quantification transporte déjà ses plages INT8, de sorte que son exportation les utilise et ignore l'étalonnage.

Lors du traitement de 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 possède des échelles de quantification attribuées à ses entrées et sorties de données, un kernel en précision INT8 est affecté à cette couche ; sinon, TensorRT sélectionne une précision FP32 ou FP16 pour le kernel, selon celle qui permet l'exécution la plus rapide pour cette couche.

Configuration de l'exportation INT8#

Les arguments fournis lors de l'utilisation de l'exportation pour un modèle Ultralytics YOLO influencent considérablement les performances du modèle exporté. Ils doivent également être sélectionnés en fonction des ressources disponibles sur l'appareil ; toutefois, les arguments par défaut devraient fonctionner pour la plupart des GPU NVIDIA discrets 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 consulter davantage de détails sur les options disponibles dans le TensorRT Developer Guide. Les tests d'Ultralytics ont montré que "MINMAX_CALIBRATION" était 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 Gio) de l'allocation de 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 des ressources disponibles. Une valeur plus élevée de workspace peut augmenter le temps de calibration, mais permet à TensorRT d'explorer un éventail plus large de stratégies d'optimisation, ce qui peut améliorer les performances et la précision du modèle. À l'inverse, une valeur plus faible de workspace peut réduire le temps de calibration, mais limiter les stratégies d'optimisation et affecter la qualité du modèle quantifié.

  • La valeur par défaut est workspace=None, ce qui permet à TensorRT d'allouer automatiquement la mémoire. En cas de configuration manuelle, il peut être nécessaire d'augmenter cette valeur si la calibration échoue (s'arrête 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 qu'il faut réduire la valeur de workspace ou la définir sur None.

  • Si workspace est défini sur la valeur maximale et que la calibration échoue ou se termine brutalement, envisage d'utiliser None pour l'allocation automatique ou de réduire les valeurs de imgsz et batch afin de diminuer les besoins en mémoire.

  • N'oublie pas que la calibration INT8 est propre à chaque appareil : emprunter un GPU « haut de gamme » pour la calibration peut entraîner de mauvaises performances lorsque l'inférence est exécutée sur un autre appareil.

• batch : taille maximale des lots utilisée pour l'inférence. Des lots plus petits peuvent être utilisés pendant l'inférence, mais celle-ci n'acceptera aucun lot plus grand que la valeur spécifiée.

Des expérimentations menées par NVIDIA l'ont incité à recommander d'utiliser au moins 500 images d'étalonnage représentatives des données de ton modèle, avec l'étalonnage 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 bons résultats pour ton jeu de données. Étant donné que les données d'étalonnage sont requises pour l'étalonnage INT8 avec TensorRT, assure-toi d'utiliser l'argument data lors de l'exportation d'un point de contrôle qui n'a pas été entraîné avec quantize=8 (quantification post-entraînement) à quantize=8 pour TensorRT, et utilise data="my_dataset.yaml", qui utilisera les images de la validation pour procéder à l'étalonnage. Un point de contrôle entraîné avec quantize=8 ignore l'étalonnage, tu dois donc omettre data pour celui-ci. Lorsqu'aucune valeur n'est transmise pour data lors de l'exportation vers TensorRT avec la quantification INT8, l'option par défaut consistera à utiliser l'un des jeux 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("yolo26n.pt")
model.export(
    format="engine",
    dynamic=True,  # (1)!
    batch=8,  # (2)!
    workspace=4,  # (3)!
    quantize=8,
    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 réduite du modèle : la quantification de FP32 vers INT8 peut réduire la taille du modèle d'un facteur 4 (sur le disque ou en mémoire), ce qui accélère les téléchargements, réduit les besoins de stockage et diminue l'empreinte mémoire lors du déploiement d'un modèle.

• Consommation électrique réduite : les opérations à précision réduite des modèles YOLO exportés en INT8 peuvent consommer moins d'énergie que les modèles FP32, notamment sur 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 accélérer l'inférence sur les GPU, les appareils embarqués et les accélérateurs.

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

• Baisse 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 risque d'être quelque peu moins bonne. Les couches Sigmoid sont conservées à une précision supérieure pour préserver la calibration des scores, mais INT8 peut malgré tout modifier les valeurs de confiance ; sélectionne donc le seuil de fonctionnement à partir de la propre courbe F1 du modèle INT8. Consulte 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 différents appareils.

• Temps de développement accru : trouver les paramètres « optimaux » pour la calibration INT8 selon le jeu de données et l'appareil peut nécessiter de nombreux tests.

• Dépendance au matériel : la calibration et les gains de performance peuvent dépendre fortement du matériel, et les poids des modèles sont moins transférables.

Performances de l'exportation Ultralytics YOLO vers TensorRT#

NVIDIA A100#

GPU grand public#

Appareils embarqués#

Méthodes d'évaluation#

Déplie les sections ci-dessous pour savoir comment 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, quantize=16)

# 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, quantize=8, 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éployer des modèles YOLO26 exportés au format TensorRT#

Après avoir exporté avec succès tes modèles Ultralytics YOLO26 au format TensorRT, tu peux maintenant les déployer. Pour obtenir des instructions détaillées sur le déploiement de tes modèles TensorRT dans différents environnements, consulte les ressources suivantes :

• Déployer Ultralytics avec un serveur Triton : notre guide explique comment utiliser le serveur NVIDIA Triton Inference (anciennement TensorRT Inference) spécifiquement avec les modèles Ultralytics YOLO.

• Déployer des 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 équipés de NVIDIA : déploiement avec NVIDIA TensorRT : cet article de blog explique comment utiliser NVIDIA TensorRT pour optimiser et déployer des modèles d'IA sur des PC équipés de NVIDIA.

• Dépôt GitHub pour NVIDIA TensorRT : C'est 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 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 YOLO26, afin de les rendre 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 souhaites découvrir d'autres intégrations Ultralytics YOLO26, notre page du guide des intégrations propose une vaste sélection de ressources informatives et d'informations détaillées.

FAQ#