Esportazione dei modelli con Ultralytics YOLO#

Introduzione#

L'obiettivo fondamentale dell'addestramento di un modello è distribuirlo per applicazioni nel mondo reale. La modalità di esportazione in Ultralytics YOLO26 offre una gamma versatile di opzioni per esportare il tuo modello addestrato in diversi formati, rendendolo distribuibile su varie piattaforme e dispositivi. Questa guida completa mira a mostrarti le sfumature dell'esportazione dei modelli, evidenziando come ottenere la massima compatibilità e prestazioni.

Consulta l'anteprima unreleased YOLO27 preview per il supporto all'esportazione pianificato.

Perché scegliere la modalità di esportazione di YOLO26?#

• Versatilità: Esporta in molteplici formati inclusi ONNX, TensorRT, CoreML e altri.
• Prestazioni: Ottieni fino a 5x di accelerazione GPU con TensorRT e 3x di accelerazione CPU con ONNX o OpenVINO.
• Compatibilità: Rendi il tuo modello universalmente distribuibile su numerosi ambienti hardware e software.
• Facilità d'uso: Semplici API Python e CLI per un'esportazione dei modelli rapida e lineare.

Funzionalità chiave della modalità di esportazione#

Ecco alcune delle funzionalità di spicco:

• Esportazione con un clic: Comandi semplici per l'esportazione in diversi formati.
• Esportazione in batch: Esporta modelli capaci di inferenza a batch.
• Inferenza ottimizzata: I modelli esportati sono ottimizzati per tempi di inferenza più rapidi.
• Video tutorial: Guide approfondite e tutorial per un'esperienza di esportazione fluida.

Esempi di utilizzo#

Esporta un modello YOLO26n in un formato diverso come ONNX o TensorRT. Consulta la sezione Argomenti sottostante per un elenco completo degli argomenti di esportazione.

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")

Argomenti#

Questa tabella descrive in dettaglio le configurazioni e le opzioni disponibili per l'esportazione dei modelli YOLO in diversi formati. Queste impostazioni sono fondamentali per ottimizzare le prestazioni, le dimensioni e la compatibilità del modello esportato su vari piattaforme e ambienti. Una configurazione corretta garantisce che il modello sia pronto per la distribuzione nell'applicazione prevista con un'efficienza ottimale.

La regolazione di questi parametri consente la personalizzazione del processo di esportazione per adattarsi a requisiti specifici, come l'ambiente di distribuzione, i vincoli hardware e gli obiettivi di prestazioni. La selezione del formato e delle impostazioni appropriate è essenziale per ottenere il miglior bilanciamento tra dimensioni, velocità e accuratezza del modello.

Formati di esportazione#

I formati di esportazione disponibili per YOLO26 sono nella tabella sottostante. Puoi esportare in qualsiasi formato usando l'argomento format, ovvero format='onnx' o format='engine'. Puoi effettuare previsioni o validazioni direttamente sui modelli esportati, ovvero yolo predict model=yolo26n.onnx. Gli esempi di utilizzo vengono mostrati per il tuo modello al termine dell'esportazione. I modelli possono anche essere esportati direttamente dal browser su Ultralytics Platform senza alcuna configurazione locale.

nms=None utilizza i valori predefiniti per gli output grezzi per la NMS esterna. Imposta nms=False per selezionare una testa senza NMS disponibile; i formati non supportati ricorrono al loro percorso di output nativo. Le voci nms sopra indicano i formati che possono incorporare la NMS con nms=True.

export YOLO_AUTOINSTALL=False

Opzioni di quantizzazione#

Usa l'argomento quantize per richiedere la precisione di esportazione. I valori di tipo stringa non sono case-sensitive e Ultralytics canonizza gli alias accettati prima dell'esportazione:

I flag legacy half=True e int8=True sono ancora accettati con avvisi di deprecazione e reindirizzano a quantize=16 e quantize=8.

Non tutti i formati di esportazione supportano qualsiasi precisione. Le richieste esplicite di quantize producono quella precisione oppure falliscono prima dell'esportazione:

Per le esportazioni INT8 e W8A16, fornisci dati di calibrazione rappresentativi con data, come data="coco8.yaml", a meno che l'integrazione di destinazione non documenti un comportamento predefinito o abilitato automaticamente. Lo schema "w8a32" di LiteRT (INT8 dinamico) non necessita di dati di calibrazione.

Addestramento consapevole della quantizzazione#

Le esportazioni INT8 sopra indicate sono quantizzazioni post-training (PTQ): gli intervalli vengono osservati in un singolo passaggio di calibrazione su data. L'addestramento consapevole della quantizzazione (QAT) apprende invece pesi che tollerano INT8 eseguendo il fine-tuning con la quantizzazione fittizia nel ciclo, il che recupera l'accuratezza che la sola calibrazione perde. Passa quantize=8 a train per eseguire il fine-tuning di un checkpoint pre-addestrato, quindi esportalo come al solito:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.train(
    data="coco.yaml",
    quantize=8,
    epochs=5,
    batch=64,
    optimizer="AdamW",
    lr0=0.00001,
    lrf=0.1,
    warmup_epochs=0.5,
    cos_lr=True,
    mosaic=0.0,
)
model.export(format="engine", quantize=8)  # ranges travel with the checkpoint, no calibration data needed

Usa un tasso di apprendimento piccolo quando effettui il fine-tuning di un checkpoint preaddestrato. L'addestramento consapevole della quantizzazione può inizialmente ridurre la precisione e il suo vantaggio rispetto alla quantizzazione post-addestramento dipende dal modello, dal dataset e dal budget di addestramento. Valuta il modello esportato rispetto sia al checkpoint originale sia a un'esportazione quantizzata post-addestramento; i punteggi di quantizzazione fittizia durante l'addestramento non stabiliscono la precisione di distribuzione.

Quanto vale la QAT dipende da quanto bene la calibrazione del backend di esportazione gestisce il modello. I valori sottostanti sono mAP50-95 su COCO val2017, misurati con motori TensorRT 10.16 a imgsz=640 e batch 1, in cui ciascun checkpoint QAT è stato addestrato con epochs=20 patience=3:

La QAT costa da 0,008 a 0,017 mAP50-95 rispetto a FP32 su tutta la gamma, mentre la quantizzazione post-training costa 0,010 su yolo26n e da 0,038 a 0,057 sui modelli più grandi. Pertanto, la QAT non offre quasi nulla sul modello più piccolo, dove la calibrazione funziona già bene, e offre da 0,030 a 0,044 sul resto. Aspettati cifre diverse su un altro set di dati, formato di esportazione o versione di TensorRT, e misura i tuoi valori.

I modelli di addestramento consapevole della quantizzazione richiedono compile=False; i moduli quantizzati di ModelOpt non supportano torch.compile.

Le convoluzioni di output finale della testa sono lasciate deliberatamente in float per limitare la perdita di precisione INT8; TensorRT abilita la precisione mista FP16 per i suoi strati non quantizzati. Il QAT viene eseguito tramite NVIDIA TensorRT Model Optimizer, installato automaticamente al primo utilizzo, e il checkpoint risultante richiede che NVIDIA TensorRT Model Optimizer sia installato per essere caricato. Tali intervalli viaggiano con il checkpoint e le esportazioni di onnx e engine emettono tali intervalli come nodi Q/DQ; altri formati leggono la calibrazione e rifiutano un checkpoint QAT.

E adesso?#

Trova la guida all'integrazione della tua destinazione di distribuzione — ONNX, TensorRT, CoreML e altre sono presenti nell'elenco completo delle integrazioni — per scoprire come eseguire il modello esportato.

FAQ#