TensorRT Esportazione per i modelli di YOLOv8
La distribuzione di modelli di computer vision in ambienti ad alte prestazioni può richiedere un formato che massimizzi la velocità e l'efficienza. Ciò è particolarmente vero quando il modello viene distribuito su GPU NVIDIA .
Utilizzando il formato di esportazione di TensorRT , potrai migliorare i tuoi Ultralytics YOLOv8 modelli per un'inferenza rapida ed efficiente su hardware NVIDIA . Questa guida ti fornirà i passaggi più semplici 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 apprendimento profondo ad alta velocità . È adatto ad applicazioni in tempo reale come il rilevamento di oggetti.
Questo toolkit ottimizza i modelli di deep learning per le GPU NVIDIA e consente di ottenere operazioni più rapide ed efficienti. I modelli TensorRT vengono sottoposti all'ottimizzazione TensorRT , che comprende tecniche come la fusione dei livelli, la calibrazione della precisione (INT8 e FP16), la gestione dinamica della memoria tensor e l'autotuning del kernel. La conversione dei modelli di deep learning nel formato TensorRT permette agli sviluppatori di sfruttare appieno il potenziale delle GPU NVIDIA .
TensorRT è noto per la sua compatibilità con diversi formati di modelli, tra cui TensorFlow, PyTorch, e ONNX, offrendo agli sviluppatori una soluzione flessibile per l'integrazione e l'ottimizzazione di modelli provenienti da framework diversi. Questa versatilità consente un'efficiente distribuzione dei modelli in diversi ambienti hardware e software.
Caratteristiche principali dei modelli TensorRT
TensorRT I modelli 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 regolare i modelli in base a specifici requisiti di accuratezza. Questo include il supporto di formati a precisione ridotta come INT8 e FP16, che possono aumentare ulteriormente la velocità di inferenza mantenendo livelli di accuratezza accettabili.
-
Fusione di livelli: Il processo di ottimizzazione di TensorRT include la fusione dei livelli, in cui più livelli di una rete neurale vengono combinati in un'unica operazione. Questo riduce l'overhead computazionale e migliora la velocità di inferenza minimizzando l'accesso alla memoria e il calcolo.
-
Gestione dinamica della memoria di Tensor : TensorRT gestisce in modo efficiente l'utilizzo della memoria di tensor durante l'inferenza, riducendo l'overhead della memoria e ottimizzando l'allocazione della stessa. Questo si traduce in un utilizzo più efficiente della memoria di GPU .
-
Sintonizzazione automatica del kernel: TensorRT applica una sintonizzazione automatica del kernel per selezionare il kernel GPU più ottimizzato per ogni strato del modello. Questo approccio adattivo garantisce che il modello sfrutti appieno la potenza di calcolo di GPU.
Opzioni di distribuzione in TensorRT
Prima di esaminare il codice per l'esportazione YOLOv8 modelli al TensorRT formato, capiamo dove TensorRT normalmente vengono utilizzati modelli.
TensorRT offre diverse opzioni di implementazione e ognuna di esse bilancia la facilità di integrazione, l'ottimizzazione delle prestazioni e la flessibilità in modo diverso:
- Distribuzione all'interno di TensorFlow: questo metodo integra TensorRT in TensorFlow, consentendo ai modelli ottimizzati di essere eseguiti in un ambiente familiare come TensorFlow . È utile per i modelli con un mix di livelli supportati e non supportati, in quanto TF-TRT può gestirli in modo efficiente.
-
API runtime standalone TensorRT : Offre un controllo granulare, ideale per le applicazioni critiche dal punto di vista delle prestazioni. È più complessa, ma consente l'implementazione personalizzata di operatori non supportati.
-
NVIDIA Triton Server di inferenza: Un'opzione che supporta modelli di vari framework. Particolarmente adatto per l'inferenza nel cloud o in rete, offre funzioni come l'esecuzione concorrente del modello e l'analisi del modello.
Esportare i modelli di YOLOv8 in TensorRT
Puoi migliorare l'efficienza dell'esecuzione e ottimizzare le prestazioni convertendo i modelli di YOLOv8 in formato TensorRT .
Installazione
Per installare il pacchetto richiesto, esegui:
Per istruzioni dettagliate e buone pratiche relative al processo di installazione, consulta la nostra Guida all'installazione diYOLOv8 . Durante l'installazione dei pacchetti necessari per YOLOv8, se dovessi incontrare delle difficoltà , consulta la nostra guida sui problemi comuni per trovare soluzioni e suggerimenti.
Utilizzo
Prima di immergerti nelle istruzioni per l'uso, assicurati di dare un'occhiata alla gamma di modelli diYOLOv8 offerti da Ultralytics. Questo ti aiuterà a scegliere il modello più adatto alle esigenze del tuo progetto.
Utilizzo
from ultralytics import YOLO
# Load the YOLOv8 model
model = YOLO("yolov8n.pt")
# Export the model to TensorRT format
model.export(format="engine") # creates 'yolov8n.engine'
# Load the exported TensorRT model
tensorrt_model = YOLO("yolov8n.engine")
# Run inference
results = tensorrt_model("https://ultralytics.com/images/bus.jpg")
Per maggiori dettagli sul processo di esportazione, visita la pagina di documentazione diUltralytics sull'esportazione.
Esportazione di TensorRT con quantizzazione INT8
L'esportazione dei 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 ogni tensor attivazione mentre il modello YOLO elabora l'inferenza su dati di input rappresentativi, e quindi utilizza tale distribuzione per stimare i valori di scala per ogni tensor attivazione. Ogni attivazione tensor candidata alla quantizzazione ha una scala associata che viene dedotta da un processo di calibrazione.
Quando elabora reti con quantizzazione implicita, TensorRT utilizza INT8 in modo opportunistico per ottimizzare il tempo di esecuzione dei livelli. Se un livello funziona più velocemente in INT8 e ha assegnato delle scale di quantizzazione ai suoi ingressi e uscite di dati, allora a quel livello viene assegnato un kernel con precisione INT8, altrimenti TensorRT seleziona una precisione di FP32 o FP16 per il kernel in base a quella che risulta in un tempo di esecuzione più veloce per quel livello.
Suggerimento
È fondamentale assicurarsi che lo stesso dispositivo che utilizzerà i pesi del modello TensorRT per la distribuzione sia 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 usa esportazione per un modello Ultralytics YOLO molto influenzano le prestazioni del modello esportato. Dovranno essere selezionati anche in base alle risorse del dispositivo disponibili, tuttavia gli argomenti predefiniti sono dovrebbe funziona per la maggior parte GPU discrete Ampere (o più recenti) NVIDIA. L'algoritmo di calibrazione utilizzato è "ENTROPY_CALIBRATION_2"
e potrai leggere ulteriori dettagli sulle opzioni disponibili nella Guida per gli sviluppatori di TensorRT. Ultralytics test hanno rilevato che "ENTROPY_CALIBRATION_2"
è stata la scelta migliore e le esportazioni sono fissate 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 la posizione 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 permette a TensorRT di esplorare una gamma più ampia di tattiche di ottimizzazione, potenzialmente migliorando le prestazioni e l'accuratezza del modello. Al contrario, un modello più piccoloworkspace
può ridurre i tempi di calibrazione, ma può limitare le strategie di ottimizzazione, incidendo sulla qualità del modello quantizzato. -
L'impostazione predefinita è
workspace=4
(GiB), questo valore potrebbe dover essere aumentato se la calibrazione si blocca (esce senza preavviso). -
TensorRT riporterÃ
UNSUPPORTED_STATE
durante l'esportazione se il valore diworkspace
è più grande della memoria disponibile per il dispositivo, il che significa che il valore diworkspace
dovrebbe essere abbassato. -
Se
workspace
è impostato sul valore massimo e la calibrazione fallisce/si blocca, considera di ridurre i valori diimgsz
ebatch
per ridurre i requisiti di memoria. -
Ricorda che la calibrazione per l'INT8 è specifica per ogni dispositivo; prendere in prestito un 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 lotto che verrà utilizzata per l'inferenza. Durante l'inferenza è possibile utilizzare lotti più piccoli, ma l'inferenza non accetterà lotti più grandi di quello specificato.
Nota
Durante la calibrazione, due volte il tasto batch
saranno utilizzate le dimensioni fornite. L'utilizzo di piccoli lotti può portare a una scalatura imprecisa durante la calibrazione. Questo perché il processo si regola in base ai dati che vede. I piccoli lotti potrebbero non catturare l'intera gamma di valori, causando problemi nella calibrazione finale. batch
viene raddoppiata automaticamente. Se non viene specificata la dimensione del lotto batch=1
la calibrazione verrà eseguita a batch=1 * 2
per ridurre gli errori di scala della calibrazione.
La sperimentazione di NVIDIA ha portato a consigliare l'utilizzo di almeno 500 immagini di calibrazione rappresentative dei dati del modello, con calibrazione di quantizzazione INT8. Si tratta di una linea guida e non di un duro e dovrai sperimentare ciò che è necessario per ottenere buone prestazioni per il tuo set di dati. Dato che i dati di calibrazione sono necessari per la calibrazione INT8 con TensorRT, assicurati di utilizzare il metodo data
argomento quando int8=True
per TensorRT e utilizzare data="my_dataset.yaml"
che utilizzerà le immagini di convalida con cui effettuare la calibrazione. Quando non viene passato alcun valore per data
con l'esportazione in TensorRT con quantizzazione INT8, l'impostazione predefinita sarà quella di utilizzare uno dei seguenti parametri "piccoli" set di dati di esempio basati sul modello di attività invece di lanciare 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 per impostazione predefinita quando si esporta con
int8=True
anche se non è stato impostato esplicitamente. Vedi argomenti di esportazione per ulteriori informazioni. - Imposta una dimensione massima di 8 lotti per il modello esportato, che si calibra con
batch = 2 * 8
per evitare errori di scala durante la calibrazione. - Alloca 4 GiB di memoria invece di allocare l'intero dispositivo per il processo di conversione.
- Utilizza il set di dati COCO per la calibrazione, in particolare le immagini utilizzate per la convalida (5.000 in totale).
# Export a YOLOv8n PyTorch model to TensorRT format with INT8 quantization
yolo export model=yolov8n.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 pesi dei modelli futuri utilizzando gli stessi dati, ma questo può portare a una calibrazione scadente quando i dati sono molto diversi o se i pesi del modello sono molto diversi. batch
valore viene modificato drasticamente. In queste circostanze, l'attuale .cache
dovrebbe essere rinominato e spostato in un'altra directory o eliminato del tutto.
Vantaggi dell'utilizzo di YOLO con TensorRT INT8
-
Riduzione delle dimensioni del modello: La quantizzazione da FP32 a INT8 può ridurre le dimensioni del modello di 4 volte (su disco o in memoria), con conseguenti tempi di download più rapidi, minori requisiti di archiviazione e un'impronta di memoria ridotta quando si distribuisce un modello.
-
Consumo energetico ridotto: Le operazioni a precisione ridotta per i modelli INT8 esportati da YOLO possono consumare meno energia rispetto ai modelli FP32, soprattutto per i dispositivi alimentati a batteria.
-
Miglioramento della velocità di inferenza: TensorRT ottimizza il modello per l'hardware di destinazione, consentendo potenzialmente una maggiore velocità di inferenza su GPU, dispositivi embedded e acceleratori.
Nota sulle velocità di inferenza
Le prime chiamate di inferenza con un modello esportato in TensorRT INT8 possono avere tempi di preelaborazione, inferenza e/o postelaborazione più lunghi del solito. Questo può accadere anche quando si cambia imgsz
durante l'inferenza, soprattutto quando imgsz
non è uguale a quello specificato durante l'esportazione (export imgsz
è impostato come TensorRT profilo "ottimale").
Svantaggi dell'utilizzo di YOLO con TensorRT INT8
-
Diminuzione delle metriche di valutazione: L'utilizzo di una precisione inferiore significa che
mAP
,Precision
,Recall
o qualsiasi altre metriche utilizzate per valutare le prestazioni del modello è probabile che sia un po' peggiore. Vedi il Sezione risultati delle prestazioni per confrontare le differenze dimAP50
emAP50-95
quando si esporta con INT8 su un piccolo campione di vari dispositivi. -
Aumento dei tempi di sviluppo: Trovare le impostazioni "ottimali" per la calibrazione INT8 in base al set di dati e al dispositivo può richiedere una quantità significativa di test.
-
Dipendenza dall'hardware: La calibrazione e i guadagni di prestazioni potrebbero dipendere fortemente dall'hardware e i pesi dei modelli sono meno trasferibili.
Ultralytics YOLO TensorRT Prestazioni di esportazione
NVIDIA A100
Prestazioni
Testato con Ubuntu 22.04.3 LTS, python 3.10.12
, ultralytics==8.2.4
, tensorrt==8.6.1.post1
Per gli esempi di utilizzo di questi modelli addestrati su COCO, che includono 80 classi pre-addestrate, consulta i Detection Docs.
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce), e max
(il più lento) per ogni test utilizzando i 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 | Prevedere | 0.52 | 0.51 | 0.56 | 8 | 640 | ||
FP32 | COCOval | 0.52 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Prevedere | 0.34 | 0.34 | 0.41 | 8 | 640 | ||
FP16 | COCOval | 0.33 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prevedere | 0.28 | 0.27 | 0.31 | 8 | 640 | ||
INT8 | COCOval | 0.29 | 0.47 | 0.33 | 1 | 640 |
Vedi Segmentation Docs per gli esempi di utilizzo di questi modelli addestrati su COCO, che includono 80 classi pre-addestrate.
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce), e max
(il più lento) per ogni test utilizzando i 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 | Prevedere | 0.62 | 0.61 | 0.68 | 8 | 640 | ||||
FP32 | COCOval | 0.63 | 0.52 | 0.36 | 0.49 | 0.31 | 1 | 640 | |
FP16 | Prevedere | 0.40 | 0.39 | 0.44 | 8 | 640 | ||||
FP16 | COCOval | 0.43 | 0.52 | 0.36 | 0.49 | 0.30 | 1 | 640 | |
INT8 | Prevedere | 0.34 | 0.33 | 0.37 | 8 | 640 | ||||
INT8 | COCOval | 0.36 | 0.46 | 0.32 | 0.43 | 0.27 | 1 | 640 |
Vedi Classification Docs per gli esempi di utilizzo di questi modelli addestrati su ImageNet, che includono 1000 classi pre-addestrate.
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce), e max
(il più lento) per ogni test utilizzando i pesi pre-addestrati yolov8n-cls.engine
Precisione | Test di valutazione | media (ms) |
min | max (ms) |
top-1 | top-5 | batch |
dimensione (pixel) |
---|---|---|---|---|---|---|---|
FP32 | Prevedere | 0.26 | 0.25 | 0.28 | 8 | 640 | ||
FP32 | ImageNetval | 0.26 | 0.35 | 0.61 | 1 | 640 | |
FP16 | Prevedere | 0.18 | 0.17 | 0.19 | 8 | 640 | ||
FP16 | ImageNetval | 0.18 | 0.35 | 0.61 | 1 | 640 | |
INT8 | Prevedere | 0.16 | 0.15 | 0.57 | 8 | 640 | ||
INT8 | ImageNetval | 0.15 | 0.32 | 0.59 | 1 | 640 |
Vedi Pose Estimation Docs per gli esempi di utilizzo di questi modelli addestrati su COCO, che includono una classe pre-addestrata, "persona".
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce), e max
(il più lento) per ogni test utilizzando i 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 | Prevedere | 0.54 | 0.53 | 0.58 | 8 | 640 | ||||
FP32 | COCOval | 0.55 | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | |
FP16 | Prevedere | 0.37 | 0.35 | 0.41 | 8 | 640 | ||||
FP16 | COCOval | 0.36 | 0.91 | 0.69 | 0.80 | 0.51 | 1 | 640 | |
INT8 | Prevedere | 0.29 | 0.28 | 0.33 | 8 | 640 | ||||
INT8 | COCOval | 0.30 | 0.90 | 0.68 | 0.78 | 0.47 | 1 | 640 |
Per gli esempi di utilizzo di questi modelli addestrati su DOTAv1, che includono 15 classi pre-addestrate, consulta i documenti sul rilevamento orientato.
Nota
Tempi di inferenza mostrati per mean
, min
(più veloce), e max
(il più lento) per ogni test utilizzando i 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 | Prevedere | 0.52 | 0.51 | 0.59 | 8 | 640 | ||
FP32 | DOTAv1val | 0.76 | 0.50 | 0.36 | 1 | 640 | |
FP16 | Prevedere | 0.34 | 0.33 | 0.42 | 8 | 640 | ||
FP16 | DOTAv1val | 0.59 | 0.50 | 0.36 | 1 | 640 | |
INT8 | Prevedere | 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
(il più lento) per ogni test utilizzando i 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 | Prevedere | 1.06 | 0.75 | 1.88 | 8 | 640 | ||
FP32 | COCOval | 1.37 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Prevedere | 0.62 | 0.75 | 1.13 | 8 | 640 | ||
FP16 | COCOval | 0.85 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prevedere | 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
(il più lento) per ogni test utilizzando i 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 | Prevedere | 1.76 | 1.69 | 1.87 | 8 | 640 | ||
FP32 | COCOval | 1.94 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Prevedere | 0.86 | 0.75 | 1.00 | 8 | 640 | ||
FP16 | COCOval | 1.43 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prevedere | 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
(il più lento) per ogni test utilizzando i 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 | Prevedere | 2.84 | 2.84 | 2.85 | 8 | 640 | ||
FP32 | COCOval | 2.94 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Prevedere | 1.09 | 1.09 | 1.10 | 8 | 640 | ||
FP16 | COCOval | 1.20 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prevedere | 0.75 | 0.74 | 0.75 | 8 | 640 | ||
INT8 | COCOval | 0.76 | 0.47 | 0.33 | 1 | 640 |
Dispositivi integrati
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
(il più lento) per ogni test utilizzando i 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 | Prevedere | 6.11 | 6.10 | 6.29 | 8 | 640 | ||
FP32 | COCOval | 6.17 | 0.52 | 0.37 | 1 | 640 | |
FP16 | Prevedere | 3.18 | 3.18 | 3.20 | 8 | 640 | ||
FP16 | COCOval | 3.19 | 0.52 | 0.37 | 1 | 640 | |
INT8 | Prevedere | 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.
Esportazione delle configurazioni
Per maggiori dettagli sugli argomenti di configurazione dell'esportazione, consulta la sezione Modalità di 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"
)
Prevedere il ciclo
Per ulteriori informazioni, consulta la modalità di previsione.
Configurazione della convalida
Vedi val
modalità per saperne di più sugli argomenti di configurazione della convalida.
Distribuzione dei modelli esportati di YOLOv8 TensorRT
Dopo aver esportato con successo i tuoi modelli Ultralytics YOLOv8 nel formato TensorRT , sei pronto a distribuirli. Per istruzioni approfondite su come distribuire i tuoi modelli TensorRT in varie impostazioni, consulta le seguenti risorse:
-
Distribuisci Ultralytics con un server Triton : La nostra guida su come utilizzare il server NVIDIA's Triton Inference (precedentemente TensorRT Inference) specificamente per l'utilizzo dei modelli Ultralytics YOLO .
-
Distribuzione di reti neurali profonde con NVIDIA TensorRT: Questo articolo spiega come utilizzare NVIDIA TensorRT per distribuire in modo efficiente le reti neurali profonde su piattaforme di deployment basate su GPU.
-
AI end-to-end per i PC basati su NVIDIA: NVIDIA TensorRT Distribuzione: Questo blog post spiega l'uso di NVIDIA TensorRT per l'ottimizzazione e la distribuzione di modelli di IA su NVIDIA PC.
-
Repository GitHub per NVIDIA TensorRT :: Questo è il repository ufficiale di GitHub che contiene il codice sorgente e la documentazione di NVIDIA TensorRT .
Sommario
In questa guida ci siamo concentrati sulla conversione dei modelli Ultralytics YOLOv8 nel formato NVIDIA's TensorRT . Questa fase di conversione è fondamentale per migliorare l'efficienza e la velocità dei modelli YOLOv8 , rendendoli più efficaci e adatti a diversi ambienti di distribuzione.
Per maggiori informazioni sui dettagli di utilizzo, consulta la documentazione ufficiale di TensorRT .
Se sei curioso di conoscere altre integrazioni di Ultralytics YOLOv8 , la nostra pagina di guida all'integrazione offre un'ampia selezione di risorse informative e approfondimenti.
DOMANDE FREQUENTI
Come posso convertire i modelli YOLOv8 in formato TensorRT ?
Per convertire i tuoi modelli Ultralytics YOLOv8 in formato TensorRT per ottimizzare l'inferenza NVIDIA GPU , segui questi passaggi:
-
Installa il pacchetto richiesto:
-
Esporta il tuo modello YOLOv8 :
Per maggiori dettagli, visita la guida all'installazione diYOLOv8 e la documentazione sull'esportazione.
Quali sono i vantaggi dell'utilizzo di TensorRT per i modelli di YOLOv8 ?
L'utilizzo di TensorRT per ottimizzare i modelli di YOLOv8 offre diversi vantaggi:
- Velocità di inferenza più rapida: TensorRT ottimizza i livelli del modello e utilizza la calibrazione di precisione (INT8 e FP16) per accelerare l'inferenza senza sacrificare significativamente l'accuratezza.
- Efficienza della memoria: TensorRT gestisce la memoria di tensor in modo dinamico, riducendo l'overhead e migliorando l'utilizzo della memoria di GPU .
- Fusione di livelli: Combina più livelli in un'unica operazione, riducendo la complessità computazionale.
- Kernel Auto-Tuning: Seleziona automaticamente i kernel ottimizzati di GPU per ogni livello del modello, garantendo le massime prestazioni.
Per maggiori informazioni, esplora le caratteristiche dettagliate di TensorRT qui e leggi la nostra sezioneTensorRT .
Posso utilizzare la quantizzazione INT8 con TensorRT per i modelli YOLOv8 ?
Sì, è possibile esportare i modelli YOLOv8 utilizzando TensorRT con quantizzazione INT8. Questo processo prevede la quantizzazione post-training (PTQ) e la calibrazione:
-
Esportazione con INT8:
-
Esegui l'inferenza:
Per maggiori dettagli, consulta la sezione Esportazione di TensorRT con quantizzazione INT8.
Come faccio a distribuire i modelli YOLOv8 TensorRT su un server di inferenza NVIDIA Triton ?
La distribuzione dei modelli YOLOv8 TensorRT su un NVIDIA Triton Inference Server può essere effettuata utilizzando le seguenti risorse:
- Distribuisci Ultralytics YOLOv8 con Triton Server: Guida passo passo alla configurazione e all'utilizzo di Triton Inference Server.
- NVIDIA Triton Documentazione sul server di inferenza: Documentazione ufficiale di NVIDIA per le opzioni di distribuzione e le configurazioni dettagliate.
Queste guide ti aiuteranno a integrare i modelli di YOLOv8 in modo efficiente in vari ambienti di distribuzione.
Quali sono i miglioramenti delle prestazioni osservati con i modelli di 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 del 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
I benchmark dettagliati delle prestazioni per le diverse configurazioni hardware sono disponibili nella sezione dedicata alle prestazioni.
Per un'analisi più completa delle prestazioni di TensorRT , consulta la documentazione diUltralytics e i nostri report di analisi delle prestazioni.
Creato 2024-01-28, Aggiornato 2024-07-10
Autori: glenn-jocher (10), ambitious-octopus (1), lakshanthad (1), IvorZhu331 (1), Burhan-Q (2), abirami-vina (1)