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é. C’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 effectuer des inférences rapides et efficaces sur du matériel NVIDIA. Ce guide te propose des étapes simples à suivre pour le processus de conversion et t’aide à tirer le meilleur parti de la technologie avancée de NVIDIA dans tes projets d’apprentissage profond.

TensorRT#

TensorRT, développé par NVIDIA, est un kit de développement logiciel (SDK) avancé conçu pour effectuer des inférences d’apprentissage profond à grande vitesse. Il est parfaitement adapté aux applications en temps réel comme la détection d’objets.

Cette boîte à outils optimise les modèles d’apprentissage profond pour les GPU NVIDIA, ce qui accélère et améliore l’efficacité des opérations. Les modèles TensorRT sont optimisés par TensorRT grâce à des techniques comme la fusion de couches, l’étalonnage de la précision (INT8 et FP16), la gestion dynamique de la mémoire des tenseurs et le réglage automatique des noyaux. La conversion des modèles d’apprentissage profond au format TensorRT permet aux développeurs d’exploiter pleinement le potentiel des GPU NVIDIA.

TensorRT est reconnu pour sa compatibilité avec différents formats de modèles, notamment TensorFlow, PyTorch et ONNX. Il offre 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.

Principales fonctionnalités des modèles TensorRT#

Les modèles TensorRT offrent plusieurs fonctionnalités clés qui contribuent à leur efficacité et à leurs performances pour les inférences d’apprentissage profond à grande vitesse :

• Étalonnage de la précision : TensorRT prend en charge l’étalonnage de la précision, ce qui permet d’ajuster finement les modèles selon des exigences précises en matière de précision. Cette fonctionnalité prend en charge des formats à précision réduite comme INT8 et FP16, qui peuvent accélérer davantage l’inférence tout en maintenant un niveau de précision acceptable.

• Fusion de couches : Le processus d’optimisation de TensorRT inclut la fusion de couches, qui combine plusieurs couches d’un réseau neuronal en une seule opération. Cela réduit la charge de calcul et accélère l’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 son allocation. Les GPU utilisent ainsi leur mémoire plus efficacement.

• Réglage automatique des noyaux : TensorRT règle automatiquement les noyaux afin de 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 avec TensorRT#

Avant d’examiner le code permettant d’exporter des modèles YOLO26 au format TensorRT, voyons les usages habituels des modèles TensorRT.

TensorRT propose plusieurs options de déploiement, qui concilient différemment la facilité d’intégration, l’optimisation des performances et la flexibilité :

• Déploiement dans TensorFlow : Cette méthode intègre TensorRT à TensorFlow et permet d’exécuter des modèles optimisés dans un environnement TensorFlow familier. Elle est utile pour les modèles qui combinent des couches prises en charge et non prises en charge, car TF-TRT peut traiter efficacement ces dernières.

• API d’exécution TensorRT autonome : Elle offre un contrôle précis et convient parfaitement aux applications où les performances sont critiques. Elle est plus complexe, mais permet une implémentation personnalisée des opérateurs non pris en charge.

• Serveur d’inférence NVIDIA Triton : Cette option prend en charge les modèles issus de différents frameworks. Particulièrement adaptée à l’inférence dans le cloud ou en périphérie, elle offre des fonctionnalités comme l’exécution simultanée de modèles et leur analyse.

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 qui inclut ces têtes.

Exporter 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 des bonnes pratiques sur le 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, pense à découvrir 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, Prédiction et Validation. L’inférence et la validation nécessitent un GPU NVIDIA. Exporte ton modèle, puis charge le modèle exporté pour effectuer des inférences ou valider sa précision.

from ultralytics import YOLO

# Charger un modèle YOLO26
model = YOLO("yolo26n.pt")

# Exporter le modèle au format TensorRT
model.export(format="engine")  # crée 'yolo26n.engine'

from ultralytics import YOLO

# Charger le modèle TensorRT exporté
model = YOLO("yolo26n.engine")

# Exécuter l’inférence
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Charger le modèle TensorRT exporté
model = YOLO("yolo26n.engine")

# Valider la précision sur le jeu de données COCO8
metrics = model.val(data="coco8.yaml")

Arguments d’exportation#

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

Exporter vers TensorRT avec une quantification INT8#

L’export de modèles Ultralytics YOLO avec TensorRT et une précision INT8 effectue une quantification après entraînement (PTQ). Pour la PTQ, TensorRT procède à un étalonnage qui mesure la distribution des activations dans chaque tenseur d’activation lorsque le modèle YOLO effectue des inférences sur des données d’entrée représentatives. Il utilise ensuite cette distribution pour estimer les valeurs d’échelle de chaque tenseur. Chaque tenseur d’activation candidat à la quantification est associé à une échelle déterminée par un processus d’étalonnage. Un point de contrôle affiné avec quantize=8 au moyen de l’entraînement sensible à la quantification contient déjà ses plages INT8 ; son export les utilise donc sans effectuer d’étalonnage.

Lors du traitement de réseaux quantifiés de manière implicite, TensorRT utilise INT8 de façon opportuniste pour optimiser le temps d’exécution des couches. Si une couche s’exécute plus rapidement en INT8 et que ses entrées et sorties de données disposent d’échelles de quantification, un noyau en précision INT8 lui est attribué. Dans le cas contraire, TensorRT sélectionne pour le noyau une précision FP32 ou FP16, selon celle qui permet à la couche de s’exécuter le plus rapidement.

Configurer l’export INT8#

Les arguments utilisés lors de l’export d’un modèle Ultralytics YOLO influencent considérablement les performances du modèle exporté. Il faut également les choisir en fonction des ressources disponibles sur l’appareil ; toutefois, les arguments par défaut devraient convenir à la plupart des GPU NVIDIA discrets Ampere ou plus récents. L’algorithme d’étalonnage utilisé est "MINMAX_CALIBRATION" pour les exports sur GPU, tandis que les exports DLA sur NVIDIA Jetson utilisent "ENTROPY_CALIBRATION_2". Pour en savoir plus sur les options disponibles, consulte le guide du développeur TensorRT. Les tests d’Ultralytics ont montré que "MINMAX_CALIBRATION" est le meilleur choix pour les exports sur GPU ; l’algorithme est sélectionné automatiquement en fonction de l’appareil cible de l’export.

• workspace : Contrôle la taille, en Gio, de l’allocation de mémoire de l’appareil pendant la conversion des poids du modèle.

  • Ajuste la valeur de workspace en fonction de tes besoins d’étalonnage et des ressources disponibles. Une valeur plus élevée pour workspace peut prolonger l’étalonnage, mais permet à TensorRT d’explorer un plus large éventail 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 pour workspace peut réduire la durée de l’étalonnage, mais limiter les stratégies d’optimisation et nuire à la qualité du modèle quantifié.

  • La valeur par défaut est workspace=None, ce qui permet à TensorRT d’allouer automatiquement la mémoire. Si tu configures cette valeur manuellement, il peut être nécessaire de l’augmenter si l’étalonnage plante (s’arrête sans avertissement).

  • Pendant l’export, TensorRT signale UNSUPPORTED_STATE si la valeur de workspace dépasse la mémoire disponible sur l’appareil. Dans ce cas, tu dois réduire la valeur de workspace ou la définir sur None.

  • Si workspace est défini sur la valeur maximale et que l’étalonnage échoue ou plante, essaie None pour l’allocation automatique ou réduis les valeurs de imgsz et batch afin de diminuer les besoins en mémoire.

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

• batch : Taille maximale de lot utilisée pour l’inférence. Avec dynamic=True, des lots plus petits peuvent être utilisés pendant l’inférence, mais celle-ci n’acceptera pas de lots plus grands que la taille indiquée.

À l’issue de leurs expérimentations, NVIDIA recommande d’utiliser au moins 500 images d’étalonnage représentatives des données du modèle pour l’étalonnage de la quantification INT8. Il s’agit d’une recommandation et non d’une exigence stricte ; tu devras expérimenter pour déterminer ce qui convient à ton jeu de données. Comme les données d’étalonnage sont nécessaires à l’étalonnage INT8 avec TensorRT, veille à utiliser l’argument data lors de l’export vers TensorRT à quantize=8 d’un point de contrôle qui n’a pas été entraîné avec quantize=8 (quantification après entraînement), et utilise data="my_dataset.yaml" pour l’étalonnage avec les images de validation. Un point de contrôle entraîné avec quantize=8 ne nécessite pas d’étalonnage ; omets donc data. Si aucune valeur n’est transmise pour data lors d’un export vers TensorRT avec quantification INT8, le jeu de données utilisé par défaut sera l’un des petits jeux de données d’exemple correspondant à la tâche du modèle, plutôt qu’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)!
)

# Charger le modèle TensorRT INT8 exporté
model = YOLO("yolo26n.engine", task="detect")

# Exécuter l’inférence
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 par 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, en particulier sur les appareils alimentés par batterie.

• Inférence plus rapide : 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 : Une précision plus faible signifie que mAP, Precision, Recall ou toute autre métrique utilisée pour évaluer les performances du modèle risque d’être légèrement moins bonne. Les couches Sigmoid conservent une précision plus élevée afin de préserver l’étalonnage des scores, mais INT8 peut tout de même modifier les valeurs de confiance ; choisis donc le seuil de fonctionnement à partir de la propre courbe F1 du modèle INT8. Consulte la section des résultats de performances pour comparer les différences de mAP50 et mAP50-95 lors d’une exportation en INT8 sur un petit échantillon de différents appareils.

• Temps de développement accrus : Trouver les paramètres « optimaux » pour l’étalonnage INT8 du jeu de données et de l’appareil peut nécessiter de nombreux tests.

• Dépendance au matériel : L’étalonnage et les gains de performances peuvent dépendre fortement du matériel, et les poids du modèle 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 avec `data` d’étalonnage (c.-à-d. COCO, ImageNet ou DOTAv1 selon la tâche du modèle)
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 de la même image
        verbose=False,
        device="cuda",
    )

from ultralytics import YOLO

model = YOLO("yolo26n.engine")
results = model.val(
    data="data.yaml",  # COCO, ImageNet ou DOTAv1 selon la tâche du modèle
    batch=1,
    imgsz=640,
    verbose=False,
    device="cuda",
)

Déploiement des modèles YOLO26 exportés vers TensorRT#

Après avoir exporté 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 équipées de GPU.

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

• Dépôt GitHub de NVIDIA TensorRT : il s’agit du dépôt GitHub officiel contenant le code source et la documentation de NVIDIA TensorRT.

Résumé#

Dans ce guide, nous avons présenté la conversion des modèles Ultralytics YOLO26 au format de modèle NVIDIA TensorRT. 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 mieux adaptés à divers environnements de déploiement.

Pour plus de détails sur l’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 un large choix de ressources et d’informations utiles.

FAQ#