Esportazione Intel OpenVINO#
In questa guida esaminiamo l'esportazione dei modelli YOLO26 nel formato OpenVINO, che può offrire fino a un'accelerazione di 3 volte su CPU, oltre ad accelerare l'inferenza di YOLO su hardware GPU e NPU Intel.
OpenVINO, acronimo di Open Visual Inference & Neural Network Optimization toolkit, è un toolkit completo per ottimizzare e distribuire modelli di inferenza di intelligenza artificiale. Sebbene il nome contenga Visual, OpenVINO supporta anche varie attività aggiuntive tra cui linguaggio, audio, serie temporali, ecc.
Watch: How to Export Ultralytics YOLO26 to Intel OpenVINO Format for Faster Inference 🚀
Attività supportate#
L'esportazione OpenVINO supporta tutti e sette i task di Ultralytics. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include quelle teste.
Esempi di Utilizzo#
Il formato OpenVINO supporta le modalità Export, Predict e Validate. Esporta il tuo modello, quindi carica il modello esportato per eseguire l'inferenza o validare la sua accuratezza su CPU Intel, GPU integrata/dedicata o NPU.
from ultralytics import YOLO
# Load a YOLO26 model
model = YOLO("yolo26n.pt")
# Export the model to OpenVINO format
model.export(format="openvino") # creates 'yolo26n_openvino_model/'from ultralytics import YOLO
# Load the exported OpenVINO model
model = YOLO("yolo26n_openvino_model/")
# Run inference
results = model("https://ultralytics.com/images/bus.jpg")
# Run inference on a specific device, available devices: ["intel:gpu", "intel:npu", "intel:cpu"]
results = model("https://ultralytics.com/images/bus.jpg", device="intel:gpu")from ultralytics import YOLO
# Load the exported OpenVINO model
model = YOLO("yolo26n_openvino_model/")
# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")Argomenti di esportazione#
| Argomento | Tipo | Predefinito | Descrizione |
|---|---|---|---|
format | str | 'openvino' | Formato di destinazione per il modello esportato, che definisce la compatibilità con vari ambienti di distribuzione. |
imgsz | int o 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. |
quantize | int o str | None | Precisione di quantizzazione: 16 (FP16) o 8 (INT8/PTQ; richiede calibrazione data/fraction); 32/non impostato è FP32. Sostituisce i flag deprecati half/int8. |
dynamic | bool | False | Consente dimensioni di input dinamiche, migliorando la flessibilità nella gestione di dimensioni variabili delle immagini. |
nms | bool | False | Aggiunge la Non-Maximum Suppression (NMS), essenziale per un post-processing del rilevamento accurato ed efficiente. |
batch | int | 1 | Specifica la dimensione dell'inferenza in batch del modello esportato o il numero massimo di immagini che il modello esportato elaborerà contemporaneamente in modalità predict. |
data | str | None | Percorso del file YAML del dataset, essenziale per la quantizzazione; la classificazione richiede invece una cartella di dataset o il nome di un dataset integrato. Se omesso con quantize=8, Ultralytics seleziona il dataset di calibrazione predefinito per il task del modello. |
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. |
Per ulteriori dettagli sul processo di esportazione, visita la pagina della documentazione di Ultralytics sull'esportazione.
OpenVINO™ è compatibile con la maggior parte dei processori Intel®, ma per garantire prestazioni ottimali:
-
Verifica il supporto a OpenVINO™ Controlla se il tuo chip Intel® è ufficialmente supportato da OpenVINO™ utilizzando l'elenco di compatibilità Intel.
-
Identifica il tuo acceleratore Determina se il tuo processore include una NPU (Neural Processing Unit) o una GPU integrata consultando la guida hardware di Intel.
-
Installa i driver più recenti Se il tuo chip supporta una NPU o una GPU ma OpenVINO™ non la rileva, potresti dover installare o aggiornare i driver associati. Segui le istruzioni per l'installazione dei driver per abilitare la piena accelerazione.
Seguendo questi tre passaggi, puoi assicurarti che OpenVINO™ funzioni in modo ottimale sul tuo hardware Intel®.
Vantaggi di OpenVINO#
- Performance: OpenVINO offre un'inferenza ad alte prestazioni utilizzando la potenza di CPU, GPU integrate e discrete e FPGA Intel.
- Supporto per l'esecuzione eterogenea: OpenVINO fornisce un'API per scrivere il codice una volta sola ed eseguirlo su qualsiasi hardware Intel supportato (CPU, GPU, FPGA, VPU, ecc.).
- Model Optimizer: OpenVINO fornisce un Model Optimizer che importa, converte e ottimizza modelli da diffusi framework di deep learning come PyTorch, TensorFlow, TensorFlow Lite, Keras, ONNX, PaddlePaddle e Caffe.
- Facilità d'uso: Il toolkit include una vasta raccolta di notebook di tutorial (inclusa l'ottimizzazione di YOLO26) che insegnano diversi aspetti del toolkit.
Struttura dell'esportazione OpenVINO#
Quando esporti un modello nel formato OpenVINO, viene generata una cartella contenente quanto segue:
- File XML: Descrive la topologia della rete.
- File BIN: Contiene i dati binari di pesi e bias.
- File di mappatura: Contiene la mappatura dei tensori di output del modello originale ai nomi dei tensori OpenVINO.
Puoi utilizzare questi file per eseguire l'inferenza con l'OpenVINO Inference Engine.
Utilizzo dell'esportazione OpenVINO nel deployment#
Una volta che il tuo modello è stato esportato correttamente nel formato OpenVINO, hai due opzioni principali per eseguire l'inferenza:
-
Usa il pacchetto
ultralytics, che fornisce un'API di alto livello e racchiude il runtime di OpenVINO. -
Usa il pacchetto nativo
openvinoper un controllo più avanzato o personalizzato sul comportamento dell'inferenza.
Inferenza con Ultralytics#
Il pacchetto ultralytics ti consente di eseguire facilmente l'inferenza utilizzando il modello OpenVINO esportato tramite il metodo predict. Puoi anche specificare il dispositivo di destinazione (ad esempio, intel:gpu, intel:npu, intel:cpu) usando l'argomento device.
from ultralytics import YOLO
# Load the exported OpenVINO model
ov_model = YOLO("yolo26n_openvino_model/") # the path of your exported OpenVINO model
# Run inference with the exported model
ov_model.predict(device="intel:gpu") # specify the device you want to run inference onQuesto approccio è ideale per una prototipazione rapida o per il deployment quando non hai bisogno di un controllo completo sulla pipeline di inferenza.
Inferenza con OpenVINO Runtime#
Il runtime di OpenVINO fornisce un'API unificata per l'inferenza su tutto l'hardware Intel supportato. Offre inoltre funzionalità avanzate come il bilanciamento del carico tra hardware Intel e l'esecuzione asincrona. Per ulteriori informazioni sull'esecuzione dell'inferenza, fai riferimento ai notebook di YOLO26.
Ricorda che avrai bisogno dei file XML e BIN, oltre a qualsiasi impostazione specifica dell'applicazione come dimensione di input, fattore di scala per la normalizzazione, ecc., per configurare e utilizzare correttamente il modello con il Runtime.
Nella tua applicazione di deployment, dovresti solitamente seguire questi passaggi:
- Inizializza OpenVINO creando
core = Core(). - Carica il modello utilizzando il metodo
core.read_model(). - Compila il modello utilizzando la funzione
core.compile_model(). - Prepara l'input (immagine, testo, audio, ecc.).
- Esegui l'inferenza utilizzando
compiled_model(input_data).
Per passaggi più dettagliati e frammenti di codice, fai riferimento alla documentazione di OpenVINO o al tutorial dell'API.
Benchmark YOLO26 con OpenVINO#
Il team di Ultralytics ha eseguito benchmark su YOLO26 attraverso vari formati di modelli e precisione, valutando velocità e accuratezza su diversi dispositivi Intel compatibili con OpenVINO.
-
I risultati del benchmarking di seguito sono di riferimento e potrebbero variare in base all'esatta configurazione hardware e software di un sistema, nonché al carico di lavoro corrente del sistema al momento dell'esecuzione dei benchmark.
-
Tutti i benchmark sono stati eseguiti con la versione 2026.2.1 del pacchetto Python
openvino. -
I modelli YOLO26 su NPU sono supportati solo su sistemi Intel® Core™ Ultra™ con serie 2xxV e serie 3xx e superiori.
Intel® Core™ Ultra#
La serie Intel® Core™ Ultra™ rappresenta un nuovo benchmark nel calcolo ad alte prestazioni, progettato per soddisfare le mutevoli esigenze degli utenti moderni, dai gamer e creatori ai professionisti che sfruttano l'IA. Questa lineup di nuova generazione è più di una tradizionale serie di CPU; combina potenti core CPU, capacità GPU integrate ad alte prestazioni e una NPU (Neural Processing Unit) dedicata all'interno di un singolo chip, offrendo una soluzione unificata per carichi di lavoro di calcolo diversificati e intensivi.
Al centro dell'architettura Intel® Core Ultra™ c'è un design ibrido che consente prestazioni eccezionali in attività di elaborazione tradizionali, carichi di lavoro accelerati da GPU e operazioni basate sull'IA. L'inclusione della NPU migliora l'inferenza AI on-device, consentendo un machine learning e un'elaborazione dei dati più rapidi ed efficienti in una vasta gamma di applicazioni.
La famiglia Core Ultra™ include vari modelli su misura per diverse esigenze di prestazioni, con opzioni che spaziano da design a efficienza energetica a varianti ad alta potenza contrassegnate dalla sigla "H", ideali per laptop e form factor compatti che richiedono una notevole potenza di calcolo. In tutta la lineup, gli utenti beneficiano della sinergia dell'integrazione di CPU, GPU e NPU, offrendo efficienza, reattività e capacità di multitasking notevoli.
Come parte dell'innovazione continua di Intel, la serie Core Ultra™ stabilisce un nuovo standard per il computing pronto per il futuro. Con molteplici modelli disponibili e altri all'orizzonte, questa serie sottolinea l'impegno di Intel nel fornire soluzioni all'avanguardia per la prossima generazione di dispositivi intelligenti e potenziati dall'IA.
I benchmark di seguito sono stati eseguiti su Intel® Core™ Ultra™ X7 358H, Intel® Core™ Ultra™ 7 258V e Intel® Core™ Ultra™ 7 155H con precisione FP32, FP16 e INT8.
Intel® Core™ Ultra™ X7 358H#
Risultati dettagliati del benchmark
| Modello | Formato | Precision | Stato | Dimensione (MB) | metrics/mAP50-95(B) | Tempo di inferenza (ms/im) |
|---|---|---|---|---|---|---|
| YOLO26n | PyTorch (CPU) | FP32 | ✅ | 5.3 | 0.4765 | 29.28 |
| YOLO26n | OpenVINO | FP32 | ✅ | 9.7 | 0.4762 | 4.09 |
| YOLO26n | OpenVINO | FP16 | ✅ | 5.1 | 0.4762 | 4.03 |
| YOLO26n | OpenVINO | INT8 | ✅ | 3.2 | 0.4634 | 4.24 |
| YOLO26s | PyTorch (CPU) | FP32 | ✅ | 19.5 | 0.5703 | 59.32 |
| YOLO26s | OpenVINO | FP32 | ✅ | 36.7 | 0.5616 | 5.08 |
| YOLO26s | OpenVINO | FP16 | ✅ | 18.7 | 0.5616 | 5.14 |
| YOLO26s | OpenVINO | INT8 | ✅ | 10.0 | 0.5462 | 4.47 |
| YOLO26m | PyTorch (CPU) | FP32 | ✅ | 42.2 | 0.6196 | 143.21 |
| YOLO26m | OpenVINO | FP32 | ✅ | 78.4 | 0.6166 | 7.1 |
| YOLO26m | OpenVINO | FP16 | ✅ | 39.5 | 0.6166 | 7.06 |
| YOLO26m | OpenVINO | INT8 | ✅ | 20.6 | 0.6055 | 5.61 |
| YOLO26l | PyTorch (CPU) | FP32 | ✅ | 50.7 | 0.6215 | 181.16 |
| YOLO26l | OpenVINO | FP32 | ✅ | 95.3 | 0.6205 | 8.45 |
| YOLO26l | OpenVINO | FP16 | ✅ | 48.1 | 0.6205 | 8.49 |
| YOLO26l | OpenVINO | INT8 | ✅ | 25.2 | 0.5938 | 6.25 |
| YOLO26x | PyTorch (CPU) | FP32 | ✅ | 113.2 | 0.6512 | 379.75 |
| YOLO26x | OpenVINO | FP32 | ✅ | 213.3 | 0.6568 | 13.03 |
| YOLO26x | OpenVINO | FP16 | ✅ | 107.1 | 0.6568 | 12.98 |
| YOLO26x | OpenVINO | INT8 | ✅ | 54.8 | 0.6385 | 8.74 |
Intel® Core™ Ultra™ 7 258V#
Risultati dettagliati del benchmark
| Modello | Formato | Precision | Stato | Dimensione (MB) | metrics/mAP50-95(B) | Tempo di inferenza (ms/im) |
|---|---|---|---|---|---|---|
| YOLO26n | PyTorch (CPU) | FP32 | ✅ | 5.3 | 0.4765 | 27.33 |
| YOLO26n | OpenVINO | FP32 | ✅ | 9.6 | 0.4764 | 3.33 |
| YOLO26n | OpenVINO | FP16 | ✅ | 5.1 | 0.4764 | 3.34 |
| YOLO26n | OpenVINO | INT8 | ✅ | 3.2 | 0.4634 | 3.46 |
| YOLO26s | PyTorch (CPU) | FP32 | ✅ | 19.5 | 0.5703 | 60.2 |
| YOLO26s | OpenVINO | FP32 | ✅ | 36.7 | 0.5616 | 4.66 |
| YOLO26s | OpenVINO | FP16 | ✅ | 18.6 | 0.5616 | 4.65 |
| YOLO26s | OpenVINO | INT8 | ✅ | 10.0 | 0.5462 | 3.99 |
| YOLO26m | PyTorch (CPU) | FP32 | ✅ | 42.2 | 0.6196 | 152.87 |
| YOLO26m | OpenVINO | FP32 | ✅ | 78.4 | 0.6168 | 9.03 |
| YOLO26m | OpenVINO | FP16 | ✅ | 39.5 | 0.6168 | 8.98 |
| YOLO26m | OpenVINO | INT8 | ✅ | 20.6 | 0.6055 | 5.7 |
| YOLO26l | PyTorch (CPU) | FP32 | ✅ | 50.7 | 0.6215 | 201.57 |
| YOLO26l | OpenVINO | FP32 | ✅ | 95.3 | 0.6203 | 11.32 |
| YOLO26l | OpenVINO | FP16 | ✅ | 48.1 | 0.6203 | 11.36 |
| YOLO26l | OpenVINO | INT8 | ✅ | 25.2 | 0.5938 | 7.45 |
| YOLO26x | PyTorch (CPU) | FP32 | ✅ | 113.2 | 0.6512 | 431.04 |
| YOLO26x | OpenVINO | FP32 | ✅ | 213.2 | 0.6568 | 19.08 |
| YOLO26x | OpenVINO | FP16 | ✅ | 107.1 | 0.6568 | 19.63 |
| YOLO26x | OpenVINO | INT8 | ✅ | 54.8 | 0.6385 | 13.69 |
Intel® Core™ Ultra™ 7 155H#
Risultati dettagliati del benchmark
| Modello | Formato | Precision | Stato | Dimensione (MB) | metrics/mAP50-95(B) | Tempo di inferenza (ms/im) |
|---|---|---|---|---|---|---|
| YOLO26n | PyTorch (CPU) | FP32 | ✅ | 5.3 | 0.4765 | 33.19 |
| YOLO26n | OpenVINO | FP32 | ✅ | 9.6 | 0.4758 | 9.13 |
| YOLO26n | OpenVINO | FP16 | ✅ | 5.1 | 0.4758 | 9.07 |
| YOLO26n | OpenVINO | INT8 | ✅ | 3.2 | 0.4573 | 5.79 |
| YOLO26s | PyTorch (CPU) | FP32 | ✅ | 19.5 | 0.5703 | 70.92 |
| YOLO26s | OpenVINO | FP32 | ✅ | 36.7 | 0.5616 | 16.37 |
| YOLO26s | OpenVINO | FP16 | ✅ | 18.6 | 0.5616 | 16.65 |
| YOLO26s | OpenVINO | INT8 | ✅ | 10.0 | 0.545 | 9.27 |
| YOLO26m | PyTorch (CPU) | FP32 | ✅ | 42.2 | 0.6196 | 192.45 |
| YOLO26m | OpenVINO | FP32 | ✅ | 78.4 | 0.6167 | 34.47 |
| YOLO26m | OpenVINO | FP16 | ✅ | 39.5 | 0.6167 | 35.71 |
| YOLO26m | OpenVINO | INT8 | ✅ | 20.6 | 0.6039 | 15.46 |
| YOLO26l | PyTorch (CPU) | FP32 | ✅ | 50.7 | 0.6215 | 239.19 |
| YOLO26l | OpenVINO | FP32 | ✅ | 95.3 | 0.621 | 43.24 |
| YOLO26l | OpenVINO | FP16 | ✅ | 48.1 | 0.621 | 43.4 |
| YOLO26l | OpenVINO | INT8 | ✅ | 25.2 | 0.5999 | 19.72 |
| YOLO26x | PyTorch (CPU) | FP32 | ✅ | 113.2 | 0.6512 | 511.89 |
| YOLO26x | OpenVINO | FP32 | ✅ | 213.2 | 0.6552 | 79.49 |
| YOLO26x | OpenVINO | FP16 | ✅ | 107.1 | 0.6552 | 79.45 |
| YOLO26x | OpenVINO | INT8 | ✅ | 54.8 | 0.642 | 34.66 |
Riproduci i nostri risultati#
Per riprodurre i benchmark di Ultralytics sopra indicati su tutti i formati di esportazione, esegui questo codice:
from ultralytics import YOLO
# Load a YOLO26n PyTorch model
model = YOLO("yolo26n.pt")
# Benchmark YOLO26n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml")Nota che i risultati dei benchmark potrebbero variare in base alla configurazione hardware e software esatta di un sistema, nonché al carico di lavoro corrente del sistema al momento dell'esecuzione dei benchmark. Per i risultati più affidabili, usa un dataset con un gran numero di immagini, ad esempio data='coco.yaml' (5000 immagini di validazione).
Conclusione#
I risultati del benchmarking dimostrano chiaramente i vantaggi dell'esportazione del modello YOLO26 nel formato OpenVINO. Tra diversi modelli e piattaforme hardware, il formato OpenVINO supera costantemente gli altri formati in termini di velocità di inferenza, mantenendo un'accuratezza comparabile.
I benchmark sottolineano l'efficacia di OpenVINO come strumento per implementare modelli di deep learning. Convertendo i modelli nel formato OpenVINO, gli sviluppatori possono ottenere significativi miglioramenti delle prestazioni, rendendo più facile implementare questi modelli in applicazioni reali.
Per informazioni più dettagliate e istruzioni sull'uso di OpenVINO, fai riferimento alla documentazione ufficiale di OpenVINO.
FAQ#
L'esportazione dei modelli YOLO26 nel formato OpenVINO può migliorare significativamente la velocità della CPU e abilitare le accelerazioni GPU e NPU sull'hardware Intel. Per esportare, puoi utilizzare Python o la CLI come mostrato di seguito:
Esempiofrom ultralytics import YOLO # Load a YOLO26n PyTorch model model = YOLO("yolo26n.pt") # Export the model model.export(format="openvino") # creates 'yolo26n_openvino_model/'Per ulteriori informazioni, fai riferimento alla documentazione sui formati di esportazione.
L'utilizzo del toolkit OpenVINO di Intel con i modelli YOLO26 offre diversi vantaggi:
- Prestazioni: Ottieni fino a 3x di velocità nell'inferenza su CPU e sfrutta le GPU e le NPU Intel per l'accelerazione.
- Ottimizzatore di modelli: Converti, ottimizza ed esegui modelli da framework popolari come PyTorch, TensorFlow e ONNX.
- Facilità d'uso: È disponibile un'ampia raccolta di notebook tutorial per aiutare gli utenti a iniziare, inclusi quelli per YOLO26.
- Esecuzione eterogenea: Implementa modelli su vari hardware Intel con una API unificata.
Per confronti dettagliati delle prestazioni, visita la nostra sezione dei benchmark.
Dopo aver esportato un modello YOLO26n nel formato OpenVINO, puoi eseguire l'inferenza utilizzando Python o la CLI:
Esempiofrom ultralytics import YOLO # Load the exported OpenVINO model ov_model = YOLO("yolo26n_openvino_model/") # Run inference results = ov_model("https://ultralytics.com/images/bus.jpg")Fai riferimento alla nostra documentazione sulla modalità predict per maggiori dettagli.
YOLO26 di Ultralytics è ottimizzato per il rilevamento di oggetti in tempo reale con alta precisione e velocità. Nello specifico, quando combinato con OpenVINO, YOLO26 fornisce:
- Fino a 3x di velocità sulle CPU Intel
- Distribuzione fluida su GPU e NPU Intel
- Accuratezza coerente e comparabile tra vari formati di esportazione
Per un'analisi approfondita delle prestazioni, controlla i nostri benchmark di YOLO26 dettagliati su diversi hardware.
Sì, puoi testare i modelli YOLO26 in vari formati, inclusi PyTorch, TorchScript, ONNX e OpenVINO. Usa il seguente frammento di codice per eseguire i benchmark sul tuo dataset scelto:
Esempiofrom ultralytics import YOLO # Load a YOLO26n PyTorch model model = YOLO("yolo26n.pt") # Benchmark YOLO26n speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8 dataset for all export formats results = model.benchmark(data="coco8.yaml")Per risultati dettagliati dei benchmark, fai riferimento alla nostra sezione dei benchmark e alla documentazione sui formati di esportazione.