TensorRT Exportation pour les modèles YOLOv8

Le déploiement de modèles de vision par ordinateur dans des environnements très performants 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 améliorer tes modèles pour une inférence rapide et efficace sur le matériel NVIDIA. Ultralytics YOLOv8 modèles pour une inférence rapide et efficace sur le matériel NVIDIA. Ce guide te donnera des étapes faciles à suivre pour le processus de conversion et t'aidera à 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 l'inférence d'apprentissage profond à grande vitesse. Il est bien 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 et permet d'obtenir des opérations plus rapides et plus efficaces. Les modèles TensorRT subissent une optimisation TensorRT , qui comprend des techniques telles que la fusion des couches, l'étalonnage de la précision (INT8 et FP16), la gestion dynamique de la mémoire tensor et l'auto-tuning du noyau. 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 connu pour sa compatibilité avec divers formats de modèles, notamment TensorFlow, PyTorch, et ONNX, offrant aux développeurs une solution flexible pour l'intégration et l'optimisation de modèles provenant de différents cadres. Cette polyvalence permet un déploiement efficace des modèles dans divers environnements matériels et logiciels.

Caractéristiques principales des modèles TensorRT

TensorRT Les modèles offrent une gamme de caractéristiques clés qui contribuent à leur efficacité et à leur efficience dans l'inférence d'apprentissage profond à grande vitesse :

• Étalonnage de précision: TensorRT prend en charge l'étalonnage de précision, ce qui permet d'affiner les modèles en fonction d'exigences spécifiques en matière de précision. Cela inclut la prise en charge des formats de précision réduite tels que INT8 et FP16, qui permettent d'augmenter la vitesse d'inférence tout en maintenant des niveaux de précision acceptables.

• Fusion de couches: Le processus d'optimisation TensorRT comprend la fusion des couches, où plusieurs couches d'un réseau neuronal sont combinées en une seule opération. Cela permet de réduire la surcharge de calcul et d'améliorer la vitesse d'inférence en minimisant l'accès à la mémoire et les calculs.

• Gestion dynamique de la mémoire de Tensor : TensorRT gère efficacement l'utilisation de la mémoire de tensor pendant l'inférence, en réduisant la surcharge de la mémoire et en optimisant l'allocation de la mémoire. Il en résulte une utilisation plus efficace de la mémoire du GPU.

• Réglage automatique du noyau : TensorRT applique le réglage automatique du noyau 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 d'examiner le code permettant d'exporter les modèles YOLOv8 au format TensorRT , comprenons où les modèles TensorRT sont normalement utilisés.

TensorRT offre 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 dans TensorFlow: Cette méthode intègre TensorRT dans TensorFlow, ce qui permet aux modèles optimisés de fonctionner dans un environnement TensorFlow familier. Elle est utile pour les modèles comportant 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 dont les performances sont critiques. Elle est plus complexe mais permet la mise en œuvre personnalisée d'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, elle offre des fonctionnalités telles que l'exécution de modèles simultanés et l'analyse de modèles.

Exporter les modèles YOLOv8 vers TensorRT

Tu peux améliorer l'efficacité de l'exécution et optimiser les performances en convertissant les modèles YOLOv8 au format TensorRT .

Installation

Pour installer le paquetage requis, exécute :

# Install the required package for YOLOv8
pip install ultralytics

Pour des instructions détaillées et les meilleures pratiques liées au processus d'installation, consulte notre guide d'installationYOLOv8 . Pendant l'installation des paquets requis pour YOLOv8, si tu rencontres des difficultés, consulte notre guide des problèmes courants pour trouver des solutions et des conseils.

Utilisation

Avant de te plonger dans les instructions d'utilisation, n'oublie pas de consulter la gamme de modèlesYOLOv8 proposée par Ultralytics. Cela t'aidera à choisir le modèle le plus approprié aux exigences de ton projet.

from ultralytics import YOLO

# Load the YOLOv8 model
model = YOLO('yolov8n.pt')

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

# Load the exported TensorRT model
tensorrt_model = YOLO('yolov8n.engine')

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

# Export a YOLOv8n PyTorch model to TensorRT format
yolo export model=yolov8n.pt format=engine  # creates 'yolov8n.engine''

# Run inference with the exported model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'

Pour plus de détails sur le processus d'exportation, visite la page de documentationUltralytics sur l'exportation.

Exporter TensorRT avec la quantification INT8

L'exportation des modèles Ultralytics YOLO à l'aide de TensorRT avec une précision INT8 exécute la quantification post-entraînement (PTQ). TensorRT utilise le calibrage pour PTQ, qui mesure la distribution des activations au sein de chaque activation tensor lorsque le modèle YOLO traite l'inférence sur des données d'entrée représentatives, et utilise ensuite cette distribution pour estimer les valeurs d'échelle pour chaque tensor. Chaque activation tensor candidate à la quantification a une échelle associée qui est déduite par un processus d'étalonnage.

Lors du traitement de réseaux implicitement quantifiés, 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 que des échelles de quantification ont été attribuées à ses entrées et sorties de données, un noyau avec une précision INT8 est attribué à cette couche. Sinon, TensorRT sélectionne une précision FP32 ou FP16 pour le noyau en fonction de celle qui permet d'obtenir un temps d'exécution plus rapide pour cette couche.

Configuration de l'exportation INT8

Les arguments fournis lors de l'utilisation de exporter pour un modèle Ultralytics YOLO grandement influencent les performances du modèle exporté. Ils devront également être sélectionnés en fonction des ressources de l'appareil disponibles, cependant les arguments par défaut. doit fonctionne pour la plupart GPU discrets NVIDIA Ampere (ou plus récents). L'algorithme de calibrage utilisé est "ENTROPY_CALIBRATION_2" et tu peux lire plus de détails sur les options disponibles dans le guide du développeur TensorRT. Ultralytics Les tests ont révélé que "ENTROPY_CALIBRATION_2" était le meilleur choix et les exportations sont fixées à l'utilisation de cet algorithme.

• workspace : Contrôle la taille (en GiB) de l'allocation de la mémoire du périphérique lors de la conversion des poids du modèle.

  • Vise à utiliser le minimum workspace valeur requise, car cela empêche de tester des algorithmes qui nécessitent plus de workspace d'être pris en compte par le constructeur TensorRT . En fixant une valeur plus élevée pour workspace peut prendre considérablement plus long pour calibrer et exporter.

  • La valeur par défaut est workspace=4 (GiB), il se peut que cette valeur doive être augmentée si l'étalonnage se bloque (se termine sans avertissement).

  • TensorRT rapportera UNSUPPORTED_STATE lors de l'exportation si la valeur de workspace est plus grande que la mémoire dont dispose l'appareil, ce qui signifie que la valeur de workspace doit être abaissée.

  • Si workspace est réglée sur la valeur maximale et que l'étalonnage échoue, envisage de réduire les valeurs de imgsz et batch pour réduire les besoins en mémoire.

  • N'oublie pas que l'étalonnage pour INT8 est spécifique à chaque appareil, emprunter un GPU "haut de gamme" pour l'étalonnage peut entraîner des performances médiocres lorsque l'inférence est exécutée sur un autre appareil.

• batch : La taille maximale du lot 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é.

  Note

  Pendant l'étalonnage, deux fois la batch La taille fournie sera utilisée. L'utilisation de petits lots peut entraîner une mise à l'échelle inexacte lors de l'étalonnage. En effet, le processus s'ajuste en fonction des données qu'il voit. Les petits lots risquent de ne pas saisir toute la gamme des valeurs, ce qui entraînera des problèmes lors de l'étalonnage final. batch est automatiquement doublée. Si aucune taille de lot n'est spécifiée batch=1L'étalonnage sera effectué à batch=1 * 2 pour réduire les erreurs d'échelle d'étalonnage.

L'expérimentation de NVIDIA les a conduits à recommander d'utiliser au moins 500 images de calibration représentatives des données de ton modèle, avec une calibration de quantification INT8. Il s'agit d'une ligne directrice et non d'une dur exigence, et tu devras expérimenter ce qui est nécessaire pour obtenir de bons résultats avec ton ensemble de données. Comme les données d'étalonnage sont nécessaires pour l'étalonnage de l'INT8 avec TensorRT, assure-toi d'utiliser l'option data argument lorsque int8=True pour TensorRT et utilise data="my_dataset.yaml"qui utilisera les images de validation pour l'étalonnage. Si aucune valeur n'est transmise pour data avec l'exportation vers TensorRT avec une quantification INT8, la valeur par défaut sera d'utiliser l'une des options suivantes "petits" ensembles de données d'exemple basés sur la tâche du modèle. au lieu de provoquer une erreur.

from ultralytics import YOLO

model = YOLO("yolov8n.pt")
model.export(
    format="engine",
    dynamic=True, #(1)!
    batch=8, #(2)!
    workspace=4, #(3)!
    int8=True,
    data="coco.yaml", #(4)!
)

model = YOLO("yolov8n.engine", task="detect") # load the model

Avantages de l'utilisation de YOLO avec TensorRT INT8

• Taille réduite du modèle : La quantification de FP32 à INT8 peut réduire la taille du modèle par 4 (sur disque ou en mémoire), ce qui permet d'accélérer les temps de téléchargement, de réduire les besoins en stockage et de réduire l'empreinte mémoire 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 par INT8 peuvent consommer moins d'énergie que les modèles FP32, en particulier pour les appareils alimentés par batterie.

• Vitesse d'inférence améliorée : TensorRT optimise le modèle pour le matériel cible, ce qui permet d'accélérer la vitesse d'inférence sur les GPU, les appareils embarqués et les accélérateurs.

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

• Diminution des paramètres d'évaluation : L'utilisation d'une précision inférieure signifie que mAP, Precision, Recall ou tout autre autre mesure utilisée pour évaluer la performance du modèle est probablement un peu pire. Voir les Section des résultats de performance pour comparer les différences entre les mAP50 et mAP50-95 lors de l'exportation avec INT8 sur un petit échantillon de divers appareils.

• Augmentation des temps de développement : Trouver les paramètres "optimaux" pour l'étalonnage de l'INT8 en fonction de l'ensemble de données et de l'appareil peut nécessiter un nombre important de tests.

• Dépendance à l'égard du matériel : L'étalonnage et les gains de performance pourraient dépendre fortement du matériel et les poids des modèles sont moins transférables.

Ultralytics YOLO TensorRT Performances à l'exportation

NVIDIA A100

GPU grand public

Appareils embarqués

Mé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("yolov8n.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
out = model.export(
    format="engine",
    imgsz:640,
    dynamic:True,
    verbose:False,
    batch:8,
    workspace:2,
    int8=True,
    data:"data.yaml"  # COCO, ImageNet, or DOTAv1 for appropriate model task
)

import cv2
from ultralytics import YOLO

model = YOLO("yolov8n.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("yolov8n.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 des modèles exportés YOLOv8 TensorRT

Après avoir exporté avec succès tes modèles Ultralytics YOLOv8 au format TensorRT , tu es maintenant prêt à les déployer. Pour obtenir des instructions détaillées sur le déploiement de tes modèles TensorRT dans différents contextes, jette un coup d'œ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 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 le GPU.

• L'IA de bout en bout pour les PC basés sur 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 basés sur NVIDIA.

• Dépôt GitHub pour NVIDIA TensorRT:: Ceci est le dépôt GitHub officiel qui contient le code source et la documentation de NVIDIA TensorRT.

Résumé

Dans ce guide, nous nous sommes concentrés sur la conversion des modèles Ultralytics YOLOv8 au format de modèle TensorRT de NVIDIA. Cette étape de conversion est cruciale pour améliorer l'efficacité et la rapidité des modèles YOLOv8 , ce qui les rend plus efficaces et adaptés à divers environnements de déploiement.

Pour plus d'informations sur les détails d'utilisation, jette un coup d'œil à la documentation officielle deTensorRT .

Si tu es curieux de connaître d'autres intégrations de Ultralytics YOLOv8 , notre page de guide d'intégration fournit une vaste sélection de ressources et d'informations.

Commentaires