Exportation TensorRT pour les modèles YOLO26#

Déployer des 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 donne 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 de deep learning à haute vitesse. Il est particulièrement bien adapté aux applications en temps réel comme l'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 dans divers environnements matériels et logiciels.

Caracté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.

• Layer Fusion : Le processus d'optimisation de 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 de calcul 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.

Options 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 au sein de TensorFlow : Cette méthode intègre TensorRT dans TensorFlow, permettant aux modèles optimisés de s'exécuter dans un environnement TensorFlow familier. Elle est utile pour les modèles comprenant 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.

Tâches prises en charge#

L'exportation TensorRT prend en charge l'ensemble des sept tâches Ultralytics. La segmentation sémantique et l'estimation de la profondeur ne sont disponibles qu'avec YOLO26, la seule famille qui intègre ces têtes.

Exporter 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 concernant le processus d'installation, consulte notre YOLO26 Installation guide. Si tu rencontres des difficultés lors de l'installation des packages requis pour YOLO26, consulte notre Common Issues guide pour trouver des solutions et des astuces.

Utilisation#

Avant de te lancer dans les instructions d'utilisation, assure-toi de découvrir la gamme de YOLO26 models offered by Ultralytics. Cela t'aidera à choisir le modèle le plus 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, visite la page de documentation d'Ultralytics sur l'exportation.

Exporter TensorRT avec quantification INT8#

L'exportation de modèles Ultralytics YOLO utilisant TensorRT avec une précision 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 possède une échelle associée 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.

Configurer l'exportation INT8#

Les arguments fournis lors de l'utilisation de l'exportation pour un modèle Ultralytics YOLO influenceront fortement les performances du modèle exporté. Ils devront également être sélectionnés en fonction des ressources de l'appareil disponibles, bien que les arguments par défaut doivent 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 Gio) de l'allocation de mémoire de l'appareil lors de la conversion des poids du modèle.

  • Ajuste la valeur de 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 un plus large éventail 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 de la mémoire. En cas de configuration manuelle, cette valeur peut devoir être augmentée si la calibration plante (quitte 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 abaissée ou définie sur None.

  • Si workspace est défini sur la valeur maximale et que la calibration échoue ou plante, envisage d'utiliser None pour l'allocation automatique ou en réduisant les valeurs de imgsz et batch pour diminuer 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 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 supérieurs à celui spécifié.

Des expérimentations menées par NVIDIA les ont amenés à recommander d'utiliser au moins 500 images de calibration représentatives des données de 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 sur ton jeu de données. Étant donné que les données de calibration sont requises pour la calibration INT8 avec TensorRT, assure-toi d'utiliser l'argument data lorsque quantize=8 pour TensorRT et d'utiliser data="my_dataset.yaml", ce qui utilisera les images de validation pour la calibration. Lorsqu'aucune valeur n'est transmise pour data lors de l'exportation vers TensorRT avec 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 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.

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

• Baisse des métriques d'évaluation : Utiliser 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. Les couches sigmoïdes sont maintenues à une précision plus élevée pour préserver la calibration des scores, mais l'INT8 peut tout de même décaler les valeurs de confiance, alors choisis le seuil opérationnel à partir de la courbe F1 du modèle INT8 lui-même. Consulte la section Résultats de performance pour comparer les différences entre mAP50 et mAP50-95 lors d'une 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.

Performances d'exportation Ultralytics YOLO TensorRT#

NVIDIA A100#

GPU grand public#

Appareils embarqués#

Mé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, 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é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 la façon d'utiliser le serveur d'inférence Triton de NVIDIA (anciennement TensorRT Inference Server) spécifiquement pour une utilisation avec 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 plates-formes de déploiement basées sur GPU.

• IA de bout en bout pour les PC équipés par 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 par NVIDIA.

• Répertoire GitHub pour NVIDIA TensorRT : : Il s'agit du 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 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 d'en savoir plus sur les autres intégrations d'Ultralytics YOLO26, notre page de guide d'intégration propose une vaste sélection de ressources et d'informations utiles.

FAQ#