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.
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 format | engine (alias : tensorrt, trt) |
| Sortie | yolo26n.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 sur | GPU NVIDIA : centre de données, station de travail et Jetson, y compris les cœurs DLA Jetson (pas avec TensorRT 11) |
| Environnement d’exécution | TensorRT 7.0 ou version ultérieure (10.2.0 n’est pas pris en charge) |
| Précision | FP32, FP16, INT8 |
| Machine d’exportation | Une 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 |
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 ultralyticsPour 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.
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'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")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#
| Argument | Type | Valeur par défaut | Description |
|---|---|---|---|
format | str | 'engine' | Format cible du modèle exporté, qui définit sa compatibilité avec différents environnements de déploiement. |
imgsz | int ou tuple | 640 | Taille 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. |
quantize | int ou str | None | Pré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. |
dynamic | bool | False | Cré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. |
simplify | bool | True | Simplifie le graphe du modèle avec onnxslim, ce qui peut améliorer les performances et la compatibilité. |
opset | int | None | Indique 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. |
workspace | float ou None | None | Limite 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. |
nms | bool, facultatif | None | Choisis 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. |
batch | int | 1 | Taille 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. |
data | str | None | Chemin 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. |
fraction | float, int ou list | 1.0 | Sous-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. |
device | str | None | Indique 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). |
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 à 10 | TensorRT 11 | |
|---|---|---|
| Méthode INT8 | Quantification implicite avec l’interface IInt8Calibrator | Quantification explicite : NVIDIA ModelOpt insère des nœuds Q/DQ dans le graphe ONNX |
| Algorithme d’étalonnage | MINMAX_CALIBRATION sur GPU, ENTROPY_CALIBRATION_2 pour DLA | ModelOpt max, exécuté sur le CPU |
| Images d’étalonnage utilisées | Chaque lot complet de la partition | Environ 512 images dans un ordre aléatoire, ou chaque lot complet d’une partition plus petite |
dynamic=True avec quantize=8 | Non couvert par les tests ; exportation sans dynamic=True | Pris en charge |
FP16 (quantize=16) | Indicateur de génération TensorRT | Conversion à 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.
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#
-
NVIDIA Triton Inference Server : sers un export ONNX avec l’accélérateur TensorRT de Triton, qui crée le moteur sur le GPU du serveur.
-
Démarrage rapide NVIDIA Jetson : configure Ultralytics sur les appareils Jetson et exporte des moteurs TensorRT avec JetPack, y compris DLA.
-
Démarrage rapide NVIDIA DGX Spark : configure Ultralytics et TensorRT sur NVIDIA DGX Spark.
-
DeepStream sur NVIDIA Jetson : exécute des modèles exportés dans des pipelines vidéo NVIDIA DeepStream.
-
NVIDIA TensorRT sur GitHub : code source, exemples et outils pour TensorRT.
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=0lorsquedevicen’est pas défini et échoue avecexport running on CPU but must be on GPUpourdevice=cpu. - Le moteur ne se charge pas dans d’autres outils : le fichier
.enginecommence 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 avecnms=Falserevient 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:0etdevice=dla:1ne fonctionnent que sur NVIDIA Jetson, et uniquement avecquantize=16ouquantize=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=Truenécessite une taille de lot maximale ; définis donc égalementbatch, par exemplebatch=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 àbatchet des tailles d’image de 32 pixels jusqu’à deux fois la valeur d’exportationimgsz. Par exemple, un moteur exporté avecimgsz=320 batch=4fonctionne à 640 pixels et rejette 704 pixels ou un lot de 6 avecinput size ... is outside the TensorRT optimization profile. Combinedynamic=Trueavecquantize=8uniquement 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=Truefonctionne toujours avec la valeur d’exportationimgsz. Le fait de passer une autre valeurimgszà 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é avecquantize=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. Passedataavec 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
imgszsur 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èle | imgsz | PyTorch | TensorRT FP32 | TensorRT FP16 | TensorRT INT8 |
|---|---|---|---|---|---|
| YOLO26n | 640 | 2.85 | 0.67 | 0.48 | 0.53 |
| YOLO26s | 640 | 2.98 | 1.15 | 0.61 | 0.66 |
| YOLO26m | 640 | 3.29 | 2.22 | 1.03 | 1.08 |
| YOLO26l | 640 | 4.70 | 3.03 | 1.49 | 1.43 |
| YOLO26x | 640 | 5.93 | 4.31 | 2.09 | 1.84 |
| YOLO26n-seg | 640 | 3.18 | 0.93 | 0.65 | 0.72 |
| YOLO26n-sem | 1024 | 1.74 | 0.74 | 0.45 | 0.71 |
| YOLO26n-cls | 224 | 1.75 | 0.29 | 0.24 | 0.20 |
| YOLO26n-pose | 640 | 3.39 | 0.76 | 0.51 | 0.59 |
| YOLO26n-obb | 1024 | 4.55 | 1.03 | 0.64 | 0.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.
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é avecquantize=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=Trueet définisbatchsur la taille maximale de lot que tu prévois d'utiliser. Le moteur accepte alors des lots de 1 àbatchimages et des tailles d'image allant de 32 pixels à deux fois la valeur d'exportationimgsz, avec un minimum plus élevé pour les moteurs INT8 dynamiques sur les anciens GPU. Sansdynamic=True, le moteur utilise une seule forme d'entrée fixe, et Ultralytics divise ou complète chaque lot pour l'adapter.Moteur dynamiquefrom 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 imagesEffectue 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:0avecquantize=16ouquantize=8. Consulte le guide NVIDIA Jetson pour la configuration et les benchmarks.Exporter sur Jetsonfrom 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.
AgbajeAyomipo
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
1martinmclee
Have you gotten any workaround? Perhaps with the YOLO26?
AgbajeAyomipo
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:- 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
1020423lzl
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: @.***>
User能不能读完再说话,肯定是m和m比,n和n比,同样尺寸输入和同样尺寸输入的比啊。 该显卡的RT core算力是普通fp32算力的近两倍。
Glenn JocherUltralytics是的,性能应当在同一模型、同一
imgsz、同一batch、同一后处理参数下比较;m比n更大、1280比640更吃显存且更慢是正常现象。对 RTX A6000 来说,FP32的 TensorRT 往往不会比.pt明显更快,建议先按 TensorRT 导出文档 用half=True重新导出,并在相同输入上预热后再统计平均耗时;如果engine与.pt结果仍明显不一致,请贴出!yolo checks、完整控制台日志文本和一个最小可复现示例,我们好继续排查环境或后处理差异。
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输入尺寸导出,推理速度就有明显提升,当然推理结果差别仍然较大。 请问这是什么道理,有什么解决办法?
020423lzl
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
Glenn JocherUltralyticsKeyError: 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 checks020423lzl
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
Glenn JocherUltralyticsGlad you found it — RT-DETR models should be loaded/exported with
RTDETR(...)(mixing them withYOLO(...)can produce mismatched metadata likenames), see the RT-DETR model docs for details:from ultralytics import RTDETR model = RTDETR("best.pt") model.export(format="engine") # creates best.engine
fly2skyToEnjoy
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")
AK993
这个方法适用于rt-detr吗
dilanpatel195
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!
Ranjith3436
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.
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:
- Try using a smaller model variant (like YOLO26n-seg instead of larger variants)
- Consider reducing the image resolution for tracking
- Optimize tracking parameters by setting
persist=Trueand adjustingconfthresholds higher to track fewer objects - Use
half=True(FP16) orint8=Truewhen 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
Ranjith3436
I convert Classification model that i retrained. But it throw the error "amax(): Expected reduction dim 1 to have non-zero size."
Glenn JocherUltralytics@Ranjith3436 this error typically occurs when TensorRT encounters an empty dimension during model conversion. For classification models, this could happen if:
- Your model architecture was modified or if you're using a custom architecture
- There might be an issue with batch normalization layers during export
- 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=Falseto 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.
Ranjith3436
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
Ranjith3436
This error sorted out