Link to this sectionEsportazione del modello con Ultralytics YOLO#

Link to this sectionIntroduzione#

L'obiettivo finale 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 ad accompagnarti attraverso le sfumature dell'esportazione del modello, mostrando come ottenere la massima compatibilità e prestazioni.

Link to this sectionPerché 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 CLI e Python per un'esportazione rapida e intuitiva del modello.

Link to this sectionFunzionalità chiave della modalità di esportazione#

Ecco alcune delle funzionalità più importanti:

• Esportazione con un clic: Comandi semplici per esportare in diversi formati.
• Esportazione batch: Esporta modelli in grado di gestire inferenze in 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.

Link to this sectionEsempi di Utilizzo#

Esporta un modello YOLO26n in un formato diverso come ONNX o TensorRT. Consulta la sezione Argomenti qui sotto 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")

Link to this sectionArgomenti#

Questa tabella descrive in dettaglio le configurazioni e le opzioni disponibili per l'esportazione di modelli YOLO in diversi formati. Queste impostazioni sono fondamentali per ottimizzare le prestazioni, le dimensioni e la compatibilità del modello esportato su varie 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 soddisfare requisiti specifici, come l'ambiente di distribuzione, i vincoli hardware e gli obiettivi di prestazione. Selezionare il formato e le impostazioni appropriati è essenziale per ottenere il miglior equilibrio tra dimensioni, velocità e accuratezza del modello.

Link to this sectionFormati di esportazione#

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

Link to this sectionOpzioni di quantizzazione#

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

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

Non tutti i formati di esportazione supportano ogni precisione. Le richieste esplicite di quantize producono quella precisione o 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 target non documenti un comportamento predefinito o abilitato automaticamente. Lo schema LiteRT "w8a32" (INT8 dinamico) non necessita di dati di calibrazione.

Link to this sectionFAQ#

Link to this sectionCome esporto un modello YOLO26 in formato ONNX?#

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 ulteriori dettagli sul processo, incluse le opzioni avanzate come la gestione di dimensioni di input diverse, consulta la guida all'integrazione ONNX.

Link to this sectionQuali sono i vantaggi dell'utilizzo di TensorRT per l'esportazione del modello?#

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.

Link to this sectionCome abilito la quantizzazione INT8 durante l'esportazione del mio modello YOLO26?#

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 utilizzando il parametro data. Consulta le Opzioni di quantizzazione per i valori quantize accettati e i formati supportati.

Link to this sectionPerché la dimensione di input dinamica è importante durante l'esportazione dei modelli?#

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

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.

Link to this sectionQuali sono gli argomenti di esportazione chiave da considerare per ottimizzare le prestazioni del modello?#

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", o gli schemi misti peso/attivazione "w8a16" e "w8a32" (INT8 dinamico LiteRT) sui formati supportati. Vedi Opzioni di Quantizzazione.
• optimize: Applica ottimizzazioni specifiche per ambienti mobili o vincolati.

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.

Link to this sectionCosa rappresentano i tensori di output nei modelli YOLO esportati?#

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 (ad esempio yolo26n.pt), l'esportazione end-to-end è abilitata per impostazione predefinita nei formati che la supportano, quindi l'output ha la forma (batch_size, max_detections, 6) con valori [x1, y1, x2, y2, confidence, class_id]. Con il valore predefinito max_det=300, questo è solitamente (batch_size, 300, 6). Alcuni formati vincolati tornano 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 è solitamente un singolo tensore con forma (batch_size, 4 + num_classes, num_predictions) dove 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 dinamico).

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

Per i modelli di posa (es. yolo26n-pose.pt), il tensore di output è tipicamente modellato come (batch_size, 4 + num_classes + keypoint_dims, num_predictions), dove keypoint_dims dipende dalla specifica della posa (es. numero di keypoint e se è inclusa la confidenza), e num_predictions dipende dalla risoluzione dell'input di esportazione (e può essere dinamico).

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

Link to this sectionEsiste un'API di inferenza C++ ufficiale di Ultralytics?#

Attualmente Ultralytics non fornisce un'API di inferenza C++ dedicata per i modelli YOLO. Per le implementazioni in C++, esporta il modello in un formato 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 usi il post-processing C++ personalizzato, fai corrispondere il layout del tensore di output per il tuo task e le impostazioni di esportazione; le esportazioni di rilevamento end-to-end YOLO26 solitamente restituiscono (batch, max_det, 6), mentre le esportazioni non end-to-end restituiscono tensori di previsione grezzi che richiedono un post-processing esterno.

Link to this sectionPerché output0 è FP32 quando si esportano modelli quantizzati con end2end=True?#

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 delle classi) è incorporata direttamente nel grafo esportato.

Il tensore output0 contiene 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 sua precisione limitata della mantissa. Per evitare potenziali perdite di precisione o ID di classe errati, output0 viene intenzionalmente mantenuto 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 FP16 completi, esporta con end2end=False ed esegui la post-elaborazione esternamente.