Inizia

Esportazione TensorRT per i modelli YOLO26

TensorRT è l'SDK di NVIDIA per l'inferenza ad alta velocità di apprendimento profondo. L'esportazione di un modello Ultralytics YOLO26 con format="engine" crea un file .engine ottimizzato per la GPU NVIDIA su cui viene creato, con precisione FP32, FP16 o INT8.

I motori TensorRT sono specifici per l'hardware e il runtime

TensorRT ottimizza un motore per la GPU su cui viene creato. Crea il motore sulla GPU di destinazione oppure su una GPU dello stesso modello e con la stessa versione di TensorRT: un file .engine non è un formato di modello portabile. Per la distribuzione edge, Ultralytics Platform offre otto configurazioni di destinazione Jetson, con lo stato della compilazione e della convalida fisiche documentato per ciascuna, oppure puoi esportare localmente sul dispositivo di destinazione.

In breve#

ProprietàDettagli
argomento formatengine (alias: tensorrt, trt)
Outputyolo26n.engine, un file che inizia con un'intestazione di metadati JSON (nomi delle classi, attività, dimensioni dell'immagine). Il file intermedio yolo26n.onnx rimane nella stessa directory
Esecuzione suGPU NVIDIA: data center, workstation e Jetson, inclusi i core DLA di Jetson (non con TensorRT 11)
RuntimeTensorRT 7.0 o versione successiva (la versione 10.2.0 non è supportata)
PrecisioneFP32, FP16, INT8
Sistema per l'esportazioneUna macchina con GPU NVIDIA e CUDA. Crea il motore sulla GPU di destinazione o su una GPU dello stesso modello
Esportazione nel cloud

Ultralytics Platform può creare un motore TensorRT sulla GPU del tipo che selezioni, incluse le destinazioni NVIDIA Jetson, così non ti serve un ambiente di esportazione locale.

Guida rapida#

Installa il pacchetto Ultralytics su una macchina con GPU NVIDIA e CUDA. Su Linux, se manca, la prima esportazione installa il pacchetto Python di TensorRT compatibile con la tua versione di CUDA. Su NVIDIA Jetson, usa la versione di TensorRT inclusa in JetPack. Su Windows, installa TensorRT manualmente prima di esportare.

pip install ultralytics

Per altri metodi di installazione, consulta la guida all'installazione. Poi esporta il tuo modello e carica il motore esportato per eseguire l'inferenza o convalidarne la precisione. L'inferenza e la convalida richiedono una GPU NVIDIA. La creazione di un motore YOLO26n richiede da uno a tre minuti su una NVIDIA T4.

Esporta
from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta il modello in formato TensorRT
model.export(format="engine")  # crea 'yolo26n.engine'

# Oppure esporta un motore FP16
model.export(format="engine", quantize=16)  # crea 'yolo26n.engine'
Predici
from ultralytics import YOLO

# Carica il modello TensorRT esportato
model = YOLO("yolo26n.engine")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")
Convalida
from ultralytics import YOLO

# Carica il modello TensorRT esportato
model = YOLO("yolo26n.engine")

# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")

Attività supportate#

L'esportazione TensorRT supporta tutte e sette le attività Ultralytics con i modelli YOLOv8, YOLO11 e YOLO26: rilevamento, segmentazione, segmentazione semantica, stima della profondità, classificazione, stima della posa e OBB. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include queste teste.

Argomenti di esportazione#

ArgomentoTipoPredefinitoDescrizione
formatstr'engine'Formato di destinazione del modello esportato, che definisce la compatibilità con i vari ambienti di distribuzione.
imgszint o tuple640Dimensione dell'immagine desiderata per l'input del modello. Può essere un intero per immagini quadrate o una tupla (height, width) per dimensioni specifiche.
quantizeint o strNonePrecisione di quantizzazione: 16 (FP16) o 8 (INT8/PTQ; richiede la calibrazione data/fraction); 32/non impostato corrisponde a FP32. Un checkpoint addestrato con quantize=8 esporta in INT8 usando gli intervalli che contiene, senza calibrazione, anche se quantize non è impostato; quantize=16 o quantize=32 genera un errore. Sostituisce i flag deprecati half/int8.
dynamicboolFalseCrea un motore che accetta dimensioni del batch da 1 a batch e dimensioni dell'immagine da 32 pixel al doppio di imgsz; il minimo è maggiore per i motori INT8 dinamici su GPU meno recenti. Quando False, il motore accetta solo batch e imgsz dell'esportazione.
simplifyboolTrueSemplifica il grafo del modello con onnxslim, migliorando potenzialmente prestazioni e compatibilità.
opsetintNoneSpecifica la versione dell'opset ONNX per il grafo ONNX intermedio. Se non è impostata, viene usato l'opset 18 (inferiore con PyTorch < 2.4), limitato alla versione onnx installata.
workspacefloat o NoneNoneLimite superiore, in GiB, della memoria usata da TensorRT durante la creazione del motore. Lascialo su None per consentire a TensorRT di allocare automaticamente la memoria.
nmsbool, facoltativoNoneSeleziona l'output grezzo (None, predefinito), NMS integrata (True) o la testa senza NMS (False). Con nms=True, conf (0.25 per impostazione predefinita), iou, max_det e agnostic_nms sono fissati durante l'esportazione; nms=True viene ignorato per i modelli semantici e di profondità e genera un errore per i modelli di classificazione.
batchint1Dimensione del batch del motore o dimensione massima del batch con dynamic=True. È anche la dimensione del batch usata per la calibrazione INT8.
datastrNonePercorso al file YAML del dataset, usato per la calibrazione INT8; per la classificazione si indica invece una directory del dataset o il nome di un dataset integrato. La calibrazione usa la suddivisione val, a meno che non sia impostato split. Se omesso con quantize=8, Ultralytics usa il piccolo dataset predefinito per l'attività del modello, ad esempio coco8.yaml per il rilevamento; un checkpoint addestrato con quantize=8 non ne ha bisogno.
fractionfloat, int o list1.0Sottoinsieme di calibrazione espresso come rapporto, numero di immagini o rapporti/conteggi [train, val, test]. Gli elenchi di due elementi lasciano completo test, mentre 0 lo esclude.
devicestrNoneSpecifica il dispositivo per l'esportazione: GPU (device=0, usato se non impostato), DLA per NVIDIA Jetson (device=dla:0 o device=dla:1, con quantize=16 o quantize=8).
Compatibilità con JetPack e DLA

Su NVIDIA Jetson, Ultralytics esporta usando il runtime TensorRT della tua versione di JetPack. Con JetPack 7, l'esportazione richiede TensorRT 10.15 o versione successiva e inferiore alla 11. device=dla:0 e device=dla:1 generano un errore con TensorRT 11. NVIDIA indica TensorRT 10.7 come l'ultima versione 10.x con supporto DLA e TensorRT 11.4.1 aggiunge il supporto a JetPack 7.2.2, che Ultralytics non usa ancora.

Per gli argomenti condivisi da tutti i formati, consulta la documentazione della modalità di esportazione.

Esportazione TensorRT con quantizzazione INT8#

quantize=8 crea un motore INT8 con quantizzazione post-addestramento (PTQ): durante l'esportazione le immagini di calibrazione vengono passate attraverso il modello per misurare l'intervallo di valori di ciascun tensore. Un checkpoint perfezionato con quantize=8 mediante addestramento consapevole della quantizzazione contiene già i propri intervalli INT8, quindi la sua esportazione salta la calibrazione.

Gli argomenti quantize e data sono identici in tutte le versioni di TensorRT, ma l'esportazione di un checkpoint non addestrato con quantize=8 funziona diversamente internamente:

TensorRT 7-10TensorRT 11
Metodo INT8Quantizzazione implicita con l'interfaccia IInt8CalibratorQuantizzazione esplicita: NVIDIA ModelOpt inserisce nodi Q/DQ nel grafo ONNX
Algoritmo di calibrazioneMINMAX_CALIBRATION su GPU, ENTROPY_CALIBRATION_2 per DLAModelOpt max, eseguito sulla CPU
Immagini di calibrazione usateOgni batch completo della suddivisioneCirca 512 immagini in ordine casuale oppure ogni batch completo di una suddivisione più piccola
dynamic=True con quantize=8Non coperto dai test; esporta senza dynamic=TrueSupportato
FP16 (quantize=16)Flag del builder TensorRTConversione a precisione mista AutoCast di ModelOpt

ModelOpt viene installato al primo utilizzo. Ultralytics non riutilizza una cache di calibrazione, quindi ogni esportazione esegue di nuovo la calibrazione. Per dettagli su entrambi i metodi, consulta Uso dei tipi quantizzati nella documentazione di TensorRT.

Per un checkpoint non addestrato con quantize=8, passa le immagini di calibrazione con data, ad esempio data="my_dataset.yaml". La calibrazione usa la suddivisione val di quel dataset, a meno che tu non imposti split; fraction limita il numero di immagini. NVIDIA consiglia almeno 500 immagini rappresentative dei dati di distribuzione e l'esportazione registra un avviso se sono meno di 300. Se manca data, l'esportazione registra un avviso e usa il piccolo dataset di esempio per l'attività del modello, ad esempio coco8.yaml per il rilevamento. La suddivisione di convalida contiene 4 immagini, sufficienti per verificare l'esportazione ma non per calibrare un modello destinato alla distribuzione.

Esempio
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Esegui la calibrazione sul 10% delle immagini di convalida COCO (500 immagini); sostituisci coco.yaml con il tuo dataset
model.export(format="engine", quantize=8, data="coco.yaml", fraction=0.1)

# Carica il motore INT8 esportato ed esegui l'inferenza
model = YOLO("yolo26n.engine")
result = model.predict("https://ultralytics.com/images/bus.jpg")

Sulla GPU di benchmark, i motori INT8 sono risultati da 1,04 a 2,3 volte più veloci dei motori FP32, ma solo tre dei dieci modelli hanno superato in velocità i motori FP16. INT8 ha perso da 1,7 a 2,9 punti mAP sui modelli da YOLO26n a YOLO26l, e molti di più su YOLO26x e YOLO26n-pose. Il motore INT8 di YOLO26n era più grande di quello FP32 (30 MB contro 11 MB), mentre i modelli grandi si sono ridotti (53 MB contro 103 MB per YOLO26l). INT8 può anche modificare i valori di confidenza, quindi scegli la soglia di confidenza dalla curva F1 del motore INT8 stesso. Consulta i benchmark di tutti i modelli.

Formato di output#

Il motore accetta un input chiamato images e restituisce gli stessi output dell'esportazione ONNX da cui è stato creato, con un'eccezione: nelle versioni di TensorRT precedenti alla 10, i modelli semantici restituiscono punteggi di classe float con forma (batch, classes, height, width) al posto della mappa delle classi uint8. Consulta il formato dell'output ONNX per conoscere la forma dell'output di ogni attività e di ogni impostazione nms.

Caricare il motore al di fuori di Ultralytics#

Un file Ultralytics .engine non è un semplice motore TensorRT. Inizia con una lunghezza di 4 byte in formato little-endian, seguita da altrettanti byte di metadati JSON e infine dal motore serializzato. Il deserialize_cuda_engine di TensorRT restituisce None quando riceve il file intero. Salta l'intestazione per caricare il motore con 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")  # lunghezza dell'intestazione dei metadati
    metadata = json.loads(f.read(n))  # nomi delle classi, attività, imgsz, batch, argomenti di esportazione
    engine = trt.Runtime(trt.Logger(trt.Logger.WARNING)).deserialize_cuda_engine(f.read())

Se un altro strumento richiede un file motore TensorRT semplice, scrivi i byte successivi all'intestazione in un nuovo file oppure crea il motore con quello strumento a partire dal file yolo26n.onnx che l'esportazione lascia accanto al motore. Con TensorRT 11, anche le esportazioni FP16 e INT8 calibrate lasciano i file yolo26n.fp16.onnx e yolo26n.int8.onnx; per creare un motore INT8 con un altro strumento, usa il file .int8.onnx. Per un checkpoint addestrato con quantize=8, yolo26n.onnx contiene già i nodi Q/DQ e non viene scritto alcun file .int8.onnx; con TensorRT 11, l'esportazione lascia yolo26n.fp16.onnx, lo stesso grafo Q/DQ con gli altri livelli in FP16.

Distribuisci#

YOLO("yolo26n.engine") carica il motore con il runtime Python di TensorRT. Il motore viene eseguito per impostazione predefinita sulla GPU 0, anche se passi device="cpu". Passa device=1 per eseguirlo su un'altra GPU dello stesso modello. Un motore esportato con device=dla:0 o device=dla:1 viene eseguito su quel core DLA.

Un motore esportato senza dynamic=True ha una forma di input fissa. Predict e val usano imgsz dell'esportazione e ignorano un argomento imgsz diverso. Ultralytics suddivide i batch più grandi in batch della dimensione usata per l'esportazione e completa quelli più piccoli con padding, quindi è possibile elaborare un numero qualsiasi di immagini. Un motore esportato con dynamic=True accetta tutte le dimensioni di batch e di immagine comprese nel suo intervallo e genera ValueError: input size ... is outside the TensorRT optimization profile per una forma che ne è fuori. Con nms=True, invece, un batch superiore all'intervallo viene suddiviso in batch della dimensione usata per l'esportazione.

Guide alla distribuzione#

Limitazioni e risoluzione dei problemi#

  • I motori non sono portabili: un motore viene creato per un solo modello di GPU e una sola versione di TensorRT. Ricrealo quando cambi la GPU, la versione di TensorRT o la versione di JetPack. Se non è possibile caricare un motore, Ultralytics registra TensorRT model exported with a different version than expected.
  • È necessaria una GPU: l'esportazione usa device=0 quando device non è impostato e non riesce con export running on CPU but must be on GPU per device=cpu.
  • Il motore non si carica in altri strumenti: il file .engine inizia con un'intestazione di metadati, quindi l'API TensorRT non può leggerlo direttamente. Consulta Caricare il motore al di fuori di Ultralytics.
  • Versione di TensorRT: Ultralytics richiede TensorRT 7.0.0 o versione successiva. TensorRT 10.2.0 non è supportato e l'installazione automatica lo esclude. Su JetPack 7 e sui sistemi NVIDIA DGX, l'esportazione richiede TensorRT 10.15 o versione successiva (e inferiore alla 11 su Jetson) e prova a installarla se la versione presente non rientra in questo intervallo.
  • Testa senza NMS nelle versioni meno recenti di TensorRT: le versioni di TensorRT precedenti alla 8.5.0 non possono creare la testa YOLO26 senza NMS. L'esportazione registra un avviso e scrive predizioni grezze che richiedono NMS. Aggiorna TensorRT alla versione 8.5.0 o successiva per esportare con nms=False.
  • INT8 su JetPack 6: con TensorRT 10.3.0 su JetPack 6, un'esportazione INT8 con nms=True non riesce, mentre un'esportazione INT8 con nms=False ripiega sulle predizioni grezze. Consulta la guida a Jetson per la soluzione.
  • INT8 su TensorRT 10.16: l'esportazione INT8 con TensorRT 10.16.1 non è riuscita sulle GPU NVIDIA RTX PRO 6000 Blackwell e RTX 6000D con Could not find any implementation for node. Sulla RTX PRO 6000 Blackwell, TensorRT 10.13, 10.14, 10.15 e 11.4 hanno creato il motore INT8.
  • DLA: device=dla:0 e device=dla:1 funzionano solo su NVIDIA Jetson e solo con quantize=16 o quantize=8. L'esportazione genera un errore con TensorRT 11. I livelli non supportati da DLA vengono eseguiti sulla GPU.
  • Forme dinamiche: dynamic=True richiede una dimensione massima del batch, quindi imposta anche batch, ad esempio batch=8. Se non lo fai, l'esportazione registra un avviso e la dimensione massima del batch è 1. Il motore accetta batch da 1 a batch e dimensioni dell'immagine da 32 pixel fino al doppio di imgsz dell'esportazione. Per esempio, un motore esportato con imgsz=320 batch=4 funziona a 640 pixel e rifiuta 704 pixel o un batch di 6 con input size ... is outside the TensorRT optimization profile. Combina dynamic=True con quantize=8 solo su TensorRT 11. Sulle GPU con capacità di calcolo 7.5 o inferiore, come la T4, la dimensione minima di questi motori INT8 dinamici è 64 pixel (128 per i modelli P6).
  • Dimensione fissa dell'input: un motore esportato senza dynamic=True funziona sempre con imgsz dell'esportazione. Passare un altro imgsz a predict o val non ha effetto: per cambiare la dimensione dell'input, esporta di nuovo.
  • Esportazione INT8 senza data: a meno che il checkpoint non sia stato addestrato con quantize=8, l'esportazione esegue la calibrazione sul piccolo dataset predefinito per l'attività, che per il rilevamento contiene 4 immagini di convalida, e registra un avviso. Passa data con immagini rappresentative; l'esportazione avvisa se sono meno di 300.
  • Prime inferenze lente: le prime chiamate con un nuovo motore, o con un nuovo imgsz su un motore dinamico, richiedono più tempo delle chiamate successive.

Per altri errori, consulta la guida ai problemi comuni.

Benchmark#

La pagina del modello YOLO26 riporta la velocità TensorRT 10 di ogni modello su una GPU NVIDIA T4 per tutte le attività, tranne la segmentazione semantica.

Confronto tra FP32, FP16 e INT8#

Le tabelle seguenti confrontano PyTorch con i motori TensorRT 11.4 FP32, FP16 e INT8 di tutti i modelli di rilevamento YOLO26 e del modello YOLO26n per altre cinque attività. Tutti i valori sono stati misurati su una GPU NVIDIA RTX PRO 6000 Blackwell Server Edition.

Millisecondi per immagine: meno è meglio. Il formato più veloce per ciascun modello è in grassetto; il motore INT8 YOLO26x è escluso perché la sua precisione era instabile.

ModelloimgszPyTorchTensorRT 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 ha mantenuto l'accuratezza di FP32 entro 0,1 punti su ogni modello. Sui modelli di rilevamento è stato da 1,4 a 2,2 volte più veloce del motore FP32 e da 2,8 a 5,9 volte più veloce di PyTorch.
  • INT8 ha avuto una latenza entro il 12% rispetto a FP16 sui modelli di rilevamento e ha perso da 1,7 a 2,9 mAP su YOLO26n, YOLO26s, YOLO26m e YOLO26l. Su questa GPU è stato più veloce di FP16 solo per YOLO26l, YOLO26x e YOLO26n-cls.
  • L'accuratezza di YOLO26x INT8 è scesa a un valore compreso tra 25,3 e 38,5 mAP nelle tre build, rispetto a 57,5 con FP32. YOLO26n-pose INT8 è sceso da 56,7 a 33,4 mAP della posa. Convalida ogni motore INT8 sui tuoi dati prima di distribuirlo.
  • I motori FP32 e FP16 di TensorRT 10.16 per YOLO26n e YOLO26s hanno raggiunto la stessa accuratezza di TensorRT 11.4. I motori FP16 erano circa il 7% più veloci e quelli FP32 dal 4% al 9% più lenti rispetto a TensorRT 11.4.

Per NVIDIA Jetson e DGX Spark, consulta i benchmark Jetson e la guida a DGX Spark.

Misurato con ultralytics 8.4.211, TensorRT 11.4.0, PyTorch 2.15.0 e CUDA 13.2 su batch=1 il 13 novembre 2026. La latenza corrisponde alla fase di inferenza riportata da val e non include il pre-elaborazione né il post-elaborazione.

Informazioni su TensorRT#

TensorRT crea un motore fondendo i layer, selezionando il kernel più veloce per ogni layer sulla GPU usata per la build e, facoltativamente, riducendo la precisione a FP16 o INT8. Per la documentazione completa, consulta la documentazione di TensorRT.

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

Domande frequenti#

  • Solo su una GPU dello stesso modello e con la stessa versione di TensorRT. Un motore viene creato per un modello di GPU e una versione di TensorRT specifici. Per condividere un file tra hardware diversi, esporta in ONNX e crea il motore su ogni dispositivo. Per NVIDIA Jetson, Ultralytics Platform può creare motori per otto modelli Jetson.

  • Inizia con FP16 (quantize=16). Non richiede dati di calibrazione e mantiene l'accuratezza di FP32. Nei benchmark eseguiti su una NVIDIA RTX PRO 6000 Blackwell con TensorRT 11.4, FP16 ha ridotto la latenza di YOLO26s da 1,15 ms a 0,61 ms per immagine, mantenendo lo stesso valore di 48,5 mAPval 50-95. INT8 (quantize=8) ha raggiunto 0,66 ms e 46,3 mAPval 50-95, quindi su quella GPU non è stato più veloce di FP16 e richiede dati di calibrazione rappresentativi, a meno che il checkpoint non sia stato addestrato con quantize=8. INT8 può convenire su altro hardware: i benchmark Jetson riportano i risultati di FP16 e INT8 per i dispositivi embedded. Misura entrambe le precisioni sul dispositivo di distribuzione prima di scegliere INT8.

  • Esporta con dynamic=True e imposta batch sul batch massimo che prevedi di eseguire. Il motore accetta quindi batch da 1 a batch e immagini con dimensioni da 32 pixel fino al doppio di imgsz usato per l'esportazione, con un minimo più alto per i motori INT8 dinamici sulle GPU meno recenti. Senza dynamic=True, il motore usa una sola forma di input fissa e Ultralytics suddivide o completa con padding ogni batch per adattarlo.

    Motore dinamico
    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 batch di 4 immagini
  • Esegui l'esportazione direttamente su Jetson con la versione di TensorRT inclusa nella tua release di JetPack. Per usare un core DLA, aggiungi device=dla:0 con quantize=16 oppure quantize=8. Consulta la guida a NVIDIA Jetson per la configurazione e i benchmark.

    Esportazione su Jetson
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    model.export(format="engine", quantize=16)  # Motore FP16 sulla GPU Jetson
    
    # Oppure crea il motore FP16 per il core DLA 0
    model.export(format="engine", quantize=16, device="dla:0")
  • La guida a Triton Inference Server esporta il modello in ONNX e abilita l'acceleratore TensorRT di Triton in config.pbtxt. Al primo caricamento, Triton crea quindi il motore TensorRT sulla GPU del server e lo memorizza nella cache, così il motore corrisponde sempre alla GPU e alla versione di TensorRT del server. La guida illustra la struttura del repository dei modelli, il container del server e l'inferenza client con Ultralytics.

Commenti116

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

  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(modificato)

      @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