Inizia

Esportazione Intel OpenVINO

OpenVINO è il toolkit open source di Intel per ottimizzare ed eseguire l'inferenza AI. Esportando un modello Ultralytics YOLO26 con format="openvino" viene creata una directory yolo26n_openvino_model/ che contiene un modello OpenVINO IR (file .xml e .bin) per CPU Intel, GPU Intel integrate e discrete e NPU Intel, con precisione FP32, FP16 o INT8.

In breve#

ProprietàDettagli
argomento formatopenvino
Outputyolo26n_openvino_model/, una directory con yolo26n.xml, yolo26n.bin e metadata.yaml; yolo26n_int8_openvino_model/ per un'esportazione quantize=8
Esecuzione suCPU Intel, GPU Intel integrate e discrete e NPU Intel. Il dispositivo CPU funziona anche su altri processori x86-64 e ARM64, come quelli di AMD e Apple silicon
RuntimeOpenVINO Runtime 2024.0.0 o versioni successive (il pacchetto Python openvino)
PrecisioneFP32, FP16, INT8. YOLO26n occupa 10,1 MB in FP32, 5,3 MB in FP16 e 3,3 MB in INT8
Sistema per l'esportazioneLinux, macOS o Windows. L'esportazione viene eseguita sulla CPU e non richiede una GPU
Esportazione nel cloud

Ultralytics Platform può esportare per te un modello addestrato in formato OpenVINO, quindi non ti serve un ambiente di esportazione locale.

Guida rapida#

Installa il pacchetto Ultralytics con le dipendenze per l'esportazione OpenVINO:

pip install "ultralytics[export-openvino]"

Questa installazione include openvino e, con Python 3.9 o versioni successive, nncf per la quantizzazione INT8. Se usi un semplice pip install ultralytics, la prima esportazione installa i pacchetti mancanti. L'esportazione richiede le seguenti versioni:

PacchettoVersione richiesta
torch2.1 o versioni successive
openvino2024.0.0 o versioni successive; 2025.2.0 o versioni successive su macOS 15.4 e successivi
nncf2.14.0 o versioni successive, solo per quantize=8; inferiore a 3.0.0 con PyTorch inferiore a 2.3

Per altri metodi di installazione, consulta la guida all'installazione. Poi esporta il modello e carica la directory esportata per eseguire l'inferenza o convalidarne l'accuratezza. Il corso OpenVINO su CPU illustra gli stessi passaggi.

Esporta
from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta il modello nel formato OpenVINO
model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

# Esporta un modello OpenVINO quantizzato INT8 con dati di calibrazione
model.export(format="openvino", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8_openvino_model/'
Predici
from ultralytics import YOLO

# Carica il modello OpenVINO esportato
model = YOLO("yolo26n_openvino_model/")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")

# Esegui l'inferenza sulla GPU Intel; usa "npu" per la NPU Intel o "cpu" per la CPU
results = model("https://ultralytics.com/images/bus.jpg", device="xpu")
Convalida
from ultralytics import YOLO

# Carica il modello OpenVINO esportato
model = YOLO("yolo26n_openvino_model/")

# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")

Attività supportate#

L'esportazione OpenVINO supporta tutte e sette le attività Ultralytics con i modelli YOLOv8, YOLO11 e YOLO26: rilevamento, segmentazione, segmentazione semantica, stima della profondità, classificazione, stima della posa e OBB. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include queste head.

Argomenti di esportazione#

ArgomentoTipoPredefinitoDescrizione
formatstr'openvino'Formato di destinazione del modello esportato, che definisce la compatibilità con i vari ambienti di distribuzione.
imgszint o tuple640Dimensione dell'immagine di input del modello: un numero intero per immagini quadrate oppure una tupla (height, width). Se non viene specificata, l'esportazione usa la dimensione usata per addestrare il checkpoint. I checkpoint ufficiali di YOLO26 usano 640 per i modelli di rilevamento, segmentazione, posa e semantici preaddestrati su ADE20K, 1024 per OBB e i modelli semantici preaddestrati su Cityscapes, 768 per la profondità e 224 per la classificazione.
quantizeint o strNonePrecisione della quantizzazione: 16 (FP16: i pesi sono memorizzati a precisione dimezzata, mentre input e output restano FP32) oppure 8 (quantizzazione post-addestramento INT8 con NNCF, usando immagini di calibrazione da data, salvate in una directory _int8_openvino_model/); 32/non impostato corrisponde a FP32. Un checkpoint addestrato con quantize=8 non può essere esportato in OpenVINO; consulta Limitazioni e risoluzione dei problemi. Sostituisce i flag deprecati half/int8.
datastrNoneFile YAML del dataset usato per la calibrazione INT8; per la classificazione si usa invece una directory del dataset o il nome di un dataset integrato. La calibrazione usa lo split val, a meno che non sia impostato split. Se omesso con quantize=8, Ultralytics usa il piccolo dataset predefinito per l'attività del modello, ad esempio coco8.yaml per il rilevamento.
fractionfloat, int o list1.0Sottoinsieme di calibrazione espresso come rapporto, numero di immagini o rapporti/conteggi [train, val, test]. Gli elenchi di due elementi lasciano completo test, mentre 0 lo esclude.
dynamicboolFalseRende dinamiche le dimensioni di batch, altezza e larghezza dell'input, così che un modello possa accettare diverse dimensioni di batch e di immagine. Su una NPU Intel, un modello dinamico funziona comunque con imgsz dell'esportazione; consulta Distribuzione.
nmsbool, facoltativoNoneSeleziona l'output grezzo (None, predefinito), NMS integrata (True) oppure la head senza NMS (False). Consulta il formato di output.
batchint1Dimensione del batch del modello esportato. In un'esportazione statica, questa dimensione del batch è fissa nella forma dell'input. È anche la dimensione del batch usata per la calibrazione INT8.
devicestrNoneL'esportazione viene sempre eseguita sulla CPU. Con quantize=8, device=npu seleziona attivazioni INT8 simmetriche per i modelli YOLO di rilevamento, segmentazione, posa e OBB, che funzionano fino a 2 volte più velocemente sulle NPU Intel.

Per gli argomenti condivisi da tutti i formati, consulta la documentazione della modalità di esportazione.

Quantizzazione INT8#

quantize=8 applica la quantizzazione post-addestramento con NNCF: durante l'esportazione, le immagini di calibrazione vengono elaborate dal modello e, dove possibile, pesi e attivazioni vengono memorizzati come interi a 8 bit.

  • Dati di calibrazione: l'esportazione esegue la calibrazione su ogni batch completo dello split val di data o dello split impostato con split. Usa fraction per limitare il numero di immagini. Se le immagini sono meno di 300, l'esportazione mostra un avviso.
  • Head di rilevamento: per i modelli con una head di rilevamento YOLO (rilevamento, segmentazione, posa e OBB) e per RT-DETR, le operazioni che decodificano gli output della head (reshape, concatenazione, decodifica delle box e DFL) e tutte le operazioni sigmoid restano in virgola mobile, mentre le convoluzioni della head vengono quantizzate. I modelli di classificazione, segmentazione semantica e profondità non hanno operazioni escluse.
  • Input e output: un modello INT8 mantiene l'input float32 e gli output del modello FP32, quindi il codice di inferenza scritto per il modello FP32 funziona senza modifiche.
  • NPU Intel: aggiungi device=npu a un'esportazione INT8 che intendi eseguire su una NPU Intel. Questa opzione passa i modelli YOLO di rilevamento, segmentazione, posa e OBB dalla quantizzazione asimmetrica a quella simmetrica delle attivazioni.
Esempio
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Esegui la calibrazione sul 10% delle immagini di convalida COCO (500 immagini); sostituisci coco.yaml con il tuo dataset
model.export(format="openvino", quantize=8, data="coco.yaml", fraction=0.1)

# Carica il modello INT8 esportato ed esegui l'inferenza
model = YOLO("yolo26n_int8_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg")

Nei benchmark, i modelli INT8 hanno funzionato da 1,02 a 1,33 volte più velocemente dei modelli FP32 su una CPU server, con una perdita da 0,5 a 0,9 mAP su COCO val2017. Sulle CPU Intel Core Ultra, INT8 ha funzionato da 1,2 a 3,8 volte più velocemente di FP32. Convalida un modello INT8 sui tuoi dati prima di distribuirlo.

Formato di output#

L'esportazione crea una directory con tre file:

FileContenuti
yolo26n.xmlIl grafo della rete in formato OpenVINO IR
yolo26n.binI pesi
metadata.yamlNomi delle classi, attività, dimensione dell'immagine, dimensione del batch, stride e argomenti di esportazione, che Ultralytics legge quando carica il modello

Il modello accetta un input con forma (batch, 3, height, width), in RGB e ridimensionato nell'intervallo 0-1. L'input e gli output sono float32 nei modelli FP32, FP16 e INT8, fatta eccezione per l'output della segmentazione semantica, una mappa delle classi uint8 (int32 per i modelli con più di 256 classi). I tensori non hanno i nomi images e output0 dell'esportazione ONNX, quindi nel tuo codice fai riferimento all'input e agli output tramite indice.

Le forme degli output sono le stesse dell'esportazione ONNX e dipendono dall'attività e dall'argomento nms: un modello di rilevamento YOLO26n esportato con imgsz=640 restituisce (1, 84, 8400) con il valore predefinito nms=None e (1, 300, 6) con nms=False o nms=True. Consulta il formato degli output ONNX per conoscere forme e contenuti di ogni attività. Con nms=True, la soglia di confidenza conf (predefinita 0.25), la soglia IoU iou, agnostic_nms e max_det sono fissate nel grafo durante l'esportazione. Un valore conf più basso in fase di predizione o convalida non può ripristinare i rilevamenti già rimossi dal grafo, quindi esporta di nuovo per modificare questi valori.

Distribuisci#

YOLO("yolo26n_openvino_model/") esegue il modello con OpenVINO Runtime e associa l'argomento device a un dispositivo OpenVINO:

deviceDispositivo OpenVINO
non impostatoAUTO, che consente a OpenVINO di scegliere tra la CPU e le GPU Intel (l'elenco predefinito delle priorità esclude la NPU), oppure CPU quando la CPU è l'unico dispositivo rilevato da OpenVINO
cpuCPU
xpu o xpu:0GPU o GPU.0, la GPU Intel integrata o discreta. xpu:1 seleziona GPU.1 su una macchina con due GPU Intel
npuNPU, l'unità di elaborazione neurale dei processori Intel Core Ultra

Altri valori, come 0 o mps, vengono gestiti come se device non fosse impostato. I nomi precedenti intel:cpu, intel:gpu e intel:npu continuano a funzionare e generano un avviso di deprecazione. La tabella dei dispositivi di inferenza confronta questi nomi nei diversi formati. La riga di log Using OpenVINO LATENCY mode for batch=1 inference on CPU... indica il dispositivo segnalato da OpenVINO al caricamento del modello. Con AUTO può essere la CPU, mentre una GPU Intel sta ancora compilando il modello: imposta quindi device per avere la certezza. Per un modello .pt, device="xpu" seleziona invece il backend GPU Intel di PyTorch, che è anche il dispositivo per l'addestramento su GPU Intel, mentre device="npu" seleziona una NPU Huawei Ascend, non la NPU Intel.

Il comportamento in fase di inferenza dipende da come è stato esportato il modello:

  • Esportazione statica (predefinita): il modello viene sempre eseguito con imgsz e batch dell'esportazione, che Ultralytics legge da metadata.yaml. Un imgsz passato a predict viene ignorato. I batch più grandi vengono suddivisi in blocchi della dimensione del batch di esportazione e quelli più piccoli vengono completati con padding, quindi è possibile elaborare un numero qualsiasi di immagini.
  • Esportazione dinamica (dynamic=True): predict accetta diverse dimensioni di batch e ogni imgsz che sia un multiplo dello stride del modello. Le NPU Intel e i modelli INT8 su CPU Intel AMX fanno eccezione; consulta Limitazioni e risoluzione dei problemi.
  • Modalità latenza: Ultralytics compila il modello con il suggerimento di prestazioni OpenVINO LATENCY ed esegue l'inferenza in modo sincrono. Per gestire molte richieste parallele con il suggerimento THROUGHPUT, usa l'API OpenVINO Runtime come illustrato nella guida a latenza e throughput.
  • NPU Intel: Ultralytics compila il modello per una dimensione del batch pari a 1 sulla NPU e suddivide i batch più grandi in singole immagini. Su una NPU, un'esportazione dinamica viene fissata a imgsz dell'esportazione.

Esegui il modello con l'API OpenVINO Runtime#

Per eseguire il modello al di fuori del pacchetto Ultralytics, carica il file .xml con il pacchetto openvino. Il modello si aspetta un'immagine preelaborata e restituisce gli output grezzi descritti in Formato degli output, quindi il letterboxing e, per un'esportazione predefinita, NMS sono a carico del tuo codice:

# Esporta prima: yolo export model=yolo26n.pt format=openvino nms=False
import numpy as np
import openvino as ov
import yaml

core = ov.Core()
model = core.read_model("yolo26n_openvino_model/yolo26n.xml")
compiled = core.compile_model(model, "AUTO")  # oppure "CPU", "GPU", "NPU"

image = np.zeros((1, 3, 640, 640), dtype=np.float32)  # la tua immagine preelaborata: RGB, NCHW, 0-1
detections = compiled(image)[0][0]  # primo output, prima immagine: shape (300, 6)
detections = detections[detections[:, 4] > 0.25]  # mantieni le righe sopra la soglia di confidenza

with open("yolo26n_openvino_model/metadata.yaml") as f:
    names = yaml.safe_load(f)["names"]  # {0: 'person', 1: 'bicycle', ...}

Guide alla distribuzione#

Limitazioni e risoluzione dei problemi#

  • Versione di PyTorch: l'esportazione non riesce con OpenVINO export requires torch>=2.1 nelle versioni precedenti di PyTorch.
  • macOS 15.4 e versioni successive: OpenVINO 2025.1.0 e versioni precedenti non funzionano con queste versioni di macOS, quindi in questo caso l'esportazione richiede openvino>=2025.2.0 e aggiorna un pacchetto meno recente.
  • Checkpoint addestrati con quantize=8: un checkpoint ottimizzato con l'addestramento consapevole della quantizzazione non può essere esportato con format='openvino' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Esporta invece il checkpoint da cui hai avviato l'ottimizzazione con quantize=8, oppure esporta il checkpoint ottimizzato in ONNX o TensorRT.
  • Esportazione INT8 senza data: l'esportazione registra INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. ed esegue la calibrazione sul piccolo dataset predefinito per l'attività. Passa data con immagini che rappresentino i dati di distribuzione.
  • Dimensioni del set di calibrazione INT8: l'esportazione registra >300 images recommended for INT8 calibration, found 4 images. quando lo split di calibrazione contiene meno di 300 immagini. coco8.yaml ha solo 4 immagini di convalida, sufficienti per testare l'esportazione ma non per calibrare un modello da distribuire.
  • Directory di output: ogni esportazione dello stesso checkpoint, tranne quelle INT8, scrive nella stessa directory yolo26n_openvino_model/, indipendentemente da quantize, imgsz, dynamic, nms o batch; quindi, l'esportazione successiva sostituisce quella precedente. Tutte le esportazioni INT8, con o senza device=npu, condividono yolo26n_int8_openvino_model/.
  • Dispositivo non disponibile: se il dispositivo richiesto non è presente, Ultralytics registra OpenVINO device 'GPU' not available. Using 'AUTO' instead. (oppure Using 'CPU' instead. su una macchina in cui OpenVINO rileva solo la CPU) e continua a usare quel dispositivo. Verifica che il tuo processore sia supportato da OpenVINO e installa il driver Intel per GPU o NPU.
  • NPU Intel: Ultralytics esegue una NPU con dimensione del batch pari a 1 e forme di input fisse; consulta Distribuzione. Passa device=npu per usarla: se device non è impostato, la NPU non viene selezionata.
  • Forme dinamiche con NMS: un'esportazione con dynamic=True e nms=True registra 'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'. se batch mantiene il valore 1. Ultralytics esegue i batch più grandi suddividendoli in blocchi della dimensione batch dell'esportazione.
  • Modelli INT8 dinamici su CPU Intel AMX: su Linux con una CPU che supporta AMX (Intel Sapphire Rapids e versioni successive), Ultralytics esegue un modello INT8 dinamico sul dispositivo CPU o AUTO con imgsz dell'esportazione, come farebbe con un modello statico: un imgsz passato a predict o val viene ignorato e val usa batch dell'esportazione. predict continua ad accettare altre dimensioni di batch e ricompila il modello per ogni nuova dimensione del batch, quindi la prima inferenza con una nuova dimensione del batch è più lenta.
  • Windows: su Windows, Ultralytics imposta su FP32 il suggerimento di precisione per l'inferenza su CPU, impedendo a OpenVINO di usare kernel in virgola mobile a precisione inferiore (i modelli INT8 continuano a funzionare in INT8), e limita oneDNN ai set di istruzioni precedenti ad AMX. Imposta la variabile d'ambiente ONEDNN_MAX_CPU_ISA prima di caricare il modello per usare un limite diverso.
  • Linux su ARM64: Ultralytics esegue il dispositivo CPU in modalità di esecuzione OpenVINO orientata all'accuratezza, con precisione di inferenza FP32.
  • NMS integrata: nms=True genera 'nms=True' is not valid for classification models. per la classificazione e viene ignorata con un avviso per i modelli di segmentazione semantica e stima della profondità ('nms=True' is not valid for semantic models. Forcing 'nms=None'.) e per i modelli RT-DETR ('nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.).
  • Head senza NMS: nms=False richiede un modello con una head senza NMS, come YOLO26 o YOLOv10. Per gli altri modelli, ad esempio YOLO11, l'esportazione mostra l'avviso This model has no one-to-one head; using one-to-many outputs. e scrive l'output grezzo (1, 84, 8400).

Per altri errori, consulta la guida ai problemi comuni.

Benchmark OpenVINO YOLO26#

Le tabelle seguenti confrontano PyTorch con i modelli OpenVINO FP32, FP16 e INT8 di ogni modello di rilevamento YOLO26. Il primo gruppo di misurazioni è stato raccolto su una CPU server con l'accuratezza COCO val2017; il secondo su tre processori Intel Core Ultra, usando CPU e GPU e la NPU di due di essi. La pagina dei modelli YOLO26 riporta l'accuratezza, la velocità ONNX su CPU e la velocità TensorRT su T4 di ogni modello.

FP32, FP16 e INT8 su una CPU server#

Tutti i valori di questa sezione sono stati misurati sulla CPU di un server con due processori AMD EPYC 9655 a 96 core, non su una CPU Intel. PyTorch è stato eseguito con 8 thread e OpenVINO con 96 thread, i valori predefiniti scelti da Ultralytics e OpenVINO su quel server; le colonne PyTorch e OpenVINO differiscono quindi sia per il numero di thread sia per il runtime. Inoltre, la convalida PyTorch ha usato l'inferenza rettangolare, con ogni immagine completata con padding fino a un rettangolo che ne rispetta le proporzioni (512x672 per un'immagine 480x640), mentre i modelli OpenVINO statici sono sempre stati eseguiti a 640x640.

Millisecondi per immagine; valori inferiori sono migliori. Il formato più veloce per ogni modello è in grassetto.

ModelloimgszPyTorchOpenVINO FP32OpenVINO FP16OpenVINO INT8
YOLO26n64013.313.413.333.35
YOLO26s64024.285.185.184.51
YOLO26m64049.948.398.346.60
YOLO26l64063.7510.9211.058.94
YOLO26x640115.1117.1217.1612.83

YOLO26n sulle stesse 8 CPU (PyTorch e OpenVINO entrambi assegnati alle CPU da 0 a 7 di quel server con taskset):

MetricaPyTorchOpenVINO FP32OpenVINO FP16OpenVINO INT8
Latenza (ms/immagine)9.287.137.146.71
mAPval 50-9540.840.940.940.3
  • OpenVINO FP32 ha funzionato da 3,9 a 6,7 volte più velocemente di PyTorch con i numeri di thread predefiniti indicati sopra, mantenendo un'accuratezza entro 0,1 mAP. Assegnando entrambi agli stessi 8 processori, con PyTorch che funzionava più velocemente rispetto alla configurazione predefinita, OpenVINO FP32 ha eseguito YOLO26n 1,3 volte più velocemente di PyTorch e INT8 1,06 volte più velocemente di FP32.
  • FP16 ha dimezzato le dimensioni del modello, mantenendo un'accuratezza entro 0,1 mAP rispetto a FP32 e una latenza pari a quella di FP32 (con una differenza massima del 3%).
  • INT8 ha funzionato da 1,02 a 1,33 volte più velocemente di FP32, ridotto le dimensioni del modello da 3,1 a 3,9 volte e perso da 0,5 a 0,9 mAP.

Misurazioni effettuate con ultralytics 8.4.212, OpenVINO 2026.4.1, NNCF 3.4.0 e PyTorch 2.15.0 su batch=1 il 14 novembre 2026. La latenza è la fase di inferenza riportata da val e non include la preelaborazione né la postelaborazione. I valori PyTorch, FP32 e FP16 sono la media di tre esecuzioni, che hanno mostrato variazioni fino al 26% per PyTorch e al 6% per OpenVINO. I modelli INT8 sono stati calibrati su 591 immagini COCO train2017 (split=train fraction=0.005) e compilati tre volte; i valori INT8 sono la media delle tre compilazioni. La tabella con 8 CPU usa un'unica compilazione INT8 eseguita tre volte.

CPU, GPU e NPU Intel Core Ultra#

Queste tabelle sono state misurate su tre processori Intel Core Ultra con openvino 2026.2.1 in modalità benchmark: model.benchmark(data="coco128.yaml", format="openvino", device=...), con device impostato su cpu, xpu o npu. L'accuratezza è mAP50-95 sul dataset COCO128 da 128 immagini, quindi non è confrontabile con i valori COCO val2017 riportati sopra. PyTorch è stato eseguito sulla CPU dello stesso processore. I modelli YOLO26 funzionano sulla NPU solo dei processori Intel Core Ultra serie 2xxV, serie 3xx e successivi.

Intel Core Ultra X7 358H#

L'Intel Core Ultra X7 358H (Panther Lake) integra core CPU, una GPU Intel Arc integrata e una NPU Intel AI Boost.

Millisecondi per immagine; un valore più basso è migliore. La colonna più veloce per ogni modello è in grassetto.

ModelloCPU PyTorchCPU FP32CPU FP16CPU INT8GPU FP32GPU FP16GPU INT8NPU FP32NPU FP16NPU INT8
YOLO26n29.2814.3514.239.994.094.034.247.687.718.60
YOLO26s59.3235.0333.5516.685.085.144.479.899.9410.69
YOLO26m143.2190.5388.8233.337.107.065.6113.0213.1314.84
YOLO26l181.16112.83111.3143.278.458.496.2514.5314.5515.64
YOLO26x379.75241.21236.8778.9213.0312.988.7423.4823.4121.56

Processori Intel Core Ultra precedenti#

Intel Core Ultra 7 258V (Lunar Lake)

Millisecondi per immagine; un valore più basso è migliore. La colonna più veloce per ogni modello è in grassetto.

ModelloCPU PyTorchCPU FP32CPU FP16CPU INT8GPU FP32GPU FP16GPU INT8NPU FP32NPU FP16NPU INT8
YOLO26n27.3316.8416.738.623.333.343.4623.7123.7023.96
YOLO26s60.2054.7154.4520.194.664.653.9926.6226.6225.89
YOLO26m152.87178.59179.2553.079.038.985.7032.9433.0130.95
YOLO26l201.57238.15233.7067.7311.3211.367.4536.0235.7732.64
YOLO26x431.04567.22561.39151.1119.0819.6313.6949.6449.6941.75
Intel Core Ultra 7 155H (Meteor Lake)

Millisecondi per immagine; un valore più basso è migliore. La colonna più veloce per ogni modello è in grassetto.

ModelloCPU PyTorchCPU FP32CPU FP16CPU INT8GPU FP32GPU FP16GPU INT8
YOLO26n33.1913.4313.2011.409.139.075.79
YOLO26s70.9236.1636.0715.5416.3716.659.27
YOLO26m192.45102.52101.8835.7234.4735.7115.46
YOLO26l239.19129.24128.5045.3843.2443.4019.72
YOLO26x511.89293.40296.4885.2479.4979.4534.66

Sui tre processori:

  • CPU: INT8 è risultato da 1,2 a 3,8 volte più veloce di FP32 e da 2,9 a 6,0 volte più veloce di PyTorch. FP32 è risultato da 1,6 a 2,5 volte più veloce di PyTorch su X7 358H e 155H, ma più lento di PyTorch per YOLO26m, YOLO26l e YOLO26x su 258V.
  • GPU: la GPU integrata ha eseguito i modelli FP32 da 3,6 a 29,1 volte più velocemente di PyTorch sulla CPU. INT8 è risultato più veloce di FP32 per tutti i modelli tranne YOLO26n su X7 358H e 258V, fino a 2,3 volte.
  • NPU (X7 358H e 258V): i modelli FP32 sono stati eseguiti da 1,2 a 16,2 volte più velocemente di PyTorch sulla CPU, mentre INT8 ha raggiunto una velocità pari da 0,88 a 1,19 volte quella di FP32. Questi modelli INT8 sono stati esportati prima che device=npu selezionasse attivazioni simmetriche, quindi le tabelle non mostrano l'esportazione INT8 ottimizzata per NPU.
  • La latenza FP16 è rimasta entro il 5% di FP32 su tutti i dispositivi e INT8 ha perso da 0,1 a 2,7 punti di mAP50-95.

Informazioni su OpenVINO#

OpenVINO, abbreviazione di Open Visual Inference and Rete neurale Optimization, converte i modelli provenienti da framework come PyTorch nel proprio formato IR e li esegue tramite un'unica API su CPU, GPU e NPU Intel. Per la documentazione completa, consulta la documentazione di OpenVINO.

OpenVINO Intel AI inference toolkit



Guarda: Come esportare Ultralytics YOLO26 nel formato Intel OpenVINO per inferenze più veloci 🚀

Domande frequenti#

  • Sì, sulla CPU. Il dispositivo OpenVINO CPU funziona sui processori x86-64 e ARM64: i benchmark delle CPU server in questa pagina sono stati misurati su processori AMD EPYC e la stessa esportazione funziona sui chip Apple. I dispositivi GPU e NPU richiedono hardware Intel, quindi device=xpu e device=npu ripiegano su un'alternativa con un avviso su altre macchine. Per altri target, consulta la guida alle opzioni di distribuzione dei modelli.

  • Dipende dal dispositivo. FP16 (quantize=16) non richiede dati di calibrazione, dimezza le dimensioni del modello e ha mantenuto l'accuratezza e la latenza di FP32 nei benchmark, quindi usalo quando le dimensioni del modello sono importanti. INT8 (quantize=8) ha offerto la latenza CPU più bassa per la maggior parte dei modelli: sulla CPU server ha ridotto la latenza di YOLO26s da 5.18 ms a 4.51 ms per immagine, con 47.6 mAPval 50-95 rispetto a 48.5 in FP32, e sulle CPU Intel Core Ultra è risultato da 1,2 a 3,8 volte più veloce di FP32. Sulle GPU Intel integrate il vantaggio di INT8 è stato minore, fino a 2,3 volte, mentre sulle NPU i modelli INT8 di queste esecuzioni, esportati senza device=npu, sono risultati all'incirca veloci quanto FP32. INT8 richiede dati di calibrazione rappresentativi, quindi convalida il modello INT8 sui tuoi dati prima di sceglierlo.

  • Esporta con dynamic=True e specifica il batch e imgsz che ti servono al momento della previsione. La dimensione dell'immagine deve essere un multiplo dello stride del modello, pari a 32 per i checkpoint YOLO26 ufficiali, tranne quelli di classificazione; consulta Deploy per le eccezioni.

    Esportazione dinamica
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    model.export(format="openvino", dynamic=True)
    
    model = YOLO("yolo26n_openvino_model/")
    results = model(["https://ultralytics.com/images/bus.jpg"] * 4, imgsz=320)  # un batch di 4 immagini a 320 pixel
  • Usa OpenVINO quando l'hardware di distribuzione è Intel: device=xpu e device=npu selezionano rispettivamente la GPU e la NPU Intel, e nei benchmark i modelli OpenVINO INT8 sono risultati da 1,2 a 3,8 volte più veloci di FP32 sulle CPU Intel Core Ultra. Usa ONNX quando un unico file deve funzionare anche su GPU NVIDIA o AMD o in runtime diversi da OpenVINO; su Windows, Windows ML può selezionare hardware Intel per un modello ONNX.

Commenti23

Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.

  1. EduardoNewGitHub

    I encountered some difficulties while trying to run the official video demo. Here is my code:

    from ultralytics import YOLO

    def main(): # Load a YOLOv8n PyTorch model model = YOLO("yolov8n.pt")

    # Export the model
    model.export(format="openvino")  # creates 'yolov8n_openvino_model/'
    
    # Load the exported OpenVINO model with explicit task definition
    ov_model = YOLO("yolov8n_openvino_model\\", task='detect')  # Explicitly define task as 'detect'
    
    # Run inference
    results_original = model("D:\\python_YOLO_test\\bus.jpg")
    
    # Run ov inference
    results_ov = ov_model("D:\\python_YOLO_test\\bus.jpg")

    if name == "main": main() Additional notes: My environment is openvino==2024.0.0, and I executed pip install --upgrade torch ultralytics.

    The issue I encountered is as follows:

    Results saved to D:\python_YOLO_test Ultralytics YOLOv8.2.57 🚀 Python-3.11.9 torch-2.1.1+cu118 CPU (11th Gen Intel Core(TM) i7-11800H 2.30GHz) YOLOv8n summary (fused): 168 layers, 3,151,904 parameters, 0 gradients, 8.7 GFLOPs

    PyTorch: starting from 'yolov8n.pt' with input shape (1, 3, 640, 640) BCHW and output shape(s) (1, 84, 8400) (6.2 MB)

    OpenVINO: starting export with openvino 2024.0.0-14509-34caeefd078-releases/2024/0... OpenVINO: export success ✅ 2.8s, saved as 'yolov8n_openvino_model' (12.3 MB)

    Export complete (5.2s) Results saved to D:\python_YOLO_test Predict: yolo predict task=detect model=yolov8n_openvino_model imgsz=640
    Validate: yolo val task=detect model=yolov8n_openvino_model imgsz=640 data=coco.yaml
    Visualize: https://netron.app

    image 1/1 D:\python_YOLO_test\bus.jpg: 640x480 4 persons, 1 bus, 1 stop sign, 324.0ms Speed: 24.0ms preprocess, 324.0ms inference, 21.0ms postprocess per image at shape (1, 3, 640, 480) Loading yolov8n_openvino_model for OpenVINO inference... Using OpenVINO LATENCY mode for batch=1 inference...

    Process finished with exit code -1073741819 (0xC0000005)

    Process finished with exit code -1073740791 (0xC0000409) The model was successfully exported but did not perform inference, instead, it terminated directly. How should I resolve this issue?

    1. Glenn JocherUltralytics(modificato)

      @EduardoNew the exit code 0xC0000005 often indicates a memory access violation. Let's address this step-by-step:

      1. Path Format: Try using forward slashes in your OpenVINO model path: "yolov8n_openvino_model/" instead of backslashes.

      2. OpenVINO Version: Ultralytics requires openvino>=2024.0.0. Try upgrading to a recent release:

      pip install -U openvino
      1. Hardware Compatibility: Ensure you have the latest Intel drivers installed from Intel's official site.

      If issues persist, please create a Minimum Reproducible Example and open a GitHub Issue following our bug report guidelines. We'll be happy to investigate further!

  2. Ranjith3436GitHub

    You mentioned that the core CPU inference model takes 23.53 ms. I would like to know if the processing time decreases when we increase the number of CPU cores ? currently i am using 12 thread CPU.

    1. Glenn JocherUltralytics

      @Ranjith3436 increasing the number of CPU cores can potentially reduce processing time, as it allows for parallel processing, but the actual speedup will depend on the model's ability to leverage multi-threading effectively.

    2. Glenn JocherUltralytics

      To assess a model's ability to utilize multiple CPU cores, you can check its support for multi-threading or parallel processing in the documentation or by running benchmarks on your hardware configuration.

  3. kimchi2020GitHub

    hey i am working on object detection in videos and came across openvino that helps in increasing speed. how can i use openvino and yolov8 together to find objects in a video

    1. Glenn JocherUltralytics

      @kimchi2020 hi there! It's great to hear that you're exploring OpenVINO to enhance the speed of your object detection tasks in videos. OpenVINO can indeed provide significant performance improvements, especially on Intel hardware.

      To get started with using YOLOv8 and OpenVINO together, follow these steps:

      Exporting YOLOv8 to OpenVINO Format
      1. Export the Model: You can export your YOLOv8 model to the OpenVINO format using the following Python code:

        from ultralytics import YOLO
        
        # Load a YOLOv8n PyTorch model
        model = YOLO("yolov8n.pt")
        
        # Export the model to OpenVINO format
        model.export(format="openvino")  # creates 'yolov8n_openvino_model/'

        Alternatively, you can use the CLI:

        yolo export model=yolov8n.pt format=openvino  # creates 'yolov8n_openvino_model/'
      2. Run Inference with the Exported Model: After exporting, you can run inference using the exported OpenVINO model. Here’s how you can do it in Python:

        from ultralytics import YOLO
        
        # Load the exported OpenVINO model
        ov_model = YOLO("yolov8n_openvino_model/")
        
        # Run inference
        results = ov_model("https://ultralytics.com/images/bus.jpg")

        Or using the CLI:

        yolo predict model=yolov8n_openvino_model source='https://ultralytics.com/images/bus.jpg'
      Running Inference on Videos

      To process videos, you can modify the inference code to read frames from a video file and run the model on each frame. Here’s an example in Python:

      import cv2
      from ultralytics import YOLO
      
      # Load the exported OpenVINO model
      model = YOLO("yolov8n_openvino_model/")
      
      # Open the video file
      video_path = "path/to/your/video.mp4"
      cap = cv2.VideoCapture(video_path)
      
      # Loop through the video frames
      while cap.isOpened():
          ret, frame = cap.read()
          if not ret:
              break
      
          # Run inference on the frame
          results = model(frame)
      
          # Visualize the results on the frame
          annotated_frame = results[0].plot()
      
          # Display the annotated frame
          cv2.imshow("YOLOv8 OpenVINO Inference", annotated_frame)
      
          # Break the loop if 'q' is pressed
          if cv2.waitKey(1) & 0xFF == ord('q'):
              break
      
      # Release the video capture object and close the display window
      cap.release()
      cv2.destroyAllWindows()
      Additional Resources

      For more detailed information and advanced usage, you can refer to the OpenVINO documentation. This guide covers everything from exporting models to running inference and optimizing performance.

      Feel free to reach out if you have any more questions. Happy coding! 🚀

    2. kimchi2020GitHub

      Traceback (most recent call last): File "/home/kimchi/Desktop/yolov8/onnx.py", line 18, in results = model(frame) ^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 174, in call return self.predict(source, stream, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 442, in predict return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 168, in call return list(self.stream_inference(source, model, *args, **kwargs)) # merge list of Result into one ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/utils/_contextlib.py", line 35, in generator_context response = gen.send(None) ^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 234, in stream_inference self.model.warmup(imgsz=(1 if self.model.pt or self.model.triton else self.dataset.bs, 3, *self.imgsz)) File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/nn/autobackend.py", line 626, in warmup import torchvision # noqa (import here so torchvision import time not recorded in postprocess time) ^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/init.py", line 6, in from torchvision import _meta_registrations, datasets, io, models, ops, transforms, utils File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/models/init.py", line 2, in from .convnext import * File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/models/convnext.py", line 8, in from ..ops.misc import Conv2dNormActivation, Permute File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/ops/init.py", line 1, in from ._register_onnx_ops import _register_custom_op File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torchvision/ops/_register_onnx_ops.py", line 5, in from torch.onnx import symbolic_opset11 as opset11 File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/onnx/init.py", line 59, in from ._internal.onnxruntime import ( File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/onnx/_internal/onnxruntime.py", line 36, in import onnx File "/home/kimchi/Desktop/yolov8/onnx.py", line 18, in results = model(frame) ^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 174, in call return self.predict(source, stream, **kwargs) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/model.py", line 442, in predict return self.predictor.predict_cli(source=source) if is_cli else self.predictor(source=source, stream=stream) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 168, in call return list(self.stream_inference(source, model, *args, **kwargs)) # merge list of Result into one ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/torch/utils/_contextlib.py", line 35, in generator_context response = gen.send(None) ^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/engine/predictor.py", line 261, in stream_inference self.results = self.postprocess(preds, im, im0s) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/models/yolo/detect/predict.py", line 25, in postprocess preds = ops.non_max_suppression( ^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/kimchi/Desktop/yolov8/myvenv/lib/python3.12/site-packages/ultralytics/utils/ops.py", line 291, in non_max_suppression i = torchvision.ops.nms(boxes, scores, iou_thres) # NMS ^^^^^^^^^^^^^^^ AttributeError: partially initialized module 'torchvision' has no attribute 'ops' (most likely due to a circular import). Did you mean: 'os'?

      I am getting this error, how to get rid of it and what does it mean

    3. Glenn JocherUltralytics

      Hi @kimchi2020,

      Thank you for reaching out! The error you're encountering seems to be related to a circular import issue with the torchvision library. This can happen if there's a naming conflict or an import loop in your code.

      Steps to Resolve the Issue:
      1. Check for Naming Conflicts: Ensure that your script name (onnx.py) is not conflicting with any library names. Rename your script to something unique, like run_inference.py.

      2. Verify Installation: Make sure you have the latest versions of torch, torchvision, and ultralytics installed. You can update them using:

        pip install --upgrade torch torchvision ultralytics
      3. Reproduce the Issue: If the issue persists, please provide a minimum reproducible example. This helps us diagnose the problem more effectively. You can refer to our guide on creating a reproducible example here: Minimum Reproducible Example.

      Example Code for Inference with OpenVINO:

      Here's a quick example of how to export your YOLOv8 model to OpenVINO and run inference on a video:

      import cv2
      from ultralytics import YOLO
      
      # Load a YOLOv8n PyTorch model
      model = YOLO("yolov8n.pt")
      
      # Export the model to OpenVINO format
      model.export(format="openvino")  # creates 'yolov8n_openvino_model/'
      
      # Load the exported OpenVINO model
      ov_model = YOLO("yolov8n_openvino_model/")
      
      # Open the video file
      video_path = "path/to/your/video.mp4"
      cap = cv2.VideoCapture(video_path)
      
      # Loop through the video frames
      while cap.isOpened():
          ret, frame = cap.read()
          if not ret:
              break
      
          # Run inference on the frame
          results = ov_model(frame)
      
          # Visualize the results on the frame
          annotated_frame = results[0].plot()
      
          # Display the annotated frame
          cv2.imshow("YOLOv8 OpenVINO Inference", annotated_frame)
      
          # Break the loop if 'q' is pressed
          if cv2.waitKey(1) & 0xFF == ord('q'):
              break
      
      # Release the video capture object and close the display window
      cap.release()
      cv2.destroyAllWindows()

      For more detailed information on exporting and using OpenVINO, please refer to our OpenVINO Integration Guide.

      Feel free to reach out if you have any more questions or need further assistance. Happy coding! 🚀

    4. YA12SHYAMGitHub

      Hi @glenn-jocher , what if i want to use intel GPU's for the inference, using device=GPU doesn't seems to works , it looks for cuda i.e nvidia gpu

    5. Glenn JocherUltralytics(modificato)

      To use Intel GPUs for inference, export your YOLOv8 model to OpenVINO format with model.export(format="openvino"), then run inference with the exported model and select the GPU with device="intel:gpu", for example ov_model("bus.jpg", device="intel:gpu"). For more details, please refer to the OpenVINO integration guide.

    6. YA12SHYAMGitHub

      ok, just to confirm i can't use ultralytics python api for inference with intel gpu like i usually do within the ultralytics ecosystem for example ?

      from ultralytics import YOLO
      model =  YOLO(path/to/model)

      here the path/to/model works with onnx, engine, opnevino;s xml , but it use cpu in case of openvino , i want to use my intel GPU

    7. Glenn JocherUltralytics(modificato)

      @YA12SHYAM to use Intel GPUs with YOLOv8, export your model to OpenVINO format and select the GPU at inference with device="intel:gpu", e.g. model("bus.jpg", device="intel:gpu"). For detailed steps, refer to the OpenVINO integration guide.

  4. kanishkaswGitHub

    Hi Im getting the following error when attempting to convert the model to openVino. Tried with both 2024.1.0 and 2024.0.0. Im on ubuntu 20.04 with python 3.8 $ yolo export model=runs/classify/train/weights/best.pt format=openvino Ultralytics YOLOv8.2.31 🚀 Python-3.8.10 torch-2.3.1+cu121 CPU (Intel Core(TM) i9-7900X 3.30GHz) YOLOv8n-cls summary (fused): 73 layers, 1438723 parameters, 0 gradients, 3.3 GFLOPs

    PyTorch: starting from 'runs/classify/train/weights/best.pt' with input shape (1, 3, 320, 320) BCHW and output shape(s) (1, 3) (2.8 MB) OpenVINO: export failure ❌ 0.0s: module 'openvino' has no attribute 'version' Traceback (most recent call last): File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/bin/yolo", line 8, in sys.exit(entrypoint()) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/cfg/init.py", line 591, in entrypoint getattr(model, mode)(**overrides) # default args from model File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/model.py", line 602, in export return Exporter(overrides=args, _callbacks=self.callbacks)(model=self.model) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/torch/utils/_contextlib.py", line 115, in decorate_context return func(*args, **kwargs) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 308, in call f[3], _ = self.export_openvino() File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 142, in outer_func raise e File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 137, in outer_func f, model = inner_func(*args, **kwargs) File "/home/Kanishka/v5.0/YOLOV8_classification/.venv/lib/python3.8/site-packages/ultralytics/engine/exporter.py", line 454, in export_openvino LOGGER.info(f"\n{prefix} starting export with openvino {ov.version}...") AttributeError: module 'openvino' has no attribute 'version'

    1. Paula DerrengerUltralytics(modificato)

      @kanishkasw hi there,

      Thank you for reaching out and providing detailed information about the issue you're encountering. It looks like you're experiencing an error when attempting to export your model to OpenVINO format. Let's work through this together.

      First, let's ensure that you are using the latest versions of torch and ultralytics. Please run the following commands to update your packages:

      pip install --upgrade torch ultralytics

      Next, it seems the error is related to the OpenVINO package. The error message module 'openvino' has no attribute '__version__' suggests there might be an issue with the OpenVINO installation. Please make sure you have a recent version of OpenVINO installed (Ultralytics requires openvino>=2024.0.0). You can install it using the following command:

      pip install -U openvino

      Once you've updated the packages, try exporting the model again:

      yolo export model=runs/classify/train/weights/best.pt format=openvino

      If the issue persists, could you please provide a minimum reproducible example? This will help us investigate the problem more effectively. You can find guidance on creating a minimum reproducible example here: Minimum Reproducible Example.

      Additionally, here's a Python example to ensure everything is set up correctly:

      from ultralytics import YOLO
      
      # Load a YOLOv8n PyTorch model
      model = YOLO("runs/classify/train/weights/best.pt")
      
      # Export the model to OpenVINO format
      model.export(format="openvino")  # creates 'best_openvino_model/'
      
      # Load the exported OpenVINO model
      ov_model = YOLO("best_openvino_model/")
      
      # Run inference
      results = ov_model("https://ultralytics.com/images/bus.jpg")

      For more detailed instructions on using OpenVINO, please refer to our OpenVINO Integration Guide.

      Feel free to reach out if you have any further questions or run into any other issues. We're here to help! 😊

  5. renato-rodrigGitHub

    hello everything is fine? I have a question about the results exposed in the article above. Is the time shown in the graphs in relation to the inference time that the model takes to return the detections or is it the time for image reading, image pre-processing and model inference? I ask this because on my computer (intel core i7 12 generation CPU) the yolov8n model ran with an inference time of 40ms and the gain from using OpenVINO was not that great.

    1. Paula DerrengerUltralytics

      @renato-rodrig hello! 👋 Regarding your question about the times shown in the graphs, they typically refer to the total inference time, which includes the actual model inference as well as the time taken for pre-processing the input data (like image reading and resizing).

      The difference you observed with OpenVINO on your Intel Core i7 may vary due to several factors such as the specific configuration of your system, the type of tasks being run, and the optimizations that the YOLOv8n model can leverage on that platform. Generally, OpenVINO tends to show more significant performance gains on integrated Intel GPUs and some specific CPU configurations.

      If you haven't seen a major performance improvement, you might want to look into further tuning your OpenVINO deployment or explore using other optimization techniques provided by OpenVINO. Additionally, ensure all drivers and software components are up to date for optimal performance.

      Here’s a quick example of ensuring you're using the model in the most optimized manner:

      from ultralytics import YOLO
      
      # Load YOLOv8n PyTorch model
      model = YOLO('yolov8n.pt')
      
      # Export the model to OpenVINO
      model.export(format='openvino')  # Creates 'yolov8n_openvino_model/'
      
      # Load the exported OpenVINO model
      ov_model = YOLO('yolov8n_openvino_model/')
      
      # Run inference to see if performance improves
      results = ov_model('https://ultralytics.com/images/bus.jpg')

      Feel free to experiment with different configurations and settings! 😊

      1
  6. YouROS12GitHub

    I wanna do inferences with my exported pre-trained yolov8 model using Raspberry PI with a Neural Network Computing 2 (NCS2) plugged in.. but its doesn't support opset 11 or above.. only opset10.. I specified onnx opset to 10 and convert it to Openvino but it didn't work.

    Anyway please to export openvino model directly in opset10 ? Does even yolov8 support this specified opset format ?

    Thank you.

    1. Glenn JocherUltralytics(modificato)

      @YouROS12 the current OpenVINO export no longer goes through ONNX: Ultralytics converts the PyTorch model directly to OpenVINO IR with openvino.convert_model, so the ONNX opset argument does not apply and the old mo Model Optimizer step isn't needed. Export with:

      from ultralytics import YOLO
      
      # Load a pretrained YOLOv8 model
      model = YOLO('yolov8n.pt')
      
      # Export the model to OpenVINO
      model.export(format='openvino')  # creates 'yolov8n_openvino_model/'

      The export requires openvino>=2024.0.0. If your target requires an older OpenVINO that cannot load these models, you can still try model.export(format='onnx', opset=10) and convert the ONNX file with that toolkit's own tools, but some YOLOv8 operations may not be supported in older opsets, which could lead to errors during export or inference.

    2. YouROS12GitHub

      Where can I find documentation about YOLOv8's operations with opset 10 ? Updating OpenVINO toolkit is not an option because NCS2 works only at opset 10 and lower.

    3. Paula DerrengerUltralytics

      @YouROS12 the documentation for ONNX opset versions and the operations they support can be found on the ONNX GitHub repository or the official ONNX documentation. However, there isn't specific documentation for YOLOv8's operations with opset 10, as this would be a combination of YOLOv8's implementation details and ONNX's opset specifications.

      To check which operations are supported in opset 10, you can refer to the ONNX Operators documentation for that specific version. This documentation lists all the operators available in opset 10 and their details.

      For YOLOv8, you would need to look at the model's architecture and identify which operations are used. Then, cross-reference these operations with the ONNX opset 10 documentation to see if they are supported. If certain operations are not supported in opset 10, you might need to modify the model or the export script to use alternative operations that are compatible with opset 10.

      Since updating OpenVINO is not an option for you, if you find that YOLOv8 uses operations not supported in opset 10, you might need to consider using a different model architecture that is compatible with opset 10, or reach out to the community or Ultralytics for further assistance on how to proceed with your specific use case and hardware constraints.