Başla

Intel OpenVINO Dışa Aktarımı

OpenVINO, yapay zekâ çıkarımını optimize etmek ve çalıştırmak için Intel'in açık kaynaklı araç takımıdır. Bir Ultralytics YOLO26 modelini format="openvino" ile dışa aktarmak, Intel CPU'lar, tümleşik ve ayrık Intel GPU'lar ve Intel NPU'ları için FP32, FP16 veya INT8 hassasiyetinde OpenVINO IR modeli (.xml ve .bin dosyaları) içeren bir yolo26n_openvino_model/ dizini oluşturur.

Genel Bakış#

ÖzellikAyrıntılar
format bağımsız değişkeniopenvino
Çıktıyolo26n_openvino_model/; yolo26n.xml, yolo26n.bin ve metadata.yaml içeren bir dizin; quantize=8 dışa aktarımı için yolo26n_int8_openvino_model/
Çalıştığı ortamlarIntel CPU'lar, tümleşik ve ayrık Intel GPU'lar ve Intel NPU'ları. CPU aygıtı, AMD ve Apple silicon gibi diğer x86-64 ve ARM64 işlemcilerde de çalışır.
Çalışma zamanıOpenVINO Runtime 2024.0.0 veya daha yenisi (openvino Python paketi)
KesinlikFP32, FP16, INT8. YOLO26n, FP32'de 10,1 MB, FP16'da 5,3 MB ve INT8'de 3,3 MB'tır.
Dışa aktarma ana makinesiLinux, macOS veya Windows. Dışa aktarma CPU'da çalışır ve GPU gerektirmez.
Bulutta dışa aktar

Ultralytics Platform, eğitilmiş bir modeli senin için OpenVINO biçiminde dışa aktarabilir; böylece yerel bir dışa aktarma ortamına ihtiyacın olmaz.

Hızlı Başlangıç#

Ultralytics paketini OpenVINO dışa aktarma bağımlılıklarıyla birlikte yükle:

pip install "ultralytics[export-openvino]"

Bu işlem openvino paketini ve Python 3.9 veya daha yenisinde INT8 niceleme için nncf paketini yükler. Düz bir pip install ultralytics kullanıyorsan, ilk dışa aktarma eksik paketleri yükler. Dışa aktarma için aşağıdaki sürüm gereksinimleri geçerlidir:

PaketGerekli sürüm
torch2.1 veya daha yenisi
openvino2024.0.0 veya daha yenisi; macOS 15.4 ve sonraki sürümlerde 2025.2.0 veya daha yenisi
nncfYalnızca quantize=8 için 2.14.0 veya daha yenisi; PyTorch 2.3'ten eskiyse 3.0.0'dan eski

Diğer yükleme yöntemleri için yükleme kılavuzuna bak. Ardından modelini dışa aktar ve çıkarım yapmak veya doğruluğunu doğrulamak için dışa aktarılan dizini yükle. CPU'da OpenVINO kursu aynı adımları anlatıyor.

Dışa aktar
from ultralytics import YOLO

# YOLO26 modelini yükle
model = YOLO("yolo26n.pt")

# Modeli OpenVINO biçimine aktar
model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

# Kalibrasyon verileriyle INT8 nicelemeli bir OpenVINO modeli dışa aktar
model.export(format="openvino", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8_openvino_model/'
Tahmin
from ultralytics import YOLO

# Dışa aktarılan OpenVINO modelini yükle
model = YOLO("yolo26n_openvino_model/")

# Çıkarımı çalıştır
results = model("https://ultralytics.com/images/bus.jpg")

# Intel GPU'da çıkarım çalıştır; Intel NPU için "npu", CPU için "cpu" kullan
results = model("https://ultralytics.com/images/bus.jpg", device="xpu")
Doğrula
from ultralytics import YOLO

# Dışa aktarılan OpenVINO modelini yükle
model = YOLO("yolo26n_openvino_model/")

# COCO8 veri kümesinde doğruluğu doğrula
metrics = model.val(data="coco8.yaml")

Desteklenen Görevler#

OpenVINO ile dışa aktarma, YOLOv8, YOLO11 ve YOLO26 modellerinde yedi Ultralytics görevinin tümünü destekler: nesne algılama, segmentasyon, anlamsal segmentasyon, derinlik tahmini, sınıflandırma, poz tahmini ve OBB. Anlamsal segmentasyon ve derinlik tahmini yalnızca bu başlıklarla gelen tek aile olan YOLO26'da kullanılabilir.

Dışa Aktarma Bağımsız Değişkenleri#

Bağımsız değişkenTürVarsayılanAçıklama
formatstr'openvino'Dışa aktarılan modelin hedef biçimi; çeşitli dağıtım ortamlarıyla uyumluluğu tanımlar.
imgszint veya tuple640Model girdisinin görüntü boyutu: kare görüntüler için bir tam sayı veya (height, width) demeti. Belirtilmezse dışa aktarma, kontrol noktasının eğitildiği boyutu kullanır. Resmî YOLO26 kontrol noktalarında tespit, segmentasyon, poz ve ADE20K üzerinde önceden eğitilmiş anlamsal modeller için 640, OBB ve Cityscapes üzerinde önceden eğitilmiş anlamsal modeller için 1024, derinlik için 768 ve sınıflandırma için 224 kullanılır.
quantizeint veya strNoneNiceleme hassasiyeti: 16 (FP16: ağırlıklar yarı hassasiyette saklanır, girdiler ve çıktılar FP32 kalır) veya 8 (data içindeki kalibrasyon görüntüleriyle NNCF kullanılarak eğitim sonrası INT8 niceleme yapılır ve sonuçlar _int8_openvino_model/ dizinine yazılır); 32/ayarlanmamış değer FP32 anlamına gelir. quantize=8 ile eğitilmiş bir kontrol noktası OpenVINO'ya aktarılamaz; Sınırlamalar ve Sorun Giderme bölümüne bak. Bu seçenek, kullanımdan kaldırılmış half/int8 bayraklarının yerini alır.
datastrNoneINT8 kalibrasyonu için kullanılan veri kümesi YAML dosyası; sınıflandırmada bunun yerine bir veri kümesi dizini veya yerleşik veri kümesi adı kullanılır. split ayarlanmadığı sürece kalibrasyonda val bölümü kullanılır. quantize=8 ile birlikte verilmezse Ultralytics, algılama için coco8.yaml gibi, modelin görevine uygun küçük varsayılan veri kümesini kullanır.
fractionfloat, int veya list1.0Oran, görüntü sayısı veya [train, val, test] oranları/sayıları olarak kalibrasyon alt kümesi. İki öğeli listelerde test tam kalır; 0 ise onu atlar.
dynamicboolFalseGirdinin yığın boyutunu, yüksekliğini ve genişliğini dinamik yapar; böylece tek bir model farklı yığın boyutlarını ve görüntü boyutlarını kabul eder. Intel NPU'da dinamik bir model yine dışa aktarma sırasında belirlenen imgsz değerinde çalışır; Dağıtım bölümüne bak.
nmsbool, isteğe bağlıNoneHam çıktıyı (None, varsayılan), gömülü NMS'yi (True) veya NMS'siz başlığı (False) seçer. Çıktı biçimi bölümüne bak.
batchint1Dışa aktarılan modelin yığın boyutu. Statik dışa aktarmada bu yığın boyutu, girdi şeklinde sabitlenir. Ayrıca INT8 kalibrasyonu için kullanılan yığın boyutudur.
devicestrNoneDışa aktarma her zaman CPU'da çalışır. quantize=8 ile device=npu, YOLO algılama, segmentasyon, poz ve OBB modellerinde simetrik INT8 aktivasyonlarını seçer; bu modeller Intel NPU'larda 2 kata kadar daha hızlı çalışır.

Tüm biçimlerde ortak olan bağımsız değişkenler için Dışa aktarma modu belgelerine bak.

INT8 Kuantizasyonu#

quantize=8, NNCF ile eğitim sonrası niceleme uygular: dışa aktarma işlemi kalibrasyon görüntülerini modelden geçirir ve mümkün olan yerlerde ağırlıkları ve aktivasyonları 8 bitlik tamsayılar olarak saklar.

  • Kalibrasyon verileri: dışa aktarma, data içindeki val bölümünün veya split ile ayarladığın bölümün her tam yığını üzerinde kalibrasyon yapar. Görüntü sayısını sınırlamak için fraction kullan. Dışa aktarma işlemi 300'den az görüntü varsa uyarı verir.
  • Algılama başlığı: YOLO algılama başlığına sahip modellerde (algılama, segmentasyon, poz ve OBB) ve RT-DETR modellerinde, başlık çıktılarını çözen işlemler (yeniden şekillendirme, birleştirme, kutu çözümleme ve DFL) ile tüm sigmoid işlemleri kayan noktalı olarak kalırken başlığın evrişimleri nicelemeye tabi tutulur. Sınıflandırma, anlamsal segmentasyon ve derinlik modellerinde hariç tutulan işlem yoktur.
  • Girdiler ve çıktılar: INT8 model, FP32 modelin float32 girdisini ve çıktılarını korur; bu nedenle FP32 model için yazılmış çıkarım kodu, modelde hiçbir değişiklik yapmadan çalışır.
  • Intel NPU: Intel NPU'da çalıştırmayı planladığın bir INT8 dışa aktarımına device=npu ekle. Bu, YOLO algılama, segmentasyon, poz ve OBB modellerini asimetrik aktivasyon nicelemesinden simetrik nicelemeye geçirir.
Örnek
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# COCO doğrulama görüntülerinin %10'u (500 görüntü) üzerinde kalibrasyon yap; coco.yaml dosyasını kendi veri kümenle değiştir
model.export(format="openvino", quantize=8, data="coco.yaml", fraction=0.1)

# Dışa aktarılan INT8 modelini yükle ve çıkarımı çalıştır
model = YOLO("yolo26n_int8_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg")

Karşılaştırma sonuçlarında INT8 modelleri sunucu CPU'sunda FP32'den 1,02 ila 1,33 kat daha hızlı çalıştı ve COCO val2017'de 0,5 ila 0,9 mAP kaybetti. Intel Core Ultra CPU'larda INT8, FP32'den 1,2 ila 3,8 kat daha hızlı çalıştı. Dağıtıma almadan önce INT8 modelini kendi verilerinle doğrula.

Çıktı Biçimi#

Dışa aktarma işlemi üç dosya içeren tek bir dizin yazar:

Dosyaİçindekiler
yolo26n.xmlOpenVINO IR biçimindeki ağ grafiği
yolo26n.binAğırlıklar
metadata.yamlUltralytics'in modeli yüklerken okuduğu sınıf adları, görev, görüntü boyutu, yığın boyutu, stride ve dışa aktarma bağımsız değişkenleri

Model, (batch, 3, height, width) şeklinde tek bir girdi alır; girdi RGB'dir ve 0-1 aralığına ölçeklenir. Anlamsal segmentasyon çıktısı hariç, FP32, FP16 ve INT8 modellerinde girdi ve çıktılar float32 biçimindedir. Anlamsal segmentasyon çıktısı ise uint8 sınıf haritasıdır (256'dan fazla sınıfa sahip modellerde int32). Tensörler, ONNX dışa aktarımındaki images ve output0 adlarını taşımaz; bu nedenle kendi kodunda girdi ve çıktılara dizin numaralarıyla eriş.

Çıktı şekilleri ONNX dışa aktarımındakiyle aynıdır ve göreve ve nms bağımsız değişkenine bağlıdır: imgsz=640 ile dışa aktarılan bir YOLO26n algılama modeli, varsayılan nms=None ile (1, 84, 8400) ve nms=False veya nms=True ile (1, 300, 6) döndürür. Her görevin şekilleri ve içerikleri için ONNX çıktı biçimi bölümüne bak. nms=True ile güven eşiği conf (varsayılan 0.25), IoU eşiği iou, agnostic_nms ve max_det dışa aktarma sırasında grafikte sabitlenir. Tahmin veya doğrulama sırasında daha düşük bir conf değeri, grafiğin zaten kaldırdığı algılamaları geri getiremez; bu değerleri değiştirmek için modeli yeniden dışa aktar.

Dağıt#

YOLO("yolo26n_openvino_model/"), modeli OpenVINO Runtime ile çalıştırır ve device bağımsız değişkenini bir OpenVINO aygıtına eşler:

deviceOpenVINO aygıtı
belirtilmemişAUTO; OpenVINO'nun CPU ile Intel GPU'lar arasında seçim yapmasını sağlar (varsayılan öncelik listesi NPU'yu içermez) veya OpenVINO'nun bulduğu tek aygıt CPU olduğunda CPU kullanılır.
cpuCPU
xpu veya xpu:0GPU veya GPU.0, tümleşik ya da ayrık Intel GPU. İki Intel GPU bulunan bir makinede xpu:1, GPU.1 seçer.
npuNPU, Intel Core Ultra işlemcilerindeki sinirsel işlem birimi

0 veya mps gibi diğer değerler, ayarlanmamış bir device gibi ele alınır. Eski intel:cpu, intel:gpu ve intel:npu adları çalışmaya devam eder ve kullanımdan kaldırma uyarısı verir. Çıkarım aygıtları tablosu, bu adları biçimler arasında karşılaştırır. Using OpenVINO LATENCY mode for batch=1 inference on CPU... günlük satırı, model yüklenirken OpenVINO'nun bildirdiği aygıtı belirtir. AUTO kullanıldığında bu CPU olabilir; Intel GPU ise modeli derlemeye devam ediyor olabilir. Bu nedenle aygıttan emin olmak için device ayarla. .pt modeli için device="xpu", bunun yerine PyTorch Intel GPU arka ucunu seçer; bu arka uç Intel GPU'larda eğitim için de kullanılır. device="npu" ise Intel NPU'yu değil, Huawei Ascend NPU'yu seçer.

Çıkarım sırasındaki davranış, modelin nasıl dışa aktarıldığına bağlıdır:

  • Statik dışa aktarma (varsayılan): model her zaman dışa aktarma sırasında belirlenen imgsz ve batch değerleriyle çalışır; Ultralytics bu değerleri metadata.yaml dosyasından okur. predict öğesine geçirilen imgsz yok sayılır. Daha büyük yığınlar, dışa aktarma yığın boyutundaki parçalara bölünür; daha küçük yığınlar ise dolguyla tamamlanır. Böylece her sayıda görüntü işlenebilir.
  • Dinamik dışa aktarma (dynamic=True): predict farklı yığın boyutlarını ve model stride'ının katı olan her imgsz değerini kabul eder. Intel NPU'lar ve Intel AMX CPU'larda çalışan INT8 modelleri istisnadır; Sınırlamalar ve Sorun Giderme bölümüne bak.
  • Gecikme modu: Ultralytics, modeli OpenVINO LATENCY performans ipucuyla derler ve çıkarımı eşzamanlı çalıştırır. THROUGHPUT ipucuyla çok sayıda paralel isteği sunmak için gecikme ve aktarım hızı kılavuzunda gösterildiği gibi OpenVINO Runtime API'sini kullan.
  • Intel NPU: Ultralytics, modeli NPU'da yığın boyutu 1 olacak şekilde derler ve daha büyük yığınları tek görüntülük parçalara böler. NPU'da dinamik dışa aktarma, dışa aktarma sırasında belirlenen imgsz değerine sabitlenir.

OpenVINO Runtime API'siyle çalıştır#

Modeli Ultralytics paketi dışında çalıştırmak için .xml dosyasını openvino paketiyle yükle. Model, ön işlenmiş bir görüntü bekler ve Çıktı Biçimi bölümünde açıklanan ham çıktıları döndürür. Bu nedenle harf kutusuna sığdırma ve varsayılan dışa aktarmada NMS işlemleri senin koduna kalır:

# Önce dışa aktar: 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")  # veya "CPU", "GPU", "NPU"

image = np.zeros((1, 3, 640, 640), dtype=np.float32)  # ön işlenmiş görüntün: RGB, NCHW, 0-1
detections = compiled(image)[0][0]  # ilk çıktı, ilk görüntü: şekil (300, 6)
detections = detections[detections[:, 4] > 0.25]  # güven eşiğinin üzerindeki satırları tut

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

Dağıtım Kılavuzları#

Sınırlamalar ve Sorun Giderme#

  • PyTorch sürümü: Eski PyTorch sürümlerinde dışa aktarma OpenVINO export requires torch>=2.1 ile başarısız olur.
  • macOS 15.4 ve sonrası: OpenVINO 2025.1.0 ve daha eski sürümler bu macOS sürümlerinde başarısız olur. Bu nedenle dışa aktarma burada openvino>=2025.2.0 gerektirir ve daha eski bir paketi günceller.
  • quantize=8 ile eğitilmiş kontrol noktaları: niceleme farkındalıklı eğitim ile ince ayar yapılmış bir kontrol noktası, format='openvino' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends ile başarısız olur. Bunun yerine ince ayara başladığın kontrol noktasını quantize=8 ile dışa aktar veya ince ayarlı kontrol noktasını ONNX ya da TensorRT biçiminde dışa aktar.
  • data olmadan INT8 dışa aktarma: dışa aktarma işlemi INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. günlüğünü yazar ve görev için küçük varsayılan veri kümesiyle kalibrasyon yapar. Dağıtım verilerini temsil eden görüntüler içeren data değerini ilet.
  • INT8 kalibrasyon boyutu: kalibrasyon bölümünde 300'den az görüntü olduğunda dışa aktarma işlemi >300 images recommended for INT8 calibration, found 4 images. günlüğünü yazar. coco8.yaml yalnızca 4 doğrulama görüntüsü içerir. Bu sayı dışa aktarmayı test etmek için yeterlidir ancak dağıtıma yönelik bir modeli kalibre etmek için yeterli değildir.
  • Çıktı dizini: INT8 dışındaki tek bir kontrol noktasının her dışa aktarımı, quantize, imgsz, dynamic, nms veya batch değeri ne olursa olsun aynı yolo26n_openvino_model/ dizinine yazar; bu nedenle sonraki dışa aktarma öncekinin üzerine yazar. device=npu olsun ya da olmasın tüm INT8 dışa aktarımları yolo26n_int8_openvino_model/ dizinini paylaşır.
  • Aygıt kullanılamıyor: İstenen aygıt yoksa Ultralytics OpenVINO device 'GPU' not available. Using 'AUTO' instead. günlüğünü yazar (OpenVINO'nun yalnızca CPU'yu bulduğu makinelerde Using 'CPU' instead.) ve o aygıtta çalışmaya devam eder. İşlemcinin OpenVINO tarafından desteklendiğini doğrula ve Intel GPU veya NPU sürücüsünü yükle.
  • Intel NPU: Ultralytics, NPU'yu sabit girdi şekilleriyle ve yığın boyutu 1 olacak şekilde çalıştırır; Dağıtım bölümüne bak. NPU'yu kullanmak için device=npu değerini ilet: ayarlanmamış bir device, NPU'yu seçmez.
  • NMS içeren dinamik şekiller: dynamic=True ve nms=True ile yapılan dışa aktarma, batch değeri 1 olarak bırakıldığında 'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'. günlüğünü yazar. Ultralytics daha büyük yığınları, dışa aktarma sırasındaki batch boyutundaki parçalara böler.
  • Intel AMX CPU'larda dinamik INT8 modeller: Linux'ta AMX destekli bir CPU'da (Intel Sapphire Rapids ve daha yenisi), Ultralytics dinamik INT8 modelini CPU veya AUTO aygıtında, statik modelde olduğu gibi dışa aktarma sırasındaki imgsz değerinde çalıştırır. predict veya val öğesine geçirilen bir imgsz yok sayılır ve val, dışa aktarma sırasındaki batch değerini kullanır. predict yine de diğer yığın boyutlarını kabul eder ve her yeni yığın boyutu için modeli yeniden derler; bu nedenle yeni yığın boyutundaki ilk çıkarım daha yavaştır.
  • Windows: Windows'ta Ultralytics, CPU çıkarım hassasiyeti ipucunu FP32 olarak ayarlar. Böylece OpenVINO'nun daha düşük hassasiyetli kayan nokta çekirdeklerini kullanması engellenir (INT8 modeller yine INT8 olarak çalışır) ve oneDNN, AMX'ten eski komut kümeleriyle sınırlandırılır. Farklı bir sınır kullanmak için modeli yüklemeden önce ONEDNN_MAX_CPU_ISA ortam değişkenini ayarla.
  • ARM64 üzerinde Linux: Ultralytics, CPU aygıtını OpenVINO'nun doğruluk yürütme modunda, FP32 çıkarım hassasiyetiyle çalıştırır.
  • Gömülü NMS: nms=True, sınıflandırmada 'nms=True' is not valid for classification models. hatasına yol açar; anlamsal segmentasyon ve derinlik tahmini modellerinde ('nms=True' is not valid for semantic models. Forcing 'nms=None'.) ve RT-DETR modellerinde ('nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.) ise uyarı verilip yok sayılır.
  • NMS'siz başlık: nms=False, YOLO26 veya YOLOv10 gibi NMS'siz başlığı olan bir model gerektirir. Örneğin YOLO11 gibi diğer modellerde dışa aktarma This model has no one-to-one head; using one-to-many outputs. uyarısı verir ve ham (1, 84, 8400) çıktısını yazar.

Diğer hatalar için Yaygın Sorunlar kılavuzuna bak.

OpenVINO YOLO26 Karşılaştırma Testleri#

Aşağıdaki tablolar, her YOLO26 algılama modelinin PyTorch ve FP32, FP16 ve INT8 OpenVINO modellerini karşılaştırır. İlk grup, COCO val2017 doğruluğuyla bir sunucu CPU'sunda; ikinci grup ise üç Intel Core Ultra işlemcide, bunların CPU ve GPU'larında ve ikisinin NPU'larında ölçüldü. YOLO26 model sayfasında her modelin doğruluğu, CPU ONNX hızı ve T4 TensorRT hızı listeleniyor.

Sunucu CPU'sunda FP32, FP16 ve INT8#

Bu bölümdeki tüm değerler Intel CPU'da değil, iki AMD EPYC 9655 96 çekirdekli işlemciye sahip bir sunucunun CPU'sunda ölçüldü. PyTorch 8 iş parçacığında, OpenVINO ise Ultralytics ve OpenVINO'nun bu sunucuda varsayılan olarak seçtiği 96 iş parçacığında çalıştı. Dolayısıyla PyTorch ve OpenVINO sütunları çalışma ortamının yanı sıra iş parçacığı sayısı bakımından da farklıdır. PyTorch ayrıca dikdörtgen çıkarımla doğrulama yaptı; her görüntü en-boy oranına uygun bir dikdörtgene (480x640 görüntü için 512x672) tamamlandı. Statik OpenVINO modelleri ise her zaman 640x640 boyutunda çalıştı.

Görüntü başına milisaniye; düşük değer daha iyidir. Her model için en hızlı biçim kalın yazılmıştır.

ModelimgszPyTorchOpenVINO 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

Aynı 8 CPU'da YOLO26n (PyTorch ve OpenVINO, taskset ile bu sunucunun 0-7 numaralı CPU'larına sabitlendi):

ÖlçütPyTorchOpenVINO FP32OpenVINO FP16OpenVINO INT8
Gecikme (ms/görüntü)9.287.137.146.71
mAPval 50-9540.840.940.940.3
  • OpenVINO FP32, yukarıdaki varsayılan iş parçacığı sayılarıyla PyTorch'tan 3,9 ila 6,7 kat daha hızlı çalıştı ve 0,1 mAP içinde aynı doğruluğu sağladı. Her ikisi de aynı 8 CPU'ya sabitlendiğinde (bu düzende PyTorch'un kendisi varsayılan yapılandırmadan daha hızlı çalışıyordu) OpenVINO FP32, YOLO26n'i PyTorch'tan 1,3 kat daha hızlı; INT8 ise FP32'den 1,06 kat daha hızlı çalıştırdı.
  • FP16, model boyutunu yarıya indirdi ve FP32'ye kıyasla doğruluk farkını 0,1 mAP içinde tuttu; gecikme ise FP32 düzeyindeydi (%3 fark içinde).
  • INT8, FP32'den 1,02 ila 1,33 kat daha hızlı çalıştı, model boyutunu 3,1 ila 3,9 kat küçülttü ve 0,5 ila 0,9 mAP kaybetti.

Ölçümler 14 Kasım 2026'da batch=1 üzerinde ultralytics 8.4.212, OpenVINO 2026.4.1, NNCF 3.4.0 ve PyTorch 2.15.0 kullanılarak yapıldı. Gecikme, val tarafından bildirilen çıkarım aşamasını ifade eder; ön işleme ve son işlemeyi kapsamaz. PyTorch, FP32 ve FP16 değerleri üç çalıştırmanın ortalamasıdır. Çalıştırmalar arasında PyTorch'ta %26'ya, OpenVINO'da %6'ya varan farklar görüldü. INT8 modeller 591 COCO train2017 görüntüsüyle (split=train fraction=0.005) kalibre edildi ve üç kez derlendi; INT8 değerleri bu üç derlemenin ortalamasıdır. 8 CPU tablosunda tek bir INT8 derlemesi üç kez çalıştırıldı.

Intel Core Ultra CPU, GPU ve NPU#

Bu tablolar, üç Intel Core Ultra işlemcide kıyaslama modunda openvino 2026.2.1 ile ölçüldü: model.benchmark(data="coco128.yaml", format="openvino", device=...); device, cpu, xpu veya npu olarak ayarlandı. Doğruluk, 128 görüntülü COCO128 veri kümesinde mAP50-95 değeridir; bu nedenle yukarıdaki COCO val2017 değerleriyle karşılaştırılamaz. PyTorch aynı işlemcinin CPU'sunda çalıştı. YOLO26 modelleri yalnızca Intel Core Ultra 2xxV serisi, 3xx serisi ve daha yeni işlemcilerin NPU'larında çalışır.

Intel Core Ultra X7 358H#

Intel Core Ultra X7 358H (Panther Lake), CPU çekirdeklerini, tümleşik Intel Arc GPU'yu ve Intel AI Boost NPU'yu bir araya getirir.

Görüntü başına milisaniye; düşük değer daha iyidir. Her model için en hızlı sütun kalın yazılmıştır.

ModelPyTorch CPUCPU 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

Önceki Intel Core Ultra işlemciler#

Intel Core Ultra 7 258V (Lunar Lake)

Görüntü başına milisaniye; düşük değer daha iyidir. Her model için en hızlı sütun kalın yazılmıştır.

ModelPyTorch CPUCPU 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)

Görüntü başına milisaniye; düşük değer daha iyidir. Her model için en hızlı sütun kalın yazılmıştır.

ModelPyTorch CPUCPU 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

Üç işlemcide de:

  • CPU: INT8, FP32'den 1,2 ila 3,8 kat ve PyTorch'tan 2,9 ila 6,0 kat daha hızlı çalıştı. FP32, X7 358H ve 155H'de PyTorch'tan 1,6 ila 2,5 kat daha hızlı çalışırken 258V'de YOLO26m, YOLO26l ve YOLO26x için PyTorch'tan daha yavaştı.
  • GPU: tümleşik GPU, FP32 modellerini CPU'daki PyTorch'tan 3,6 ila 29,1 kat daha hızlı çalıştırdı. X7 358H ve 258V'de YOLO26n dışındaki tüm modellerde INT8, FP32'den 2,3 kata kadar daha hızlıydı.
  • NPU (X7 358H ve 258V): FP32 modelleri, CPU'daki PyTorch'tan 1,2 ila 16,2 kat daha hızlı çalıştı; INT8 ise FP32 hızının 0,88 ila 1,19 katında çalıştı. Bu INT8 modelleri, device=npu simetrik aktivasyonları seçmeden önce dışa aktarıldığından tablolar NPU için optimize edilmiş INT8 dışa aktarımını göstermiyor.
  • FP16 gecikmesi her aygıtta FP32'nin %5'i dahilindeydi ve INT8, mAP50-95'te 0,1 ila 2,7 puan kayba yol açtı.

OpenVINO hakkında#

OpenVINO, Open Visual Inference and Neural Network Optimization ifadesinin kısaltmasıdır. PyTorch gibi çerçevelerdeki modelleri kendi IR biçimine dönüştürür ve Intel CPU, GPU ve NPU'larda tek bir API üzerinden çalıştırır. Eksiksiz başvuru kaynağı için OpenVINO belgelerine bak.

OpenVINO Intel AI inference toolkit



İzle: Daha hızlı çıkarım için Ultralytics YOLO26'yı Intel OpenVINO biçimine aktarma 🚀

Sık Sorulan Sorular#

  • Evet, CPU'da çalışır. OpenVINO CPU aygıtı x86-64 ve ARM64 işlemcilerde çalışır: bu sayfadaki sunucu CPU kıyaslamaları AMD EPYC işlemcilerde ölçüldü ve aynı dışa aktarım Apple silicon'da da çalışır. GPU ve NPU aygıtları Intel donanımı gerektirir; bu nedenle device=xpu ve device=npu diğer makinelerde bir uyarıyla geri dönüş yapar. Diğer hedefler için model dağıtım seçenekleri kılavuzuna bak.

  • Bu, aygıta bağlıdır. FP16 (quantize=16) kalibrasyon verisi gerektirmez, model boyutunu yarıya indirir ve kıyaslamalarda FP32 doğruluğunu ve gecikmesini korudu; bu nedenle model boyutu önemliyse FP16 kullan. INT8 (quantize=8) çoğu model için en düşük CPU gecikmesini sağladı: sunucu CPU'sunda YOLO26s gecikmesini görüntü başına 5,18 ms'den 4,51 ms'ye düşürürken, FP32'deki 48,5 değerine karşılık 47,6 mAPval 50-95 elde etti ve Intel Core Ultra CPU'larda FP32'den 1,2 ila 3,8 kat daha hızlı çalıştı. Tümleşik Intel GPU'larda INT8 kazanımı daha düşüktü (2,3 kata kadar); NPU'larda ise bu çalışmalardaki INT8 modelleri, device=npu olmadan dışa aktarıldığından FP32 kadar hızlıydı. INT8, temsili kalibrasyon verisi gerektirir; bu nedenle seçim yapmadan önce INT8 modelini kendi verilerinle doğrula.

  • dynamic=True ile dışa aktar ve tahmin sırasında ihtiyacın olan toplu iş boyutunu ve imgsz değerini belirt. Görüntü boyutu, model adım boyutunun katı olmalıdır; sınıflandırma dışındaki resmî YOLO26 kontrol noktalarında bu değer 32'dir. İstisnalar için Dağıtım bölümüne bak.

    Dinamik dışa aktarma
    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)  # 320 piksel boyutunda 4 görüntülük bir toplu işlem
  • Dağıtım donanımı Intel ise OpenVINO kullan: device=xpu ve device=npu Intel GPU ve NPU'yu seçer; Intel Core Ultra CPU'larda INT8 OpenVINO modelleri kıyaslamalarda FP32'den 1,2 ila 3,8 kat daha hızlı çalıştı. Aynı dosyanın NVIDIA veya AMD GPU'larda ya da OpenVINO dışındaki çalışma zamanlarında da çalışması gerekiyorsa ONNX kullan; Windows'ta Windows ML, ONNX modeli için Intel donanımını seçebilir.

Yorumlar23

Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.

  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(düzenlendi)

      @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(düzenlendi)

      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(düzenlendi)

      @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(düzenlendi)

      @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(düzenlendi)

      @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.