Commencer

Export TensorRT pour les modèles YOLO26

TensorRT est le SDK de NVIDIA pour l’inférence rapide en deep learning. L’exportation d’un modèle Ultralytics YOLO26 avec format="engine" crée un fichier .engine optimisé pour le GPU NVIDIA sur lequel il a été créé, en précision FP32, FP16 ou INT8.

Les moteurs TensorRT dépendent du matériel et de l’environnement d’exécution

TensorRT optimise un moteur pour le GPU sur lequel il est créé. Crée le moteur sur le GPU de déploiement ou sur un GPU du même modèle, avec la même version de TensorRT ; un fichier .engine n’est pas un format de modèle portable. Pour le déploiement en périphérie, Ultralytics Platform propose huit cibles Jetson, avec l’état des tests et de la validation sur du matériel physique documenté pour chacune. Tu peux aussi effectuer l’exportation localement sur l’appareil de destination.

En bref#

PropriétéDétails
Argument formatengine (alias : tensorrt, trt)
Sortieyolo26n.engine, un seul fichier qui commence par un en-tête de métadonnées JSON (noms de classes, tâche, taille d’image). Le fichier intermédiaire yolo26n.onnx reste à côté
Fonctionne surGPU NVIDIA : centre de données, station de travail et Jetson, y compris les cœurs DLA Jetson (pas avec TensorRT 11)
Environnement d’exécutionTensorRT 7.0 ou version ultérieure (10.2.0 n’est pas pris en charge)
PrécisionFP32, FP16, INT8
Machine d’exportationUne machine équipée d’un GPU NVIDIA et de CUDA. Effectue la création sur le GPU de déploiement ou sur un GPU du même modèle
Exporter dans le cloud

Ultralytics Platform peut créer un moteur TensorRT pour toi sur le type de GPU que tu sélectionnes, y compris les cibles NVIDIA Jetson, sans nécessiter d’environnement d’exportation local.

Démarrage rapide#

Installe le paquet Ultralytics sur une machine équipée d’un GPU NVIDIA et de CUDA. Sous Linux, si le paquet Python TensorRT correspondant à ta version de CUDA est absent, la première exportation l’installe. Sur NVIDIA Jetson, utilise la version de TensorRT fournie avec JetPack. Sous Windows, installe TensorRT toi-même avant l’exportation.

pip install ultralytics

Pour les autres méthodes d’installation, consulte le guide d’installation. Ensuite, exporte ton modèle et charge le moteur exporté pour exécuter l’inférence ou valider sa précision. L’inférence et la validation nécessitent un GPU NVIDIA. La création d’un moteur YOLO26n prend une à trois minutes sur un NVIDIA T4.

Export
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'

# Ou exporte plutôt un moteur FP16
model.export(format="engine", quantize=16)  # crée 'yolo26n.engine'
Prédiction
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")
Valider
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")

Tâches prises en charge#

L’exportation TensorRT prend en charge les sept tâches Ultralytics avec les modèles YOLOv8, YOLO11 et YOLO26 : détection, segmentation, segmentation sémantique, estimation de profondeur, classification, estimation de pose et OBB. La segmentation sémantique et l’estimation de profondeur sont uniquement disponibles avec YOLO26, la seule famille qui intègre ces têtes.

Arguments d’exportation#

ArgumentTypeValeur par défautDescription
formatstr'engine'Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement.
imgszint ou tuple640Taille d’image souhaitée pour l’entrée du modèle. Peut être un entier pour les images carrées ou un tuple (height, width) pour définir des dimensions spécifiques.
quantizeint ou strNonePrécision de quantification : 16 (FP16) ou 8 (INT8/PTQ ; nécessite un jeu data/fraction pour l’étalonnage) ; 32/non défini correspond à FP32. Un point de contrôle entraîné avec quantize=8 exporte en INT8 à partir des plages qu’il contient, sans étalonnage, même si quantize n’est pas défini ; quantize=16 ou quantize=32 provoque une erreur. Remplace les options obsolètes half/int8.
dynamicboolFalseCrée un moteur qui accepte des tailles de lot de 1 à batch et des tailles d’image de 32 pixels à deux fois imgsz ; la taille minimale est supérieure pour les moteurs INT8 dynamiques sur les anciens GPU. Lorsque False est défini, le moteur n’accepte que les valeurs d’exportation batch et imgsz.
simplifyboolTrueSimplifie le graphe du modèle avec onnxslim, ce qui peut améliorer les performances et la compatibilité.
opsetintNoneIndique la version de l'opset ONNX pour le graphe ONNX intermédiaire. Si elle n'est pas définie, utilise l'opset 18 (une version inférieure avec PyTorch < 2.4), sans dépasser la version onnx installée.
workspacefloat ou NoneNoneLimite supérieure, en Gio, de la mémoire utilisée par TensorRT lors de la création du moteur. Laisse la valeur None pour que TensorRT alloue automatiquement la mémoire.
nmsbool, facultatifNoneChoisis la sortie brute (None, par défaut), la NMS intégrée (True) ou la tête sans NMS (False). Avec nms=True, conf (0.25 par défaut), iou, max_det et agnostic_nms sont fixés lors de l’exportation ; nms=True est ignoré pour les modèles de segmentation sémantique et de profondeur, et provoque une erreur pour les modèles de classification.
batchint1Taille de lot du moteur, ou taille de lot maximale avec dynamic=True. Il s’agit également de la taille de lot utilisée pour l’étalonnage INT8.
datastrNoneChemin vers le fichier YAML du jeu de données, utilisé pour l’étalonnage INT8 ; pour la classification, il faut plutôt fournir un répertoire de jeu de données ou le nom d’un jeu de données intégré. L’étalonnage utilise la partition val, sauf si split est défini. Si cette valeur est omise avec quantize=8, Ultralytics utilise le petit jeu de données par défaut pour la tâche du modèle, par exemple coco8.yaml pour la détection ; un point de contrôle entraîné avec quantize=8 n’en a pas besoin.
fractionfloat, int ou list1.0Sous-ensemble de calibration exprimé en ratio, en nombre d’images ou en listes [train, val, test] de ratios/de nombres. Les listes de deux éléments laissent test complet, tandis que 0 l’ignore.
devicestrNoneIndique l’appareil utilisé pour l’exportation : GPU (device=0, utilisé si la valeur n’est pas définie), DLA pour NVIDIA Jetson (device=dla:0 ou device=dla:1, avec quantize=16 ou quantize=8).
Compatibilité avec JetPack et DLA

Sur NVIDIA Jetson, Ultralytics effectue l’exportation avec l’environnement d’exécution TensorRT de ta version de JetPack. Avec JetPack 7, l’exportation nécessite TensorRT 10.15 ou une version ultérieure, mais antérieure à la version 11. device=dla:0 et device=dla:1 provoquent une erreur avec TensorRT 11. NVIDIA indique que TensorRT 10.7 est la dernière version 10.x compatible avec la prise en charge de DLA, et TensorRT 11.4.1 ajoute la prise en charge de JetPack 7.2.2, qu’Ultralytics n’utilise pas encore.

Pour les arguments communs à tous les formats, consulte la documentation du mode Export.

Exporter vers TensorRT avec une quantification INT8#

quantize=8 crée un moteur INT8 avec une quantification après entraînement (PTQ) : l’export fait passer des images de calibration dans le modèle afin de mesurer la plage de valeurs de chaque tenseur. Un point de contrôle affiné avec quantize=8 grâce à l’entraînement avec prise en compte de la quantification contient déjà ses plages INT8 ; son export ignore donc l’étape de calibration.

Les arguments quantize et data sont identiques pour toutes les versions de TensorRT, mais l’exportation d’un point de contrôle qui n’a pas été entraîné avec quantize=8 fonctionne différemment en interne :

TensorRT 7 à 10TensorRT 11
Méthode INT8Quantification implicite avec l’interface IInt8CalibratorQuantification explicite : NVIDIA ModelOpt insère des nœuds Q/DQ dans le graphe ONNX
Algorithme d’étalonnageMINMAX_CALIBRATION sur GPU, ENTROPY_CALIBRATION_2 pour DLAModelOpt max, exécuté sur le CPU
Images d’étalonnage utiliséesChaque lot complet de la partitionEnviron 512 images dans un ordre aléatoire, ou chaque lot complet d’une partition plus petite
dynamic=True avec quantize=8Non couvert par les tests ; exportation sans dynamic=TruePris en charge
FP16 (quantize=16)Indicateur de génération TensorRTConversion à précision mixte AutoCast de ModelOpt

ModelOpt est installé lors de sa première utilisation. Ultralytics ne réutilise pas de cache d’étalonnage ; chaque exportation effectue donc un nouvel étalonnage. Pour en savoir plus sur les deux méthodes, consulte Working with Quantized Types dans la documentation TensorRT.

Pour un point de contrôle non entraîné avec quantize=8, fournis des images d’étalonnage avec data, par exemple data="my_dataset.yaml". L’étalonnage utilise la partition val de ce jeu de données, sauf si tu définis split, et fraction limite le nombre d’images. NVIDIA recommande au moins 500 images représentatives de tes données de déploiement, et l’exportation affiche un avertissement en dessous de 300. Sans data, l’exportation affiche un avertissement et utilise le petit jeu de données d’exemple correspondant à la tâche du modèle, par exemple coco8.yaml pour la détection. Sa partition de validation contient 4 images, ce qui suffit pour tester l’exportation, mais pas pour étalonner un modèle destiné au déploiement.

Exemple
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Étalonne sur 10 % des images de validation COCO (500 images) ; remplace coco.yaml par ton propre jeu de données
model.export(format="engine", quantize=8, data="coco.yaml", fraction=0.1)

# Charge le moteur INT8 exporté et exécute l’inférence
model = YOLO("yolo26n.engine")
result = model.predict("https://ultralytics.com/images/bus.jpg")

Sur le GPU utilisé pour les tests de performance, les moteurs INT8 étaient 1,04 à 2,3 fois plus rapides que les moteurs FP32, mais ils n’ont surpassé les moteurs FP16 en vitesse que pour trois modèles sur dix. La quantification INT8 a entraîné une baisse de 1,7 à 2,9 points de mAP pour les modèles allant de YOLO26n à YOLO26l, et une baisse bien plus importante pour YOLO26x et YOLO26n-pose. Le moteur INT8 de YOLO26n était plus volumineux que son moteur FP32 (30 Mo contre 11 Mo), tandis que les moteurs des modèles de grande taille étaient plus compacts (53 Mo contre 103 Mo pour YOLO26l). INT8 peut aussi modifier les valeurs de confiance ; choisis donc le seuil de confiance à partir de la courbe F1 propre au moteur INT8. Consulte les tests de performance pour chaque modèle.

Format de sortie#

Le moteur prend une entrée nommée images et renvoie les mêmes sorties que l’exportation ONNX à partir de laquelle il a été créé, à une exception près : avec les versions de TensorRT antérieures à 10, les modèles sémantiques renvoient des scores de classe flottants de forme (batch, classes, height, width) à la place de la carte de classes uint8. Consulte le format de sortie ONNX pour connaître la forme de sortie de chaque tâche et de chaque paramètre nms.

Charger le moteur en dehors d’Ultralytics#

Un fichier .engine Ultralytics n’est pas un moteur TensorRT brut. Il commence par une longueur de 4 octets en little-endian, suivie du nombre d’octets correspondant de métadonnées JSON, puis du moteur sérialisé. La méthode deserialize_cuda_engine de TensorRT renvoie None lorsqu’elle reçoit le fichier complet. Ignore l’en-tête pour charger le moteur avec l’API TensorRT :

import json

import tensorrt as trt

with open("yolo26n.engine", "rb") as f:
    n = int.from_bytes(f.read(4), byteorder="little")  # longueur de l’en-tête de métadonnées
    metadata = json.loads(f.read(n))  # noms de classes, tâche, imgsz, lot, arguments d’exportation
    engine = trt.Runtime(trt.Logger(trt.Logger.WARNING)).deserialize_cuda_engine(f.read())

Lorsqu’un autre outil attend un fichier de moteur TensorRT brut, écris les octets qui suivent l’en-tête dans un nouveau fichier ou crée le moteur dans cet outil à partir du fichier yolo26n.onnx que l’exportation laisse à côté du moteur. Avec TensorRT 11, les exportations FP16 et INT8 étalonnées génèrent également yolo26n.fp16.onnx et yolo26n.int8.onnx ; crée un moteur INT8 dans un autre outil à partir du fichier .int8.onnx. Pour un point de contrôle entraîné avec quantize=8, yolo26n.onnx contient déjà les nœuds Q/DQ et aucun fichier .int8.onnx n’est écrit ; avec TensorRT 11, cette exportation génère yolo26n.fp16.onnx, le même graphe Q/DQ dont les autres couches sont en FP16.

Déployer#

YOLO("yolo26n.engine") charge le moteur avec l’environnement d’exécution Python de TensorRT. Par défaut, le moteur s’exécute sur le GPU 0, même si tu passes device="cpu". Passe device=1 pour l’exécuter sur un autre GPU du même modèle. Un moteur exporté avec device=dla:0 ou device=dla:1 s’exécute sur ce cœur DLA.

Un moteur exporté sans dynamic=True a une forme d’entrée fixe. predict et val utilisent les valeurs d’exportation imgsz et ignorent toute valeur différente de l’argument imgsz. Ultralytics divise les lots plus grands en lots de la taille d’exportation et complète les plus petits ; tu peux donc traiter n’importe quel nombre d’images. Un moteur exporté avec dynamic=True accepte toutes les tailles de lot et d’image comprises dans sa plage et déclenche ValueError: input size ... is outside the TensorRT optimization profile pour une forme qui en sort. Avec nms=True, un lot dépassant la plage est plutôt divisé en lots de la taille d’exportation.

Guides de déploiement#

Limites et dépannage#

  • Les moteurs ne sont pas portables : un moteur est créé pour un modèle de GPU et une version de TensorRT. Recrée-le lorsque tu changes de GPU, de version de TensorRT ou de version de JetPack. Lorsqu’un moteur ne peut pas être chargé, Ultralytics consigne TensorRT model exported with a different version than expected.
  • GPU requis : l’exportation utilise device=0 lorsque device n’est pas défini et échoue avec export running on CPU but must be on GPU pour device=cpu.
  • Le moteur ne se charge pas dans d’autres outils : le fichier .engine commence par un en-tête de métadonnées ; l’API TensorRT ne peut donc pas le lire directement. Consulte Charger le moteur en dehors d’Ultralytics.
  • Version de TensorRT : Ultralytics nécessite TensorRT 7.0.0 ou une version ultérieure. TensorRT 10.2.0 n’est pas pris en charge et l’installation automatique l’ignore. Sur JetPack 7 et les systèmes NVIDIA DGX, l’exportation nécessite TensorRT 10.15 ou une version ultérieure (mais antérieure à la version 11 sur Jetson) et tente de l’installer si la version installée ne respecte pas cette plage.
  • Tête sans NMS avec les anciennes versions de TensorRT : les versions de TensorRT antérieures à 8.5.0 ne peuvent pas créer la tête YOLO26 sans NMS. L’exportation affiche un avertissement et écrit des prédictions brutes qui nécessitent une NMS. Mets TensorRT à niveau vers la version 8.5.0 ou ultérieure pour effectuer l’exportation avec nms=False.
  • INT8 sur JetPack 6 : avec TensorRT 10.3.0 sur JetPack 6, une exportation INT8 avec nms=True échoue, et une exportation INT8 avec nms=False revient aux prédictions brutes. Consulte le guide Jetson pour connaître la solution.
  • INT8 avec TensorRT 10.16 : l’exportation INT8 avec TensorRT 10.16.1 a échoué sur les GPU NVIDIA RTX PRO 6000 Blackwell et RTX 6000D avec Could not find any implementation for node. Sur la RTX PRO 6000 Blackwell, TensorRT 10.13, 10.14, 10.15 et 11.4 ont permis de créer le moteur INT8.
  • DLA : device=dla:0 et device=dla:1 ne fonctionnent que sur NVIDIA Jetson, et uniquement avec quantize=16 ou quantize=8. L’exportation déclenche une erreur avec TensorRT 11. Les couches non prises en charge par DLA s’exécutent sur le GPU.
  • Formes dynamiques : dynamic=True nécessite une taille de lot maximale ; définis donc également batch, par exemple batch=8. Sans cette valeur, l’exportation affiche un avertissement et la taille de lot maximale est de 1. Le moteur accepte des lots de 1 à batch et des tailles d’image de 32 pixels jusqu’à deux fois la valeur d’exportation imgsz. Par exemple, un moteur exporté avec imgsz=320 batch=4 fonctionne à 640 pixels et rejette 704 pixels ou un lot de 6 avec input size ... is outside the TensorRT optimization profile. Combine dynamic=True avec quantize=8 uniquement avec TensorRT 11. Sur les GPU dont la capacité de calcul est de 7.5 ou moins, comme le T4, la taille minimale de ces moteurs INT8 dynamiques est de 64 pixels (128 pour les modèles P6).
  • Taille d’entrée fixe : un moteur exporté sans dynamic=True fonctionne toujours avec la valeur d’exportation imgsz. Le fait de passer une autre valeur imgsz à predict ou val n’a aucun effet ; effectue donc une nouvelle exportation pour modifier la taille d’entrée.
  • Exportation INT8 sans data : sauf si le point de contrôle a été entraîné avec quantize=8, l’exportation effectue l’étalonnage sur le petit jeu de données par défaut de la tâche, qui contient 4 images de validation pour la détection, et affiche un avertissement. Passe data avec des images représentatives ; l’exportation affiche un avertissement en dessous de 300.
  • Premières inférences lentes : les premiers appels avec un nouveau moteur, ou avec une nouvelle valeur imgsz sur un moteur dynamique, prennent plus de temps que les appels suivants.

Pour les autres erreurs, consulte le guide des problèmes courants.

Benchmarks#

La page du modèle YOLO26 répertorie la vitesse TensorRT 10 de chaque modèle sur un GPU NVIDIA T4 pour toutes les tâches, sauf la segmentation sémantique.

Comparaison de FP32, FP16 et INT8#

Les tableaux ci-dessous comparent PyTorch aux moteurs TensorRT 11.4 FP32, FP16 et INT8 de tous les modèles de détection YOLO26, ainsi qu’au modèle YOLO26n pour cinq autres tâches. Toutes les valeurs ont été mesurées sur un seul GPU NVIDIA RTX PRO 6000 Blackwell Server Edition.

Millisecondes par image ; plus la valeur est basse, mieux c’est. Le format le plus rapide pour chaque modèle est en gras ; le moteur YOLO26x INT8 est exclu, car sa précision était instable.

ModèleimgszPyTorchTensorRT FP32TensorRT FP16TensorRT INT8
YOLO26n6402.850.670.480.53
YOLO26s6402.981.150.610.66
YOLO26m6403.292.221.031.08
YOLO26l6404.703.031.491.43
YOLO26x6405.934.312.091.84
YOLO26n-seg6403.180.930.650.72
YOLO26n-sem10241.740.740.450.71
YOLO26n-cls2241.750.290.240.20
YOLO26n-pose6403.390.760.510.59
YOLO26n-obb10244.551.030.640.88
  • FP16 a conservé une précision à moins de 0,1 point de celle de FP32 sur tous les modèles. Pour les modèles de détection, son exécution était 1,4 à 2,2 fois plus rapide que celle du moteur FP32 et 2,8 à 5,9 fois plus rapide que celle de PyTorch.
  • INT8 s'est exécuté avec une latence à moins de 12 % de celle de FP16 sur les modèles de détection, avec une perte de 1,7 à 2,9 mAP sur YOLO26n, YOLO26s, YOLO26m et YOLO26l. Sur ce GPU, il était plus rapide que FP16 uniquement pour YOLO26l, YOLO26x et YOLO26n-cls.
  • La précision de YOLO26x INT8 est tombée entre 25,3 et 38,5 mAP sur trois builds, contre 57,5 en FP32. Le YOLO26n-pose INT8 est passé de 56,7 à 33,4 mAP de pose. Valide chaque moteur INT8 sur tes propres données avant de le déployer.
  • Les moteurs FP32 et FP16 de TensorRT 10.16 pour YOLO26n et YOLO26s ont atteint la même précision que ceux de TensorRT 11.4. Leurs moteurs FP16 étaient environ 7 % plus rapides, et leurs moteurs FP32 4 % à 9 % plus lents que sous TensorRT 11.4.

Pour NVIDIA Jetson et DGX Spark, consulte les benchmarks Jetson et le guide DGX Spark.

Mesures effectuées avec ultralytics 8.4.211, TensorRT 11.4.0, PyTorch 2.15.0 et CUDA 13.2 sur batch=1, le 13 novembre 2026. La latence correspond à l'étape d'inférence rapportée par val et n'inclut ni le prétraitement ni le post-traitement.

À propos de TensorRT#

TensorRT crée un moteur en fusionnant des couches, en sélectionnant le noyau le plus rapide pour chaque couche sur le GPU de build et, en option, en réduisant la précision à FP16 ou INT8. Pour consulter la référence complète, reporte-toi à la documentation TensorRT.

NVIDIA TensorRT connecting deep learning frameworks to NVIDIA data center GPUs, Jetson, and DLA hardware

FAQ#

  • Uniquement sur un GPU du même modèle et avec la même version de TensorRT. Un moteur est créé pour un modèle de GPU et une version de TensorRT spécifiques. Pour partager un fichier entre différents matériels, exporte le modèle au format ONNX, puis crée le moteur sur chaque appareil. Pour NVIDIA Jetson, Ultralytics Platform peut créer des moteurs pour huit cibles Jetson.

  • Commence par FP16 (quantize=16). Cette précision ne nécessite pas de données d'étalonnage et conserve la précision de FP32. Dans les benchmarks réalisés sur un NVIDIA RTX PRO 6000 Blackwell avec TensorRT 11.4, FP16 a réduit la latence de YOLO26s de 1,15 ms à 0,61 ms par image, avec le même résultat de 48,5 mAPval 50-95. INT8 (quantize=8) a atteint 0,66 ms et 46,3 mAPval 50-95 : il n'était donc pas plus rapide que FP16 sur ce GPU et nécessite des données d'étalonnage représentatives, sauf si le checkpoint a été entraîné avec quantize=8. INT8 peut être avantageux sur d'autres matériels : les benchmarks Jetson répertorient les résultats FP16 et INT8 pour les appareils embarqués. Mesure les performances des deux précisions sur ton appareil de déploiement avant de choisir INT8.

  • Exporte avec dynamic=True et définis batch sur la taille maximale de lot que tu prévois d'utiliser. Le moteur accepte alors des lots de 1 à batch images et des tailles d'image allant de 32 pixels à deux fois la valeur d'exportation imgsz, avec un minimum plus élevé pour les moteurs INT8 dynamiques sur les anciens GPU. Sans dynamic=True, le moteur utilise une seule forme d'entrée fixe, et Ultralytics divise ou complète chaque lot pour l'adapter.

    Moteur dynamique
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    model.export(format="engine", dynamic=True, batch=8, quantize=16)
    
    model = YOLO("yolo26n.engine")
    results = model(["https://ultralytics.com/images/bus.jpg"] * 4, batch=4)  # un lot de 4 images
  • Effectue l'export directement sur le Jetson, avec la version de TensorRT fournie avec ta version de JetPack. Pour utiliser un cœur DLA, ajoute device=dla:0 avec quantize=16 ou quantize=8. Consulte le guide NVIDIA Jetson pour la configuration et les benchmarks.

    Exporter sur Jetson
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    model.export(format="engine", quantize=16)  # moteur FP16 sur le GPU Jetson
    
    # Ou crée plutôt le moteur FP16 pour le cœur DLA 0
    model.export(format="engine", quantize=16, device="dla:0")
  • Le guide du serveur d'inférence Triton exporte le modèle au format ONNX et active l'accélérateur TensorRT de Triton dans config.pbtxt. Triton crée alors le moteur TensorRT sur le GPU du serveur au premier chargement et le met en cache, de sorte que le moteur correspond toujours au GPU et à la version de TensorRT du serveur. Le guide explique l'organisation du dépôt de modèles, le conteneur du serveur et l'inférence côté client avec Ultralytics.

Commentaires116

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  1. AgbajeAyomipoGitHub

    Hi Ultralytics team, I’ve trained a YOLOv11 model on (1024x1024) images from a camera feed and now I’m trying to run real-time inference on live streams using a Jetson Orin Nano. I want to maintain full resolution for inference because of accuracy requirements, but currently I'm getting only 1-2 FPS. When I reduce the input size, the FPS improves significantly, but it's not acceptable due to missed detections at lower resolutions. I attempted to export the model to TensorRT using:

    model.export(format="engine", imgsz=(2592, 1944), half=True) but it fails silently. If I use a dynamic=true without specifying the imgsz parameter, the export succeeds and uses (1024, 1024). My questions:

    Is TensorRT export for such high-resolution input supported/recommended with YOLOv11? If not, is there any known limitation or workaround? Are there ways to improve performance with high-res inference on Jetson Orin Nano? What hardware would you recommend for real-time inference on 1-3 camera streams with 5MP inputs, assuming we need at least ~15-20 FPS per stream? Device: AAEON BOXER-8621AI Module: NVIDIA® Jetson Orin Nano™ (4GB LPDDR5, Super Mode Enabled) Memory: 4 GB LPDDR5 I/O: USB 3.2 Gen 2, M.2 Expansion Operating System: JetPack 5.1.4 (L4T 35.6.0, Ubuntu 20.04) Use Case: Real-time multi-stream 5MP video inference

    1
  2. AgbajeAyomipoGitHub

    Hi Ultralytics team, I’ve trained a YOLOv11 model on full-size 5MP (2592x1944) images from a camera feed and now I’m trying to run real-time inference on live streams using a Jetson Orin Nano. I want to maintain full resolution for inference because of accuracy requirements, but currently I'm getting only 1-2 FPS. When I reduce the input size, the FPS improves significantly, but it's not acceptable due to missed detections at lower resolutions. I attempted to export the model to TensorRT using:

    model.export(format="engine", imgsz=(2592, 1944), half=True) but it fails silently. If I use a dynamic=true, the export succeeds and uses (1024, 1024). My questions:

    1. Is TensorRT export for such high-resolution input supported/recommended with YOLOv11? If not, is there any known limitation or workaround?
    2. Are there ways to improve performance with high-res inference on Jetson Orin Nano?
    3. What hardware would you recommend for real-time inference on 1-3 camera streams with 5MP inputs, assuming we need at least ~15-20 FPS per stream? Device: AAEON BOXER-8621AI Module: NVIDIA® Jetson Orin Nano™ (4GB LPDDR5, Super Mode Enabled) Memory: 4 GB LPDDR5 I/O: USB 3.2 Gen 2, M.2 Expansion Operating System: JetPack 5.1.4 (L4T 35.6.0, Ubuntu 20.04) Use Case: Real-time multi-stream 5MP video inference
    1
  3. 020423lzlGitHub

    m的模型大小比n大的多,速度也慢了很多,输入图像尺寸越大,越吃显存,速度也越慢

    李子乐控制工程 @.***

    ---Original--- From: @.> Date: Sat, May 9, 2026 10:30 AM To: @.>; Cc: @.@.>; Subject: Re: [ultralytics/ultralytics] zh/integrations/tensorrt/ (Discussion #9868)

    现在有一个奇怪的现象,我导出的tensorrt模型的推理速度几乎和原来的.pt几乎没有差别甚至更慢,并且导出的tensorrt模型的推理结果和.pt模型的差别很大。 我的设备是i914900k+64G RAM+RTX A6000 我的环境是cuda12.4.131+tensorrt10.10.0.31+torch2.5.1+ultralytics8.3.252 导出命令: yolo export model=yolo11m.pt imgsz=1280 format='engine 推理代码为: model.predict(stream_path, imgsz=1280, classes=[14], conf=0.2, iou=0.5, stream=True, task='detect')

    另外我试了下yolo11n.pt的640输入尺寸导出,推理速度就有明显提升,当然推理结果差别仍然较大。 请问这是什么道理,有什么解决办法?

    — Reply to this email directly, view it on GitHub, or unsubscribe. Triage notifications on the go with GitHub Mobile for iOS or Android. You are receiving this because you commented.Message ID: @.***>

    1. User

      能不能读完再说话,肯定是m和m比,n和n比,同样尺寸输入和同样尺寸输入的比啊。 该显卡的RT core算力是普通fp32算力的近两倍。

    2. Glenn JocherUltralytics

      是的,性能应当在同一模型、同一 imgsz、同一 batch、同一后处理参数下比较;m 比 n 更大、1280 比 640 更吃显存且更慢是正常现象。对 RTX A6000 来说,FP32 的 TensorRT 往往不会比 .pt 明显更快,建议先按 TensorRT 导出文档 用 half=True 重新导出,并在相同输入上预热后再统计平均耗时;如果 engine 与 .pt 结果仍明显不一致,请贴出 !yolo checks、完整控制台日志文本和一个最小可复现示例,我们好继续排查环境或后处理差异。

  4. User

    现在有一个奇怪的现象,我导出的tensorrt模型的推理速度几乎和原来的.pt几乎没有差别甚至更慢,并且导出的tensorrt模型的推理结果和.pt模型的差别很大。 我的设备是i914900k+64G RAM+RTX A6000 我的环境是cuda12.4.131+tensorrt10.10.0.31+torch2.5.1+ultralytics8.3.252 导出命令: yolo export model=yolo11m.pt imgsz=1280 format='engine 推理代码为:

    model.predict(stream_path, imgsz=1280, classes=[14], conf=0.2, iou=0.5, stream=True, task='detect')

    另外我试了下yolo11n.pt的640输入尺寸导出,推理速度就有明显提升,当然推理结果差别仍然较大。 请问这是什么道理,有什么解决办法?

  5. 020423lzlGitHub

    etson@yahboom:~/ultralytics/ultralytics$ yolo predict model=best.engine source=0 save=False show WARNING ⚠️ Unable to automatically guess model task, assuming 'task=detect'. Explicitly define task for your model, i.e. 'task=detect', 'segment', 'classify','pose' or 'obb'. Ultralytics 8.3.172 🚀 Python-3.10.12 torch-2.5.0a0+872d972e41.nv24.08 CUDA:0 (Orin, 7620MiB) Loading best.engine for TensorRT inference... [12/18/2025-17:11:05] [TRT] [I] Loaded engine size: 75 MiB [12/18/2025-17:11:05] [TRT] [I] [MS] Running engine with multi stream info [12/18/2025-17:11:05] [TRT] [I] [MS] Number of aux streams is 7 [12/18/2025-17:11:05] [TRT] [I] [MS] Number of total worker streams is 8 [12/18/2025-17:11:05] [TRT] [I] [MS] The main stream provided by execute/enqueue calls is the first worker stream [12/18/2025-17:11:05] [TRT] [I] [MemUsageChange] TensorRT-managed allocation in IExecutionContext creation: CPU +1, GPU +88, now: CPU 1, GPU 158 (MiB)

    [ WARN:0@2.771] global cap_gstreamer.cpp:1777 open OpenCV | GStreamer warning: Cannot query video position: status=0, value=-1, duration=-1 1/1: 0... Success ✅ (inf frames of shape 1920x1080 at 5.00 FPS)

    Traceback (most recent call last): File "/home/jetson/.local/bin/yolo", line 7, in sys.exit(entrypoint()) File "/home/jetson/Downloads/ultralytics-main/ultralytics/cfg/init.py", line 983, in entrypoint getattr(model, mode)(**overrides) # default args from model File "/home/jetson/Downloads/ultralytics-main/ultralytics/engine/model.py", line 555, in predict return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream) File "/home/jetson/Downloads/ultralytics-main/ultralytics/engine/predictor.py", line 247, in predict_cli for _ in gen: # sourcery skip: remove-empty-nested-block, noqa File "/usr/local/lib/python3.10/dist-packages/torch/utils/_contextlib.py", line 36, in generator_context response = gen.send(None) File "/home/jetson/Downloads/ultralytics-main/ultralytics/engine/predictor.py", line 351, in stream_inference s[i] += self.write_results(i, Path(paths[i]), im, s) File "/home/jetson/Downloads/ultralytics-main/ultralytics/engine/predictor.py", line 434, in write_results string += f"{result.verbose()}{result.speed['inference']:.1f}ms" File "/home/jetson/Downloads/ultralytics-main/ultralytics/engine/results.py", line 694, in verbose return "".join(f"{n} {self.names[i]}{'s' * (n > 1)}, " for i, n in enumerate(counts) if n > 0) File "/home/jetson/Downloads/ultralytics-main/ultralytics/engine/results.py", line 694, in return "".join(f"{n} {self.names[i]}{'s' * (n > 1)}, " for i, n in enumerate(counts) if n > 0) KeyError: 171 terminate called without an active exception Aborted (core dumped) jetson@yahboom:~/ultralytics/ultralytics$ How to solve it

    1. Glenn JocherUltralytics

      KeyError: 171 表示模型输出了类别 171,但当前 names 里没有这个索引(通常是自定义数据集的标签类别编号不在 0..nc-1 范围内、data.yaml 里的 names 数量与 nc 不匹配,或导出/推理用的模型与数据配置不一致导致的元数据错配);请先把所有标注 .txt 的 class id 修正为连续的 0..nc-1,同步修正 data.yaml 的 nc/names,修正后删除数据集 labels/ 下的 *.cache,再用同一套环境从 best.pt 重新导出 .engine(参考 TensorRT 导出文档),并在推理时显式加上 task=detect。另外请把下面命令的完整输出(文本)贴在这个 discussion 里,以及你当时的导出命令,方便我们确认是否有多环境/路径冲突:

      yolo checks
    2. 020423lzlGitHub

      Thank you for your reply. The issue has been resolved. I was using the RT-DETR model, but I mistakenly used "from ultralytics import YOLO" when exporting

    3. Glenn JocherUltralytics

      Glad you found it — RT-DETR models should be loaded/exported with RTDETR(...) (mixing them with YOLO(...) can produce mismatched metadata like names), see the RT-DETR model docs for details:

      from ultralytics import RTDETR
      
      model = RTDETR("best.pt")
      model.export(format="engine")  # creates best.engine
  6. fly2skyToEnjoyGitHub

    May I ask : The following command exports the file, whether the box and mask are both nmsed at the same time ???

    from ultralytics import YOLO

    Load the YOLO11 model

    model = YOLO("yolo11n.pt")

    Export the model to TensorRT format

    model.export(format="engine") # creates 'yolo11n.engine'

    Load the exported TensorRT model

    tensorrt_model = YOLO("yolo11n.engine")

    Run inference

    results = tensorrt_model("https://ultralytics.com/images/bus.jpg")

  7. dilanpatel195GitHub

    I am trying to prediction model for the YOLOv11n-seg, I have exported the .py to .engine to back it run faster but keep getting a KEY error message:


    KeyError Traceback (most recent call last) Cell In[4], line 109 106 # Inside the main loop after grabbing a frame 107 if inference_active and not inpainting_active: 108 # Perform YOLO inference --> 109 results = model(rgb_frame)[0] 110 masked_image = rgb_frame.copy() # Make a copy for masking 112 # Process YOLO masks (original functionality remains unchanged)

    File c:\ProgramData\miniconda3\Lib\site-packages\ultralytics\engine\model.py:176, in Model.call(self, source, stream, **kwargs) 147 def call( 148 self, 149 source: Union[str, Path, int, Image.Image, list, tuple, np.ndarray, torch.Tensor] = None, 150 stream: bool = False, 151 **kwargs, 152 ) -> list: 153 """ 154 Alias for the predict method, enabling the model instance to be callable for predictions. 155 (...) 174 ... print(f"Detected {len(r)} objects in image") 175 """ --> 176 return self.predict(source, stream, **kwargs)

    File c:\ProgramData\miniconda3\Lib\site-packages\ultralytics\engine\model.py:554, in Model.predict(self, source, stream, predictor, **kwargs) 552 if prompts and hasattr(self.predictor, "set_prompts"): # for SAM-type models 553 self.predictor.set_prompts(prompts) --> 554 return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream)

    File c:\ProgramData\miniconda3\Lib\site-packages\ultralytics\engine\predictor.py:168, in BasePredictor.call(self, source, model, stream, *args, **kwargs) 166 return self.stream_inference(source, model, *args, **kwargs) 167 else: --> 168 return list(self.stream_inference(source, model, *args, **kwargs))

    File c:\ProgramData\miniconda3\Lib\site-packages\torch\utils_contextlib.py:36, in _wrap_generator..generator_context(*args, **kwargs) 33 try: 34 # Issuing None to a generator fires it up 35 with ctx_factory(): ---> 36 response = gen.send(None) 38 while True: 39 try: 40 # Forward the response to our caller and get its next request

    File c:\ProgramData\miniconda3\Lib\site-packages\ultralytics\engine\predictor.py:274, in BasePredictor.stream_inference(self, source, model, *args, **kwargs) 268 self.results[i].speed = { 269 "preprocess": profilers[0].dt * 1e3 / n, 270 "inference": profilers[1].dt * 1e3 / n, 271 "postprocess": profilers[2].dt * 1e3 / n, 272 } 273 if self.args.verbose or self.args.save or self.args.save_txt or self.args.show: --> 274 s[i] += self.write_results(i, Path(paths[i]), im, s) 276 # Print batch results 277 if self.args.verbose:

    File c:\ProgramData\miniconda3\Lib\site-packages\ultralytics\engine\predictor.py:334, in BasePredictor.write_results(self, i, p, im, s) 332 result = self.results[i] 333 result.save_dir = self.save_dir.str() # used in other locations --> 334 string += f"{result.verbose()}{result.speed['inference']:.1f}ms" 336 # Add predictions to image 337 if self.args.save or self.args.show:

    File c:\ProgramData\miniconda3\Lib\site-packages\ultralytics\engine\results.py:663, in Results.verbose(self) 661 for c in boxes.cls.unique(): 662 n = (boxes.cls == c).sum() # detections per class --> 663 log_string += f"{n} {self.names[int(c)]}{'s' * (n > 1)}, " 664 return log_string

    KeyError: 2

    Any help would be greatly appreciated!

  8. Ranjith3436GitHub

    Now, My TensorRT Sengment model used for track. if any detections not there the processing FPS is 75-80 in jetson. But once the person or people detected suddenly reused to 15-20. processing time going to 40ms. only when the object detected. What's the issue in model.track(), could i run all the tracking thing on GPU.

    1. Glenn JocherUltralytics(modifié)

      @Ranjith3436 the performance drop when objects are detected is expected behavior, as tracking introduces additional computational overhead. When objects are detected, the model.track() method performs several CPU-bound operations including feature extraction, association, and trajectory management.

      To improve performance:

      1. Try using a smaller model variant (like YOLO26n-seg instead of larger variants)
      2. Consider reducing the image resolution for tracking
      3. Optimize tracking parameters by setting persist=True and adjusting conf thresholds higher to track fewer objects
      4. Use half=True (FP16) or int8=True when exporting your model to TensorRT for maximum GPU acceleration

      For the tracking components specifically, the BoT-SORT or ByteTrack algorithms used by Ultralytics do have some CPU-bound operations, but you can minimize their impact with the above optimizations. For more details on tracking optimization, check our tracking documentation.

      1
  9. Ranjith3436GitHub

    I convert Classification model that i retrained. But it throw the error "amax(): Expected reduction dim 1 to have non-zero size."

    1. Glenn JocherUltralytics

      @Ranjith3436 this error typically occurs when TensorRT encounters an empty dimension during model conversion. For classification models, this could happen if:

      1. Your model architecture was modified or if you're using a custom architecture
      2. There might be an issue with batch normalization layers during export
      3. The class count in your retrained model might be causing dimension mismatches

      Try these solutions:

      • Ensure your model's forward pass works correctly before export
      • Try exporting with simplify=False to preserve the original graph structure
      • Check if your classification model has the correct output dimension for your number of classes

      If the issue persists, share more details about your model architecture and export command for better assistance. For more guidance, refer to our TensorRT integration documentation.

    2. Ranjith3436GitHub

      The model trained use yolov8l-cls.pt and the error come from jetson device.

      (model): ClassificationModel( (model): Sequential( (0): Conv( (conv): Conv2d(3, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (1): Conv( (conv): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (2): C2f( (cv1): Conv( (conv): Conv2d(128, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (cv2): Conv( (conv): Conv2d(320, 128, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (m): ModuleList( (0-2): 3 x Bottleneck( (cv1): Conv( (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (cv2): Conv( (conv): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) ) ) ) (3): Conv( (conv): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (4): C2f( (cv1): Conv( (conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (cv2): Conv( (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (m): ModuleList( (0-5): 6 x Bottleneck( (cv1): Conv( (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (cv2): Conv( (conv): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) ) ) ) (5): Conv( (conv): Conv2d(256, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (6): C2f( (cv1): Conv( (conv): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (cv2): Conv( (conv): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (m): ModuleList( (0-5): 6 x Bottleneck( (cv1): Conv( (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (cv2): Conv( (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) ) ) ) (7): Conv( (conv): Conv2d(512, 1024, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False) (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (8): C2f( (cv1): Conv( (conv): Conv2d(1024, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (cv2): Conv( (conv): Conv2d(2560, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (m): ModuleList( (0-2): 3 x Bottleneck( (cv1): Conv( (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (cv2): Conv( (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False) (bn): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) ) ) ) (9): Classify( (conv): Conv( (conv): Conv2d(1024, 1280, kernel_size=(1, 1), stride=(1, 1), bias=False) (bn): BatchNorm2d(1280, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (act): SiLU(inplace=True) ) (pool): AdaptiveAvgPool2d(output_size=1) (drop): Dropout(p=0.0, inplace=True) (linear): Linear(in_features=1280, out_features=2, bias=True) ) ) ) )

      model architecture