Vai al contenuto

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

Panoramica su 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.

Fusione dei Livelli TensorRT

  • 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.

Panoramica su TensorRT

  • 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ù grande workspace 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ù piccolo workspace 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 di workspace è superiore alla memoria disponibile per il dispositivo, il che significa che è necessario ridurre il valore di workspace dovrebbe essere abbassato o impostato su None.

    • Se workspace è impostato al valore massimo e la calibrazione fallisce/si blocca, considera l'utilizzo di None per l'allocazione automatica o riducendo i valori di imgsz e batch 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")
  1. 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.
  2. 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.
  3. Alloca 4 GiB di memoria invece di allocare l'intero dispositivo per il processo di conversione.
  4. 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 in mAP50 e mAP50-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:

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:

  1. Installa il pacchetto richiesto:

    pip install ultralytics
    
  2. 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:

  1. Esporta con INT8:

    from ultralytics import YOLO
    
    model = YOLO("yolov8n.pt")
    model.export(format="engine", batch=8, workspace=4, int8=True, data="coco.yaml")
    
  2. 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:

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.



📅 Creato 1 anno fa ✏️ Aggiornato 2 mesi fa

Commenti