Esportazione TensorRT per modelli YOLO11
Il deployment di modelli di computer vision in ambienti ad alte prestazioni può richiedere un formato che massimizzi velocità ed efficienza. Ciò è particolarmente vero quando si distribuisce il modello su GPU NVIDIA.
Utilizzando il formato di esportazione TensorRT, puoi migliorare i tuoi modelli Ultralytics YOLO11 per un'inferenza rapida ed efficiente sull'hardware NVIDIA. Questa guida ti fornirà passaggi facili da seguire per il processo di conversione e ti aiuterà a sfruttare al meglio la tecnologia avanzata di NVIDIA nei tuoi progetti di deep learning.
TensorRT
TensorRT, sviluppato da NVIDIA, è un kit di sviluppo software (SDK) avanzato progettato per l'inferenza di deep learning ad alta velocità. È adatto per applicazioni in tempo reale come il rilevamento di oggetti.
Questo toolkit ottimizza i modelli di deep learning per le GPU NVIDIA e si traduce in operazioni più veloci ed efficienti. I modelli TensorRT sono sottoposti a ottimizzazione TensorRT, che include tecniche come la fusione di layer, la calibrazione della precisione (INT8 e FP16), la gestione dinamica della memoria tensor e l'auto-tuning del kernel. La conversione di modelli di deep learning nel formato TensorRT consente agli sviluppatori di realizzare appieno il potenziale delle GPU NVIDIA.
TensorRT è noto per la sua compatibilità con vari formati di modello, tra cui TensorFlow, PyTorch e ONNX, fornendo agli sviluppatori una soluzione flessibile per l'integrazione e l'ottimizzazione di modelli provenienti da diversi framework. Questa versatilità consente un deployment del modello efficiente in diversi ambienti hardware e software.
Caratteristiche principali dei modelli TensorRT
I modelli TensorRT offrono una serie di caratteristiche chiave che contribuiscono alla loro efficienza ed efficacia nell'inferenza di deep learning ad alta velocità:
-
Calibrazione di precisione: TensorRT supporta la calibrazione di precisione, consentendo di ottimizzare i modelli per specifici requisiti di accuratezza. Ciò include il supporto per formati a precisione ridotta come INT8 e FP16, che possono ulteriormente aumentare la velocità di inferenza mantenendo livelli di accuratezza accettabili.
-
Fusione dei layer: Il processo di ottimizzazione di TensorRT include la fusione dei layer, in cui più layer di una rete neurale vengono combinati in un'unica operazione. Ciò riduce il sovraccarico computazionale e migliora la velocità di inferenza riducendo al minimo l'accesso alla memoria e il calcolo.
-
Gestione dinamica della memoria dei tensor: TensorRT gestisce in modo efficiente l'utilizzo della memoria dei tensor durante l'inferenza, riducendo il sovraccarico di memoria e ottimizzando l'allocazione della memoria. Ciò si traduce in un utilizzo più efficiente della memoria della GPU.
-
Ottimizzazione automatica del kernel: TensorRT applica l'ottimizzazione automatica del kernel per selezionare il kernel GPU più ottimizzato per ogni livello del modello. Questo approccio adattivo assicura che il modello sfrutti appieno la potenza computazionale delle GPU.
Opzioni di deployment in TensorRT
Prima di esaminare il codice per l'esportazione di modelli YOLO11 nel formato TensorRT, cerchiamo di capire dove vengono normalmente utilizzati i modelli TensorRT.
TensorRT offre diverse opzioni di implementazione, e ciascuna di esse bilancia in modo differente la facilità di integrazione, l'ottimizzazione delle prestazioni e la flessibilità:
- Implementazione all'interno di TensorFlow: Questo metodo integra TensorRT in TensorFlow, consentendo l'esecuzione di modelli ottimizzati in un ambiente TensorFlow familiare. È utile per i modelli con un mix di layer supportati e non supportati, poiché TF-TRT è in grado di gestirli in modo efficiente.
-
API Runtime TensorRT Standalone: Offre un controllo granulare, ideale per applicazioni in cui le prestazioni sono fondamentali. È più complesso, ma consente l'implementazione personalizzata di operatori non supportati.
-
NVIDIA Triton Inference Server: Un'opzione che supporta modelli provenienti da vari framework. Particolarmente adatto per l'inferenza su cloud o edge, fornisce funzionalità come l'esecuzione simultanea di modelli e l'analisi dei modelli.
Esportazione di modelli YOLO11 in TensorRT
Puoi migliorare l'efficienza dell'esecuzione e ottimizzare le prestazioni convertendo i modelli YOLO11 in formato TensorRT.
Installazione
Per installare il pacchetto richiesto, esegui:
Installazione
# Install the required package for YOLO11
pip install ultralytics
Per istruzioni dettagliate e best practice relative al processo di installazione, consulta la nostra guida all'installazione di YOLO11. Durante l'installazione dei pacchetti richiesti per YOLO11, in caso di difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.
Utilizzo
Prima di immergerti nelle istruzioni per l'uso, assicurati di controllare la gamma di modelli YOLO11 offerti da Ultralytics. Questo ti aiuterà a scegliere il modello più appropriato per le esigenze del tuo progetto.
Utilizzo
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")
# Export a YOLO11n PyTorch model to TensorRT format
yolo export model=yolo11n.pt format=engine # creates 'yolo11n.engine''
# Run inference with the exported model
yolo predict model=yolo11n.engine source='https://ultralytics.com/images/bus.jpg'
Argomenti di esportazione
Argomento | Tipo | Predefinito | Descrizione |
---|---|---|---|
format |
str |
'engine' |
Formato di destinazione per il modello esportato, che definisce la compatibilità con vari ambienti di distribuzione. |
imgsz |
int oppure tuple |
640 |
Dimensione dell'immagine desiderata per l'input del modello. Può essere un numero intero per immagini quadrate o una tupla (height, width) per dimensioni specifiche. |
half |
bool |
False |
Abilita la quantizzazione FP16 (mezza precisione), riducendo le dimensioni del modello e potenzialmente accelerando l'inferenza su hardware supportato. |
int8 |
bool |
False |
Attiva la quantizzazione INT8, comprimendo ulteriormente il modello e accelerando l'inferenza con una perdita di accuratezza minima, principalmente per i dispositivi edge. |
dynamic |
bool |
False |
Consente dimensioni di input dinamiche, migliorando la flessibilità nella gestione di diverse dimensioni delle immagini. |
simplify |
bool |
True |
Semplifica il grafo del modello con onnxslim , migliorando potenzialmente le prestazioni e la compatibilità. |
workspace |
float oppure None |
None |
Imposta la dimensione massima dello spazio di lavoro in GiB per le ottimizzazioni TensorRT, bilanciando l'utilizzo della memoria e le prestazioni; usa None per l'allocazione automatica da parte di TensorRT fino al massimo del dispositivo. |
nms |
bool |
False |
Aggiunge la Non-Maximum Suppression (NMS), essenziale per una post-elaborazione del rilevamento accurata ed efficiente. |
batch |
int |
1 |
Specifica la dimensione del batch di inferenza del modello di esportazione o il numero massimo di immagini che il modello esportato elaborerà contemporaneamente in modalità predict . |
data |
str |
'coco8.yaml' |
Percorso del dataset file di configurazione (predefinito: coco8.yaml ), essenziale per la quantizzazione. |
fraction |
float |
1.0 |
Specifica la frazione del dataset da utilizzare per la calibrazione della quantizzazione INT8. Consente la calibrazione su un sottoinsieme del dataset completo, utile per esperimenti o quando le risorse sono limitate. Se non specificato con INT8 abilitato, verrà utilizzato l'intero dataset. |
device |
str |
None |
Specifica il dispositivo per l'esportazione: GPU (device=0 ), DLA per NVIDIA Jetson (device=dla:0 oppure device=dla:1 ). |
Suggerimento
Assicurati di utilizzare una GPU con supporto CUDA quando esporti in TensorRT.
Per maggiori dettagli sul processo di esportazione, visita la pagina della documentazione di Ultralytics sull'esportazione.
Esportazione di TensorRT con quantizzazione INT8
L'esportazione di modelli Ultralytics YOLO utilizzando TensorRT con precisione INT8 esegue la quantizzazione post-training (PTQ). TensorRT utilizza la calibrazione per la PTQ, che misura la distribuzione delle attivazioni all'interno di ciascun tensor di attivazione mentre il modello YOLO elabora l'inferenza sui dati di input rappresentativi, e quindi utilizza tale distribuzione per stimare i valori di scala per ciascun tensor. Ogni tensor di attivazione candidato alla quantizzazione ha una scala associata che viene dedotta da un processo di calibrazione.
Quando elabora reti quantizzate implicitamente, TensorRT utilizza INT8 in modo opportunistico per ottimizzare i tempi di esecuzione dei layer. Se un layer viene eseguito più velocemente in INT8 e ha scale di quantizzazione assegnate ai suoi input e output di dati, allora a quel layer viene assegnato un kernel con precisione INT8, altrimenti TensorRT seleziona una precisione di FP32 o FP16 per il kernel in base a quale risulta in un tempo di esecuzione più veloce per quel layer.
Suggerimento
È fondamentale assicurarsi che lo stesso dispositivo che utilizzerà i pesi del modello TensorRT per l'implementazione venga utilizzato per l'esportazione con precisione INT8, poiché i risultati della calibrazione possono variare da un dispositivo all'altro.
Configurazione dell'esportazione INT8
Gli argomenti forniti quando si utilizza export per un modello Ultralytics YOLO influenzeranno notevolmente le prestazioni del modello esportato. Dovranno anche essere selezionati in base alle risorse del dispositivo disponibili, tuttavia gli argomenti predefiniti dovrebbero funzionare per la maggior parte delle GPU NVIDIA discrete Ampere (o più recenti). L'algoritmo di calibrazione utilizzato è "MINMAX_CALIBRATION"
e puoi leggere maggiori dettagli sulle opzioni disponibili nella Guida per sviluppatori di TensorRT. I test Ultralytics hanno rilevato che "MINMAX_CALIBRATION"
era la scelta migliore e le esportazioni sono fisse per l'utilizzo di questo algoritmo.
-
workspace
: Controlla la dimensione (in GiB) dell'allocazione della memoria del dispositivo durante la conversione dei pesi del modello.-
Regola il valore di
workspace
in base alle tue esigenze di calibrazione e alla disponibilità di risorse. Mentre un valore più grandeworkspace
può aumentare il tempo di calibrazione, ma consente a TensorRT di esplorare una gamma più ampia di tattiche di ottimizzazione, migliorando potenzialmente le prestazioni del modello e accuratezza. Al contrario, un valore più piccoloworkspace
può ridurre il tempo di calibrazione, ma potrebbe limitare le strategie di ottimizzazione, influenzando la qualità del modello quantizzato. -
Il valore predefinito è
workspace=None
, che consentirà a TensorRT di allocare automaticamente la memoria; quando si configura manualmente, questo valore potrebbe dover essere aumentato se la calibrazione si arresta in modo anomalo (si chiude senza preavviso). -
TensorRT segnalerà
UNSUPPORTED_STATE
durante l'esportazione se il valore diworkspace
è superiore alla memoria disponibile per il dispositivo, il che significa che è necessario ridurre il valore diworkspace
dovrebbe essere abbassato o impostato suNone
. -
Se
workspace
è impostato al valore massimo e la calibrazione fallisce/si blocca, considera l'utilizzo diNone
per l'allocazione automatica o riducendo i valori diimgsz
ebatch
per ridurre i requisiti di memoria. -
Ricorda: la calibrazione per INT8 è specifica per ogni dispositivo. Utilizzare una GPU "di fascia alta" per la calibrazione potrebbe comportare prestazioni scadenti quando l'inferenza viene eseguita su un altro dispositivo.
-
-
batch
: la dimensione massima del batch che verrà utilizzata per l'inferenza. Durante l'inferenza è possibile utilizzare batch più piccoli, ma l'inferenza non accetterà batch più grandi di quelli specificati.
Nota
Durante la calibrazione, verrà utilizzata una dimensione doppia di batch
fornita. L'utilizzo di batch piccoli può portare a un ridimensionamento inaccurato durante la calibrazione. Questo perché il processo si adatta in base ai dati che vede. Batch piccoli potrebbero non catturare l'intera gamma di valori, portando a problemi con la calibrazione finale, quindi la dimensione di batch
viene raddoppiata automaticamente. Se non viene specificato alcun valore per dimensione del batch , batch=1
, la calibrazione verrà eseguita con batch=1 * 2
per ridurre gli errori di ridimensionamento della calibrazione.
La sperimentazione di NVIDIA ha portato a raccomandare l'utilizzo di almeno 500 immagini di calibrazione che siano rappresentative dei dati per il tuo modello, con la calibrazione della quantizzazione INT8. Questa è una linea guida e non un requisito rigido , e dovrai sperimentare con ciò che è necessario per ottenere buone prestazioni per il tuo set di dati. Poiché i dati di calibrazione sono necessari per la calibrazione INT8 con TensorRT, assicurati di utilizzare l'argomento data
quando int8=True
per TensorRT e usa data="my_dataset.yaml"
, che utilizzerà le immagini dalla convalida per la calibrazione. Quando non viene passato alcun valore per data
con l'esportazione in TensorRT con quantizzazione INT8, il valore predefinito sarà l'utilizzo di uno dei dataset di esempio "small" basati sull'attività del modello invece di generare un errore.
Esempio
from ultralytics import YOLO
model = YOLO("yolov8n.pt")
model.export(
format="engine",
dynamic=True, # (1)!
batch=8, # (2)!
workspace=4, # (3)!
int8=True,
data="coco.yaml", # (4)!
)
# Load the exported TensorRT INT8 model
model = YOLO("yolov8n.engine", task="detect")
# Run inference
result = model.predict("https://ultralytics.com/images/bus.jpg")
- Esportazioni con assi dinamici, questo sarà abilitato di default quando si esporta con
int8=True
anche quando non impostato esplicitamente. Vedi argomenti di esportazione per ulteriori informazioni. - Imposta la dimensione massima del batch a 8 per il modello esportato, che si calibra con
batch = 2 * 8
per evitare errori di ridimensionamento durante la calibrazione. - Alloca 4 GiB di memoria invece di allocare l'intero dispositivo per il processo di conversione.
- Utilizza il dataset COCO per la calibrazione, nello specifico le immagini utilizzate per la convalida (5.000 totali).
# Export a YOLO11n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolo11n.pt format=engine batch=8 workspace=4 int8=True data=coco.yaml # creates 'yolov8n.engine''
# Run inference with the exported TensorRT quantized model
yolo predict model=yolov8n.engine source='https://ultralytics.com/images/bus.jpg'
Cache di calibrazione
TensorRT genererà una calibrazione .cache
che può essere riutilizzato per accelerare l'esportazione dei futuri pesi del modello utilizzando gli stessi dati, ma ciò potrebbe comportare una calibrazione insufficiente quando i dati sono molto diversi o se il batch
il valore viene modificato drasticamente. In queste circostanze, l'esistente .cache
dovrebbe essere rinominato e spostato in una directory diversa o eliminato completamente.
Vantaggi dell'utilizzo di YOLO con TensorRT INT8
-
Dimensione del modello ridotta: La quantizzazione da FP32 a INT8 può ridurre la dimensione del modello di 4 volte (su disco o in memoria), portando a tempi di download più rapidi, minori requisiti di archiviazione e un ingombro di memoria ridotto durante la distribuzione di un modello.
-
Minore consumo energetico: Le operazioni a precisione ridotta per i modelli YOLO esportati in INT8 possono consumare meno energia rispetto ai modelli FP32, soprattutto per i dispositivi alimentati a batteria.
-
Velocità di inferenza migliorate: TensorRT ottimizza il modello per l'hardware di destinazione, portando potenzialmente a velocità di inferenza più elevate su GPU, dispositivi embedded e acceleratori.
Nota sulle velocità di inferenza
È prevedibile che le prime chiamate di inferenza con un modello esportato in TensorRT INT8 abbiano tempi di pre-elaborazione, inferenza e/o post-elaborazione più lunghi del solito. Questo può verificarsi anche quando si cambia imgsz
durante l'inferenza, specialmente quando imgsz
non è lo stesso di quello specificato durante l'esportazione (export imgsz
è impostato come profilo "ottimale" di TensorRT).
Svantaggi dell'utilizzo di YOLO con TensorRT INT8
-
Diminuzioni nelle metriche di valutazione: L'utilizzo di una precisione inferiore implicherà che
mAP
,Precision
,Recall
o qualsiasi altra metrica utilizzata per valutare le prestazioni del modello probabilmente sarà leggermente peggiore. Consultare la sezione Sezione risultati delle prestazioni per confrontare le differenze inmAP50
emAP50-95
durante l'esportazione con INT8 su un piccolo campione di vari dispositivi. -
Tempi di sviluppo maggiori: Trovare le impostazioni "ottimali" per la calibrazione INT8 per il set di dati e il dispositivo può richiedere una notevole quantità di test.
-
Dipendenza dall'hardware: La calibrazione e i miglioramenti delle prestazioni potrebbero dipendere fortemente dall'hardware e i pesi del modello sono meno trasferibili.
Prestazioni di esportazione Ultralytics YOLO TensorRT
NVIDIA A100
Prestazioni
Testato con Ubuntu 22.04.3 LTS, python 3.10.12
, ultralytics==8.2.4
, tensorrt==8.6.1.post1
Vedere Documentazione sul rilevamento per esempi di utilizzo con questi modelli addestrati su COCO, che includono 80 classi pre-addestrate.
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|
FP32 | Predizione | 0.52 | 0.51 | 0.56 | 8 | 640 | ||
FP32 | COCOval | 0.52 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Predizione | 0.34 | 0.34 | 0.41 | 8 | 640 | ||
FP16 | COCOval | 0.33 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Predizione | 0.28 | 0.27 | 0.31 | 8 | 640 | ||
INT8 | COCOval | 0.29 | 0.47 | 0.33 | 1 | 640 |
Consulta la documentazione sulla segmentazione per esempi di utilizzo con questi modelli addestrati su COCO, che include 80 classi pre-addestrate.
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n-seg.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
mAPval 50(M) |
mAPval 50-95(M) |
batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|---|---|
FP32 | Predizione | 0.62 | 0.61 | 0.68 | 8 | 640 | ||||
FP32 | COCOval | 0.63 | 0.52 | 0.36 | 0.49 | 0.31 | 1 | 640 | |
FP16 | Predizione | 0.40 | 0.39 | 0.44 | 8 | 640 | ||||
FP16 | COCOval | 0.43 | 0.52 | 0.36 | 0.49 | 0.30 | 1 | 640 | |
INT8 | Predizione | 0.34 | 0.33 | 0.37 | 8 | 640 | ||||
INT8 | COCOval | 0.36 | 0.46 | 0.32 | 0.43 | 0.27 | 1 | 640 |
Consulta la documentazione sulla classificazione per esempi di utilizzo con questi modelli addestrati su ImageNet, che include 1000 classi pre-addestrate.
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n-cls.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
top-1 | top-5 | batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|
FP32 | Predizione | 0.26 | 0.25 | 0.28 | 8 | 640 | ||
FP32 | ImageNetval | 0.26 | 0.35 | 0.61 | 1 | 640 | |
FP16 | Predizione | 0.18 | 0.17 | 0.19 | 8 | 640 | ||
FP16 | ImageNetval | 0.18 | 0.35 | 0.61 | 1 | 640 | |
INT8 | Predizione | 0.16 | 0.15 | 0.57 | 8 | 640 | ||
INT8 | ImageNetval | 0.15 | 0.32 | 0.59 | 1 | 640 |
Consulta la documentazione sulla stima della posa per esempi di utilizzo con questi modelli addestrati su COCO, che include 1 classe pre-addestrata, "person".
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n-pose.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
mAPval 50(P) |
mAPval 50-95(P) |
batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|---|---|
FP32 | Predizione | 0.54 | 0.53 | 0.58 | 8 | 640 | ||||
FP32 | COCOval | 0.55 | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | |
FP16 | Predizione | 0.37 | 0.35 | 0.41 | 8 | 640 | ||||
FP16 | COCOval | 0.36 | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | |
INT8 | Predizione | 0.29 | 0.28 | 0.33 | 8 | 640 | ||||
INT8 | COCOval | 0.30 | 0.90 | 0.68 | 0.78 | 0.47 | 1 | 640 |
Consulta la documentazione sul rilevamento orientato per esempi di utilizzo con questi modelli addestrati su DOTAv1, che include 15 classi pre-addestrate.
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n-obb.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|
FP32 | Predizione | 0.52 | 0.51 | 0.59 | 8 | 640 | ||
FP32 | DOTAv1val | 0.76 | 0.50 | 0.36 | 1 | 640 | |
FP16 | Predizione | 0.34 | 0.33 | 0.42 | 8 | 640 | ||
FP16 | DOTAv1val | 0.59 | 0.50 | 0.36 | 1 | 640 | |
INT8 | Predizione | 0.29 | 0.28 | 0.33 | 8 | 640 | ||
INT8 | DOTAv1val | 0.32 | 0.45 | 0.32 | 1 | 640 |
GPU consumer
Prestazioni di rilevamento (COCO)
Testato con Windows 10.0.19045, python 3.10.9
, ultralytics==8.2.4
, tensorrt==10.0.0b6
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|
FP32 | Predizione | 1.06 | 0.75 | 1.88 | 8 | 640 | ||
FP32 | COCOval | 1.37 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Predizione | 0.62 | 0.75 | 1.13 | 8 | 640 | ||
FP16 | COCOval | 0.85 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Predizione | 0.52 | 0.38 | 1.00 | 8 | 640 | ||
INT8 | COCOval | 0.74 | 0.47 | 0.33 | 1 | 640 |
Testato con Windows 10.0.22631, python 3.11.9
, ultralytics==8.2.4
, tensorrt==10.0.1
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|
FP32 | Predizione | 1.76 | 1.69 | 1.87 | 8 | 640 | ||
FP32 | COCOval | 1.94 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Predizione | 0.86 | 0.75 | 1.00 | 8 | 640 | ||
FP16 | COCOval | 1.43 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Predizione | 0.80 | 0.75 | 1.00 | 8 | 640 | ||
INT8 | COCOval | 1.35 | 0.47 | 0.33 | 1 | 640 |
Testato con Pop!_OS 22.04 LTS, python 3.10.12
, ultralytics==8.2.4
, tensorrt==8.6.1.post1
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|
FP32 | Predizione | 2.84 | 2.84 | 2.85 | 8 | 640 | ||
FP32 | COCOval | 2.94 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Predizione | 1.09 | 1.09 | 1.10 | 8 | 640 | ||
FP16 | COCOval | 1.20 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Predizione | 0.75 | 0.74 | 0.75 | 8 | 640 | ||
INT8 | COCOval | 0.76 | 0.47 | 0.33 | 1 | 640 |
Dispositivi embedded
Prestazioni di rilevamento (COCO)
Testato con JetPack 6.0 (L4T 36.3) Ubuntu 22.04.4 LTS, python 3.10.12
, ultralytics==8.2.16
, tensorrt==10.0.1
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce) e max
(più lento) per ogni test utilizzando pesi pre-addestrati yolov8n.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
mAPval 50(B) |
mAPval 50-95(B) |
batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|
FP32 | Predizione | 6.11 | 6.10 | 6.29 | 8 | 640 | ||
FP32 | COCOval | 6.17 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Predizione | 3.18 | 3.18 | 3.20 | 8 | 640 | ||
FP16 | COCOval | 3.19 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Predizione | 2.30 | 2.29 | 2.35 | 8 | 640 | ||
INT8 | COCOval | 2.32 | 0.46 | 0.32 | 1 | 640 |
Info
Consulta la nostra guida rapida su NVIDIA Jetson con Ultralytics YOLO per saperne di più sulla configurazione.
Metodi di valutazione
Espandi le sezioni sottostanti per informazioni su come questi modelli sono stati esportati e testati.
Configurazioni di esportazione
Vedere la modalità di esportazione per i dettagli relativi agli argomenti di configurazione dell'esportazione.
from ultralytics import YOLO
model = YOLO("yolov8n.pt")
# TensorRT FP32
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2)
# TensorRT FP16
out = model.export(format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, half=True)
# TensorRT INT8 with calibration `data` (i.e. COCO, ImageNet, or DOTAv1 for appropriate model task)
out = model.export(
format="engine", imgsz=640, dynamic=True, verbose=False, batch=8, workspace=2, int8=True, data="coco8.yaml"
)
Ciclo di previsione
Vedere la modalità di previsione per ulteriori informazioni.
import cv2
from ultralytics import YOLO
model = YOLO("yolov8n.engine")
img = cv2.imread("path/to/image.jpg")
for _ in range(100):
result = model.predict(
[img] * 8, # batch=8 of the same image
verbose=False,
device="cuda",
)
Configurazione di convalida
Vedere val
mode per saperne di più sugli argomenti di configurazione della convalida.
from ultralytics import YOLO
model = YOLO("yolov8n.engine")
results = model.val(
data="data.yaml", # COCO, ImageNet, or DOTAv1 for appropriate model task
batch=1,
imgsz=640,
verbose=False,
device="cuda",
)
Distribuzione di modelli TensorRT YOLO11 esportati
Dopo aver esportato con successo i tuoi modelli Ultralytics YOLO11 in formato TensorRT, sei ora pronto per distribuirli. Per istruzioni dettagliate sulla distribuzione dei tuoi modelli TensorRT in varie impostazioni, dai un'occhiata alle seguenti risorse:
-
Distribuisci Ultralytics con un server Triton: La nostra guida su come utilizzare il server NVIDIA Triton Inference (precedentemente TensorRT Inference) specificamente per l'uso con i modelli Ultralytics YOLO.
-
Distribuzione di reti neurali profonde con NVIDIA TensorRT: Questo articolo spiega come utilizzare NVIDIA TensorRT per distribuire in modo efficiente reti neurali profonde su piattaforme di distribuzione basate su GPU.
-
AI end-to-end per PC basati su NVIDIA: Distribuzione NVIDIA TensorRT: Questo articolo del blog spiega l'uso di NVIDIA TensorRT per ottimizzare e distribuire modelli di intelligenza artificiale su PC basati su NVIDIA.
-
Repository GitHub per NVIDIA TensorRT:: Questo è il repository GitHub ufficiale che contiene il codice sorgente e la documentazione per NVIDIA TensorRT.
Riepilogo
In questa guida, ci siamo concentrati sulla conversione dei modelli Ultralytics YOLO11 nel formato modello TensorRT di NVIDIA. Questo passaggio di conversione è fondamentale per migliorare l'efficienza e la velocità dei modelli YOLO11, rendendoli più efficaci e adatti a diversi ambienti di implementazione.
Per ulteriori informazioni sui dettagli di utilizzo, dai un'occhiata alla documentazione ufficiale di TensorRT.
Se sei curioso di conoscere ulteriori integrazioni di Ultralytics YOLO11, la nostra pagina della guida all'integrazione fornisce un'ampia selezione di risorse informative e approfondimenti.
FAQ
Come posso convertire i modelli YOLO11 nel formato TensorRT?
Per convertire i tuoi modelli Ultralytics YOLO11 in formato TensorRT per un'inferenza NVIDIA GPU ottimizzata, segui questi passaggi:
-
Installa il pacchetto richiesto:
pip install ultralytics
-
Esporta il tuo modello YOLO11:
from ultralytics import YOLO model = YOLO("yolo11n.pt") model.export(format="engine") # creates 'yolo11n.engine' # Run inference model = YOLO("yolo11n.engine") results = model("https://ultralytics.com/images/bus.jpg")
Per maggiori dettagli, visita la guida all'installazione di YOLO11 e la documentazione sull'export.
Quali sono i vantaggi dell'utilizzo di TensorRT per i modelli YOLO11?
L'utilizzo di TensorRT per ottimizzare i modelli YOLO11 offre diversi vantaggi:
- Velocità di inferenza più elevata: TensorRT ottimizza i livelli del modello e utilizza la calibrazione della precisione (INT8 e FP16) per accelerare l'inferenza senza sacrificare significativamente l'accuratezza.
- Efficienza della memoria: TensorRT gestisce dinamicamente la memoria dei tensor, riducendo il sovraccarico e migliorando l'utilizzo della memoria della GPU.
- Fusione di livelli: Combina più livelli in singole operazioni, riducendo la complessità computazionale.
- Auto-tuning del kernel: Seleziona automaticamente i kernel GPU ottimizzati per ogni livello del modello, garantendo le massime prestazioni.
Per saperne di più, esplora la documentazione ufficiale di TensorRT di NVIDIA e la nostra panoramica approfondita di TensorRT.
Posso utilizzare la quantizzazione INT8 con TensorRT per i modelli YOLO11?
Sì, puoi esportare i modelli YOLO11 usando TensorRT con quantizzazione INT8. Questo processo include la quantizzazione post-training (PTQ) e la calibrazione:
-
Esporta con INT8:
from ultralytics import YOLO model = YOLO("yolov8n.pt") model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml")
-
Esegui l'inferenza:
from ultralytics import YOLO model = YOLO("yolov8n.engine", task="detect") result = model.predict("https://ultralytics.com/images/bus.jpg")
Per maggiori dettagli, fare riferimento alla sezione sull'esportazione di TensorRT con quantizzazione INT8.
Come posso distribuire modelli YOLO11 TensorRT su un NVIDIA Triton Inference Server?
La distribuzione di modelli TensorRT YOLO11 su un NVIDIA Triton Inference Server può essere eseguita utilizzando le seguenti risorse:
- Distribuisci Ultralytics YOLOv8 con il server Triton: Guida dettagliata sulla configurazione e l'utilizzo del server Triton Inference.
- Documentazione del server NVIDIA Triton Inference: Documentazione NVIDIA ufficiale per opzioni e configurazioni di distribuzione dettagliate.
Queste guide ti aiuteranno a integrare i modelli YOLOv8 in modo efficiente in vari ambienti di implementazione.
Quali sono i miglioramenti delle prestazioni osservati con i modelli YOLOv8 esportati in TensorRT?
I miglioramenti delle prestazioni con TensorRT possono variare in base all'hardware utilizzato. Ecco alcuni benchmark tipici:
-
NVIDIA A100:
- Inferenza FP32: ~0,52 ms / immagine
- Inferenza FP16: ~0,34 ms / immagine
- Inferenza INT8: ~0,28 ms / immagine
- Leggera riduzione della mAP con precisione INT8, ma significativo miglioramento della velocità.
-
GPU consumer (ad esempio, RTX 3080):
- Inferenza FP32: ~1,06 ms / immagine
- Inferenza FP16: ~0,62 ms / immagine
- Inferenza INT8: ~0,52 ms / immagine
Benchmark dettagliati delle prestazioni per diverse configurazioni hardware sono disponibili nella sezione prestazioni.
Per approfondimenti più completi sulle prestazioni di TensorRT, consulta la documentazione di Ultralytics e i nostri report di analisi delle prestazioni.