Esportazione del modello con Ultralytics YOLO#

Esportare un modello YOLO26 in formato ONNX è semplice con Ultralytics. Offre sia metodi Python che CLI per esportare i modelli.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom-trained model

# Export the model
model.export(format="onnx")

Per maggiori dettagli sul processo, incluse opzioni avanzate come la gestione di diverse dimensioni di input, fai riferimento alla guida all'integrazione ONNX.

L'utilizzo di TensorRT per l'esportazione del modello offre significativi miglioramenti delle prestazioni. I modelli YOLO26 esportati in TensorRT possono ottenere un'accelerazione GPU fino a 5x, rendendoli ideali per applicazioni di inferenza in tempo reale.

• Versatilità: Ottimizza i modelli per una specifica configurazione hardware.
• Velocità: Ottieni un'inferenza più rapida grazie a ottimizzazioni avanzate.
• Compatibilità: Integra senza problemi con hardware NVIDIA.

Per saperne di più sull'integrazione di TensorRT, consulta la guida all'integrazione TensorRT.

La quantizzazione INT8 è un ottimo modo per comprimere il modello e accelerare l'inferenza, specialmente su dispositivi edge. Ecco come puoi abilitare la quantizzazione INT8:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # Load a model
model.export(format="onnx", quantize=8, data="coco8.yaml")

La quantizzazione INT8 può essere applicata a formati come ONNX, TensorRT, OpenVINO, CoreML e Rockchip RKNN. Per risultati di quantizzazione ottimali, fornisci un dataset rappresentativo usando il parametro data. Vedi Opzioni di quantizzazione per i valori di quantize accettati e i formati supportati.

La dimensione di input dinamica consente al modello esportato di gestire dimensioni d'immagine variabili, offrendo flessibilità e ottimizzando l'efficienza di elaborazione per diversi casi d'uso. Quando si esporta verso formati come ONNX o TensorRT, abilitare la dimensione di input dinamica garantisce che il modello possa adattarsi a diverse forme di input in modo trasparente.

Per abilitare questa funzionalità, usa il flag dynamic=True durante l'esportazione:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="onnx", dynamic=True)

Il ridimensionamento dinamico dell'input è particolarmente utile per le applicazioni in cui le dimensioni dell'input possono variare, come nell'elaborazione video o quando si gestiscono immagini da diverse fonti.

Comprendere e configurare gli argomenti di esportazione è cruciale per ottimizzare le prestazioni del modello:

• format: Il formato di destinazione per il modello esportato (es. onnx, torchscript, tensorflow).
• imgsz: Dimensione dell'immagine desiderata per l'input del modello (es. 640 o (height, width)).
• quantize: Precisione di quantizzazione, come 8/"int8", 16/"fp16", 32/"fp32", oppure gli schemi misti peso/attivazione "w8a16" e "w8a32" (LiteRT INT8 dinamico) sui formati supportati. Vedi Opzioni di quantizzazione.
• optimize: Abilita un'ottimizzazione del compilatore superiore per le esportazioni DEEPX.

Per la distribuzione su piattaforme hardware specifiche, considera l'utilizzo di formati di esportazione specializzati come TensorRT per GPU NVIDIA, CoreML per dispositivi Apple o Edge TPU per dispositivi Google Coral.

Quando esporti un modello YOLO in formati come ONNX o TensorRT, la struttura del tensore di output dipende dal compito del modello. Comprendere questi output è importante per implementazioni di inferenza personalizzate.

Per i modelli di rilevamento YOLO26 (es. yolo26n.pt), l'esportazione end-to-end è abilitata per impostazione predefinita nei formati che la supportano, quindi l'output ha una forma simile a (batch_size, max_detections, 6) con valori [x1, y1, x2, y2, confidence, class_id]. Con il valore predefinito max_det=300, questo è comunemente (batch_size, 300, 6). Alcuni formati vincolati passano automaticamente al layout di output tradizionale quando gli operatori end-to-end non sono supportati.

Per i modelli di rilevamento non end-to-end, o per i modelli YOLO26 esportati con end2end=False, l'output è tipicamente un singolo tensore con forma (batch_size, 4 + num_classes, num_predictions) in cui i canali rappresentano le coordinate del box più i punteggi per classe, e num_predictions dipende dalla risoluzione di input dell'esportazione (e può essere dinamica). La End-to-End Detection guide spiega quali formati mantengono l'output end-to-end.

Per i modelli di segmentazione (es. yolo26n-seg.pt), otterrai tipicamente due output: il primo tensore con forma simile a (batch_size, 4 + num_classes + mask_dim, num_predictions) (box, punteggi di classe e coefficienti di maschera) e il secondo tensore con forma simile a (batch_size, mask_dim, proto_h, proto_w) contenente i prototipi di maschera utilizzati con i coefficienti per generare le maschere di istanza. Le dimensioni dipendono dalla risoluzione di input dell'esportazione (e possono essere dinamiche).

Per i modelli di posa (es. yolo26n-pose.pt), il tensore di output ha tipicamente una forma simile a (batch_size, 4 + num_classes + keypoint_dims, num_predictions), dove keypoint_dims dipende dalla specifica della posa (es. numero di keypoint e presenza o meno della confidenza) e num_predictions dipende dalla risoluzione di input dell'esportazione (e può essere dinamico).

Gli esempi negli esempi di inferenza ONNX mostrano come elaborare questi output per ciascun tipo di modello.

Ultralytics non fornisce attualmente un'API di inferenza C++ dedicata per i modelli YOLO. Per le distribuzioni in C++, esporta il modello in un formato di runtime come ONNX, TensorRT, TorchScript o MNN, quindi carica l'artefatto esportato con l'API C++ nativa di quel runtime.

Ad esempio, esporta un modello di rilevamento con yolo export model=yolo26n.pt format=onnx ed esegui il file .onnx con ONNX Runtime C++, oppure esporta con format=engine ed esegui il motore TensorRT da un'applicazione C++ TensorRT. Quando utilizzi una post-elaborazione C++ personalizzata, fai corrispondere il layout del tensore di output per la tua attività e le tue impostazioni di esportazione; le esportazioni di rilevamento end-to-end YOLO26 restituiscono solitamente (batch, max_det, 6), mentre le esportazioni non end-to-end restituiscono tensori di predizione grezzi che richiedono una post-elaborazione esterna.

Quando si esporta con quantize=16 (FP16) o quantize=8 (INT8), la maggior parte dei tensori viene convertita a una precisione inferiore per ridurre le dimensioni del modello e migliorare le prestazioni. Tuttavia, quando end2end=True è abilitato, la post-elaborazione (inclusi gli indici di classe) viene incorporata direttamente nel grafo esportato.

Il tensore output0 contiene gli indici di classe, che sono rappresentati internamente come valori in virgola mobile. FP16 non può rappresentare in modo affidabile valori interi superiori a 2048 a causa della precisione limitata della sua mantissa. Per evitare potenziali perdite di precisione o ID di classe errati, output0 viene mantenuto intenzionalmente in FP32.

Questo comportamento è previsto e si applica anche a esportazioni a bassa precisione o quantizzate in cui deve essere preservata la fedeltà dell'indice di classe.

Se sono richiesti output completi in FP16, esporta con end2end=False ed esegui la post-elaborazione esternamente.