Esportazione dei modelli con Ultralytics YOLO#

Esportare un modello YOLO26 in formato ONNX è semplice con Ultralytics. Puoi esportare i modelli sia con Python sia tramite CLI.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n.pt")  # carica un modello ufficiale
model = YOLO("path/to/best.pt")  # carica un modello addestrato personalizzato

# Esporta il modello
model.export(format="onnx")

Per maggiori dettagli sulla procedura, incluse opzioni avanzate come la gestione di diverse dimensioni di input, consulta la guida all'integrazione ONNX.

L'uso di TensorRT per l'esportazione dei modelli offre notevoli miglioramenti delle prestazioni. I modelli YOLO26 esportati in TensorRT possono raggiungere una velocità GPU fino a 5 volte superiore, il che li rende ideali per le applicazioni di inferenza in tempo reale.

• Versatilità: ottimizza i modelli per una configurazione hardware specifica.
• Velocità: ottieni inferenze più rapide grazie a ottimizzazioni avanzate.
• Compatibilità: integra i modelli senza problemi con l'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, soprattutto sui dispositivi edge. Ecco come abilitare la quantizzazione INT8:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # Carica un modello
model.export(format="onnx", quantize=8, data="coco8.yaml")

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

Le dimensioni di input dinamiche consentono al modello esportato di gestire immagini di dimensioni diverse, offrendo flessibilità e ottimizzando l'efficienza di elaborazione per diversi casi d'uso. Quando esporti in formati come ONNX o TensorRT, abilitare le dimensioni di input dinamiche permette al modello di adattarsi facilmente a forme di input diverse.

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)

Le dimensioni di input dinamiche sono particolarmente utili nelle applicazioni in cui le dimensioni dell'input possono variare, ad esempio nell'elaborazione video o quando si gestiscono immagini provenienti da fonti diverse.

Per impostazione predefinita, i modelli PyTorch e le esportazioni dinamiche usano il padding a rettangolo minimo, mentre le esportazioni statiche applicano il padding fino a imgsz; perciò le rilevazioni vicine alla soglia di confidenza possono differire. Usa rect=False per l'inferenza nativa, così da ottenere risultati corrispondenti a un'esportazione statica, oppure esporta con dynamic=True se supportato.

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

• format: Il formato di destinazione del modello esportato (ad es. onnx, torchscript, saved_model).
• imgsz: La dimensione dell'immagine desiderata per l'input del modello (ad es. 640 o (height, width)).
• quantize: La precisione di quantizzazione, ad esempio 8/"int8", 16/"fp16", 32/"fp32" oppure gli schemi misti di pesi/attivazioni "w8a16" e "w8a32" (INT8 dinamico LiteRT) nei formati supportati. Consulta Opzioni di quantizzazione.
• dynamic: Accetta dimensioni di input variabili nei formati che supportano forme dinamiche, come ONNX, OpenVINO e TensorRT.
• nms: Seleziona output grezzi per NMS esterna (None), NMS integrata (True) o la testata senza NMS (False).
• device: Il dispositivo usato per tracciare il modello durante l'esportazione, ad esempio cpu o 0 per la prima GPU CUDA; TorchScript FP16 richiede una GPU.

Per il deployment su piattaforme hardware specifiche, valuta formati di esportazione specializzati come TensorRT per le GPU NVIDIA, CoreML per i dispositivi Apple o Edge TPU per i dispositivi Google Coral.

Quando esporti un modello YOLO in formati come ONNX o TensorRT, la struttura del tensore di output dipende dall'attività del modello. Comprendere questi output è importante per implementare inferenze personalizzate.

Per i modelli di rilevamento YOLO26 (ad es. yolo26n.pt) esportati con nms=False, i formati supportati producono un output senza NMS con forma (batch_size, max_detections, 6) e valori [x1, y1, x2, y2, confidence, class_id]. Con il valore predefinito max_det=300, in genere è (batch_size, 300, 6). Alcuni formati soggetti a vincoli ripiegano automaticamente sul layout di output tradizionale quando gli operatori end-to-end non sono supportati.

Per impostazione predefinita (nms=None), i modelli di rilevamento, incluso YOLO26, esportano le predizioni grezze one-to-many: l'output è in genere un singolo tensore con forma (batch_size, 4 + num_classes, num_predictions), in cui i canali rappresentano le coordinate dei riquadri più i punteggi per classe, mentre num_predictions dipende dalla risoluzione di input dell'esportazione (e può essere dinamico). La guida al rilevamento end-to-end spiega quali formati mantengono l'output end-to-end.

Per i modelli di segmentazione (ad es. yolo26n-seg.pt), in genere ottieni due output: il primo tensore con forma (batch_size, 4 + num_classes + mask_dim, num_predictions) (riquadri, punteggi di classe e coefficienti delle maschere) e il secondo tensore con forma (batch_size, mask_dim, proto_h, proto_w), contenente i prototipi delle maschere usati insieme ai coefficienti per generare le maschere delle istanze. Le dimensioni dipendono dalla risoluzione di input dell'esportazione (e possono essere dinamiche).

Per i modelli pose (ad es. yolo26n-pose.pt), il tensore di output ha in genere forma (batch_size, 4 + num_classes + keypoint_dims, num_predictions), mentre keypoint_dims dipende dalla specifica della posa (ad es. dal numero di punti chiave e dall'inclusione o meno della confidenza) e num_predictions dipende dalla risoluzione di input dell'esportazione (e può essere dinamico).

Gli esempi in Esempi di inferenza ONNX illustrano come elaborare questi output per ogni tipo di modello.

Ultralytics al momento non fornisce un'API dedicata di inferenza C++ per i modelli YOLO. Per le distribuzioni 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 del 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 usi una post-elaborazione C++ personalizzata, fai corrispondere il layout del tensore di output all'attività e alle impostazioni di esportazione; le esportazioni predefinite di rilevamento YOLO26 restituiscono tensori di predizione grezzi che richiedono NMS esterna. Esporta con nms=False per ottenere rilevamenti senza NMS con forma (batch, max_det, 6), oppure con nms=True per incorporare NMS nei formati supportati.

Quando esporti 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 è abilitato nms=False, la post-elaborazione (inclusi gli indici di classe) viene incorporata direttamente nel grafo esportato.

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

Se ti servono output interamente in FP16, esporta con nms=None su una GPU ed esegui la post-elaborazione esternamente. Le esportazioni ONNX FP16 su CPU mantengono comunque input e output FP32, convertendo solo il grafo interno.