Экспорт в Intel OpenVINO
OpenVINO — это набор инструментов Intel с открытым исходным кодом для оптимизации и выполнения инференса ИИ-моделей. Экспорт модели Ultralytics YOLO26 с помощью format="openvino" создает каталог yolo26n_openvino_model/, содержащий модель OpenVINO IR (файлы .xml и .bin) для процессоров Intel, встроенных и дискретных графических процессоров Intel и NPU Intel с точностью FP32, FP16 или INT8.
Краткий обзор#
| Свойство | Описание |
|---|---|
Аргумент format | openvino |
| Результат | yolo26n_openvino_model/ — каталог с yolo26n.xml, yolo26n.bin и metadata.yaml; yolo26n_int8_openvino_model/ для экспорта quantize=8 |
| Поддерживаемые устройства | Процессоры Intel, встроенные и дискретные графические процессоры Intel и NPU Intel. Устройство CPU также работает на других процессорах x86-64 и ARM64, например AMD и Apple silicon |
| Среда выполнения | OpenVINO Runtime версии 2024.0.0 или новее (пакет Python openvino) |
| Точность | FP32, FP16, INT8. Размер YOLO26n составляет 10,1 МБ в FP32, 5,3 МБ в FP16 и 3,3 МБ в INT8 |
| Среда для экспорта | Linux, macOS или Windows. Экспорт выполняется на CPU и не требует GPU |
Платформа Ultralytics может экспортировать обученную модель в OpenVINO за тебя, поэтому локальная среда для экспорта не нужна.
Быстрый старт#
Установи пакет Ultralytics с зависимостями для экспорта в OpenVINO:
pip install "ultralytics[export-openvino]"Устанавливаются openvino и, для Python 3.9 или новее, nncf для квантования INT8. При обычной установке pip install ultralytics недостающие пакеты устанавливаются при первом экспорте. Для экспорта требуются следующие версии:
| Пакет | Требуемая версия |
|---|---|
torch | 2.1 или новее |
openvino | 2024.0.0 или новее; 2025.2.0 или новее для macOS 15.4 и новее |
nncf | 2.14.0 или новее только для quantize=8; ниже 3.0.0 при PyTorch ниже 2.3 |
О других способах установки смотри в руководстве по установке. Затем экспортируй модель и загрузи экспортированный каталог, чтобы выполнить инференс или проверить точность. Те же действия описаны в курсе по OpenVINO на CPU.
from ultralytics import YOLO
# Загрузи модель YOLO26
model = YOLO("yolo26n.pt")
# Экспортировать модель в формат OpenVINO
model.export(format="openvino") # creates 'yolo26n_openvino_model/'
# Экспортировать квантованную до INT8 модель OpenVINO с калибровочными данными
model.export(format="openvino", quantize=8, data="coco8.yaml") # creates 'yolo26n_int8_openvino_model/'from ultralytics import YOLO
# Загрузи экспортированную модель OpenVINO
model = YOLO("yolo26n_openvino_model/")
# Выполнить инференс
results = model("https://ultralytics.com/images/bus.jpg")
# Выполнить инференс на GPU Intel; для NPU Intel укажи "npu", а для CPU — "cpu"
results = model("https://ultralytics.com/images/bus.jpg", device="xpu")from ultralytics import YOLO
# Загрузи экспортированную модель OpenVINO
model = YOLO("yolo26n_openvino_model/")
# Проверить точность на наборе данных COCO8
metrics = model.val(data="coco8.yaml")Поддерживаемые задачи#
Экспорт OpenVINO поддерживает все семь задач Ultralytics с моделями YOLOv8, YOLO11 и YOLO26: обнаружение объектов, сегментацию, семантическую сегментацию, оценку глубины, классификацию, оценку позы и OBB. Семантическая сегментация и оценка глубины доступны только в YOLO26 — единственном семействе, в котором есть соответствующие головы.
Аргументы экспорта#
| Аргумент | Тип | По умолчанию | Описание |
|---|---|---|---|
format | str | 'openvino' | Целевой формат экспортируемой модели, определяющий совместимость с различными средами развертывания. |
imgsz | int или tuple | 640 | Размер входного изображения модели: целое число для квадратных изображений или кортеж (height, width). Если значение не задано, при экспорте используется размер, на котором обучалась модель из чекпойнта. В официальных чекпойнтах YOLO26 используется 640 для моделей обнаружения объектов, сегментации, оценки позы и семантических моделей, предобученных на ADE20K; 1024 для OBB и семантических моделей, предобученных на Cityscapes; 768 для оценки глубины и 224 для классификации. |
quantize | int или str | None | Точность квантования: 16 (FP16: веса хранятся с половинной точностью, входы и выходы остаются в FP32) или 8 (посттренировочное квантование INT8 с NNCF и калибровочными изображениями из data, результат записывается в каталог _int8_openvino_model/); 32/не задано означает FP32. Контрольную точку, обученную с quantize=8, нельзя экспортировать в OpenVINO; см. раздел Ограничения и устранение неполадок. Заменяет устаревшие флаги half/int8. |
data | str | None | YAML-файл датасета для калибровки INT8; для классификации вместо него укажи каталог датасета или встроенное название датасета. Для калибровки используется раздел val, если не задан split. Если quantize=8 не указан, Ultralytics использует небольшой датасет по умолчанию для задачи модели, например coco8.yaml для обнаружения объектов. |
fraction | float, int или list | 1.0 | Подмножество для калибровки, заданное как доля, количество изображений или [train, val, test] отношения/количества. Если список содержит два элемента, test остаётся без изменений, а 0 пропускает его. |
dynamic | bool | False | Делает размер пакета, высоту и ширину входных данных динамическими, позволяя одной модели принимать разные размеры пакета и изображений. На NPU Intel динамическая модель по-прежнему работает с размером imgsz, заданным при экспорте; см. раздел Развертывание. |
nms | bool, необязательно | None | Выбирает исходный вывод (None, по умолчанию), встроенный NMS (True) или голову без NMS (False). См. формат вывода. |
batch | int | 1 | Размер пакета экспортированной модели. При статическом экспорте этот размер фиксируется во входной форме. Также используется как размер пакета для калибровки INT8. |
device | str | None | Экспорт всегда выполняется на CPU. При quantize=8 параметр device=npu включает симметричное квантование активаций INT8 для моделей YOLO detect, segment, pose и OBB, которые работают на NPU Intel до 2 раз быстрее. |
Аргументы, общие для всех форматов, описаны в документации по режиму экспорта.
Квантование INT8#
quantize=8 выполняет посттренировочное квантование с помощью NNCF: при экспорте калибровочные изображения пропускаются через модель, а веса и активации, где это возможно, сохраняются как 8-битные целые числа.
- Калибровочные данные: экспорт использует для калибровки каждый полный пакет из раздела
valдатасетаdataлибо из раздела, заданного параметромsplit. Используйfraction, чтобы ограничить число изображений. Если изображений меньше 300, экспорт выведет предупреждение. - Голова обнаружения: в моделях с головой обнаружения YOLO (detect, segment, pose и OBB), а также в RT-DETR, операции декодирования выходов головы (изменение формы, конкатенация, декодирование рамок и DFL) и все операции sigmoid остаются с плавающей точкой, а свертки головы квантуются. В моделях классификации, семантической сегментации и оценки глубины исключаемых операций нет.
- Входы и выходы: у модели INT8 остаются те же вход
float32и выходы, что у модели FP32, поэтому код инференса, написанный для модели FP32, будет работать без изменений. - NPU Intel: добавь
device=npuк экспорту INT8, который планируешь запускать на NPU Intel. Это переключает модели YOLO detect, segment, pose и OBB с асимметричного на симметричное квантование активаций.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
# Выполнить калибровку на 10% валидационных изображений COCO (500 изображений); замени coco.yaml на собственный датасет
model.export(format="openvino", quantize=8, data="coco.yaml", fraction=0.1)
# Загрузить экспортированную модель INT8 и выполнить инференс
model = YOLO("yolo26n_int8_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg")В результатах тестов модели INT8 работали на серверном CPU в 1,02–1,33 раза быстрее FP32 и теряли 0,5–0,9 mAP на COCO val2017. На процессорах Intel Core Ultra INT8 работал в 1,2–3,8 раза быстрее FP32. Перед развертыванием проверь модель INT8 на собственных данных.
Формат вывода#
При экспорте создается один каталог с тремя файлами:
| Файл | Содержимое |
|---|---|
yolo26n.xml | Граф сети в формате OpenVINO IR |
yolo26n.bin | Веса |
metadata.yaml | Названия классов, задача, размер изображения, размер пакета, шаг и аргументы экспорта, которые Ultralytics считывает при загрузке модели |
Модель принимает один вход с формой (batch, 3, height, width), в формате RGB и с масштабированием до диапазона 0–1. Вход и выходы имеют тип float32 в моделях FP32, FP16 и INT8, за исключением выхода семантической сегментации — карты классов uint8 (int32 для моделей с более чем 256 классами). Тензоры не содержат имен images и output0 из экспорта ONNX, поэтому в собственном коде обращайся к входу и выходам по индексу.
Формы выходов совпадают с формами при экспорте ONNX и зависят от задачи и аргумента nms: модель обнаружения YOLO26n, экспортированная с imgsz=640, возвращает (1, 84, 8400) со значениями по умолчанию nms=None и (1, 300, 6) при nms=False или nms=True. Формы и содержимое выходов для каждой задачи см. в разделе Формат выходных данных ONNX. При nms=True порог уверенности conf (по умолчанию 0.25), порог IoU iou, agnostic_nms и max_det фиксируются в графе при экспорте. Если при предсказании или валидации задать меньший conf, это не вернет обнаружения, уже удаленные графом, поэтому для изменения этих значений выполни экспорт заново.
Разверни#
YOLO("yolo26n_openvino_model/") запускает модель с OpenVINO Runtime и сопоставляет аргумент device с устройством OpenVINO:
device | Устройство OpenVINO |
|---|---|
| не задано | AUTO позволяет OpenVINO выбирать между CPU и GPU Intel (список приоритетов по умолчанию не включает NPU); либо укажи CPU, если CPU — единственное устройство, найденное OpenVINO |
cpu | CPU |
xpu или xpu:0 | GPU или GPU.0 — встроенный или дискретный графический процессор Intel. xpu:1 выбирает GPU.1 на компьютере с двумя графическими процессорами Intel |
npu | NPU — нейронный процессор в составе процессоров Intel Core Ultra |
Другие значения, например 0 или mps, обрабатываются так же, как незаданный device. Старые названия intel:cpu, intel:gpu и intel:npu по-прежнему работают и выводят предупреждение об устаревании. Сравнение этих названий для разных форматов см. в таблице устройств инференса. Строка журнала Using OpenVINO LATENCY mode for batch=1 inference on CPU... указывает устройство, которое OpenVINO сообщает при загрузке модели. При AUTO это может быть CPU, пока GPU Intel еще компилирует модель, поэтому для уверенности задай device. Для модели .pt параметр device="xpu" вместо этого выбирает бэкенд PyTorch для GPU Intel — он также используется для обучения на GPU Intel, а device="npu" выбирает NPU Huawei Ascend, а не NPU Intel.
Поведение во время инференса зависит от способа экспорта модели:
- Статический экспорт (по умолчанию): модель всегда работает с размером
imgszиbatch, заданными при экспорте и считанными Ultralytics изmetadata.yaml. Параметрimgsz, переданный вpredict, игнорируется. Большие пакеты разбиваются на части размером с пакет экспорта, а меньшие дополняются, поэтому можно обрабатывать любое число изображений. - Динамический экспорт (
dynamic=True):predictпринимает пакеты разных размеров и любоеimgsz, кратное шагу модели. Исключения — NPU Intel и модели INT8 на CPU Intel AMX; см. раздел Ограничения и устранение неполадок. - Режим минимальной задержки: Ultralytics компилирует модель с подсказкой производительности OpenVINO
LATENCYи выполняет инференс синхронно. Чтобы обрабатывать множество параллельных запросов с подсказкойTHROUGHPUT, используй API OpenVINO Runtime, как описано в руководстве по задержке и пропускной способности. - NPU Intel: Ultralytics компилирует модель для размера пакета 1 на NPU и разбивает большие пакеты на отдельные изображения. На NPU динамический экспорт фиксируется на значении
imgsz, заданном при экспорте.
Запуск с API OpenVINO Runtime#
Чтобы запускать модель вне пакета Ultralytics, загрузи файл .xml с помощью пакета openvino. Модель ожидает предварительно обработанное изображение и возвращает необработанные выходы, описанные в разделе Формат выходных данных, поэтому добавление полей до нужного соотношения сторон и, при экспорте по умолчанию, NMS должны выполняться в твоем коде:
# Сначала выполни экспорт: 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") # или "CPU", "GPU", "NPU"
image = np.zeros((1, 3, 640, 640), dtype=np.float32) # предварительно обработанное изображение: RGB, NCHW, 0-1
detections = compiled(image)[0][0] # первый выход, первое изображение: форма (300, 6)
detections = detections[detections[:, 4] > 0.25] # оставить строки выше порога уверенности
with open("yolo26n_openvino_model/metadata.yaml") as f:
names = yaml.safe_load(f)["names"] # {0: 'person', 1: 'bicycle', ...}Руководства по развертыванию#
- Режимы задержки и пропускной способности OpenVINO: выбери минимальную задержку для одного потока или максимальную пропускную способность для множества потоков.
- Intel DL Streamer: запускай экспортированные модели в конвейерах видеоаналитики GStreamer на процессорах, графических процессорах и NPU Intel Core Ultra.
- Устройства инференса OpenVINO: устройства CPU, GPU и NPU, а также режим
AUTOв документации OpenVINO. - Блокноты OpenVINO: обучающие блокноты Intel, в том числе оптимизация YOLO26.
Ограничения и устранение неполадок#
- Версия PyTorch: на старых версиях PyTorch экспорт завершается ошибкой с
OpenVINO export requires torch>=2.1. - macOS 15.4 и новее: OpenVINO 2025.1.0 и более старые версии не работают в этих версиях macOS, поэтому для экспорта требуется
openvino>=2025.2.0, который обновляет более старый пакет. - Контрольные точки, обученные с
quantize=8: дообученная с помощью квантования с учетом обучения контрольная точка не экспортируется сformat='openvino' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. Вместо нее экспортируй исходную контрольную точку, с которой ты начал дообучение, используяquantize=8, либо экспортируй дообученную контрольную точку в ONNX или TensorRT. - Экспорт INT8 без
data: в журнал экспорта записываетсяINT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'., а калибровка выполняется на небольшом датасете по умолчанию для этой задачи. Передайdataс изображениями, характерными для данных, на которых будет работать модель. - Размер калибровки INT8: если в разделе калибровки меньше 300 изображений, экспорт записывает в журнал
>300 images recommended for INT8 calibration, found 4 images.. Вcoco8.yamlвсего 4 проверочных изображения — этого достаточно для проверки экспорта, но недостаточно для калибровки модели перед развертыванием. - Каталог выходных данных: при каждом экспорте одной контрольной точки, кроме INT8, записывается один и тот же каталог
yolo26n_openvino_model/независимо от значенийquantize,imgsz,dynamic,nmsилиbatch, поэтому более поздний экспорт заменяет предыдущий. Все экспорты INT8, сdevice=npuили без него, используют общий каталогyolo26n_int8_openvino_model/. - Устройство недоступно: если запрошенное устройство отсутствует, Ultralytics записывает в журнал
OpenVINO device 'GPU' not available. Using 'AUTO' instead.(илиUsing 'CPU' instead.на компьютере, где OpenVINO обнаруживает только CPU) и продолжает работу на этом устройстве. Убедись, что твой процессор поддерживается OpenVINO, и установи драйвер GPU или NPU Intel. - NPU Intel: Ultralytics запускает NPU с размером пакета 1 и фиксированными входными формами; см. раздел Развертывание. Передай
device=npu, чтобы использовать NPU: еслиdeviceне задан, NPU не выбирается. - Динамические формы с NMS: если для экспорта заданы
dynamic=Trueиnms=True, в журнал записывается'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'., когдаbatchоставлен равным1. Ultralytics обрабатывает большие пакеты частями размером сbatch, заданный при экспорте. - Динамические модели INT8 на CPU Intel AMX: в Linux на CPU с поддержкой AMX (Intel Sapphire Rapids и новее) Ultralytics запускает динамическую модель INT8 на устройстве
CPUилиAUTOс размеромimgsz, заданным при экспорте, как и статическую модель: параметрimgsz, переданный вpredictилиval, игнорируется, аvalиспользует значениеbatch, заданное при экспорте. При этомpredictпо-прежнему принимает пакеты других размеров и повторно компилирует модель для каждого нового размера, поэтому первый инференс с новым размером пакета выполняется медленнее. - Windows: в Windows Ultralytics задает подсказку точности инференса CPU FP32, что запрещает OpenVINO использовать ядра вычислений с плавающей точкой меньшей точности (модели INT8 по-прежнему работают в INT8), и ограничивает oneDNN наборами инструкций ниже AMX. Чтобы задать другое ограничение, установи переменную среды
ONEDNN_MAX_CPU_ISAдо загрузки модели. - Linux на ARM64: Ultralytics запускает устройство
CPUв режиме выполнения OpenVINO с приоритетом точности и точностью инференса FP32. - Встроенная NMS:
nms=Trueвызывает'nms=True' is not valid for classification models.для классификации и игнорируется с предупреждением для моделей семантической сегментации и оценки глубины ('nms=True' is not valid for semantic models. Forcing 'nms=None'.), а также для моделей RT-DETR ('nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.). - Голова без NMS: для
nms=Falseнужна модель с головой без NMS, например YOLO26 или YOLOv10. Для других моделей, например YOLO11, при экспорте появится предупреждениеThis model has no one-to-one head; using one-to-many outputs., а в файл будет записан исходный выход(1, 84, 8400).
Другие ошибки описаны в руководстве по распространённым проблемам.
Результаты тестирования YOLO26 с OpenVINO#
В таблицах ниже сравниваются PyTorch и модели OpenVINO FP32, FP16 и INT8 для всех моделей обнаружения YOLO26. Первый набор измерений получен на серверном CPU с проверкой точности на COCO val2017, второй — на трех процессорах Intel Core Ultra с использованием их CPU и GPU, а также NPU двух из них. На странице моделей YOLO26 указаны точность, скорость ONNX на CPU и скорость TensorRT на T4 для каждой модели.
FP32, FP16 и INT8 на серверном CPU#
Все значения в этом разделе измерены на CPU одного сервера с двумя 96-ядерными процессорами AMD EPYC 9655, а не на CPU Intel. PyTorch работал на 8 потоках, а OpenVINO — на 96 потоках; это значения по умолчанию, выбранные Ultralytics и OpenVINO для этого сервера, поэтому в столбцах PyTorch и OpenVINO различаются и число потоков, и среда выполнения. Кроме того, PyTorch выполнял валидацию с прямоугольным инференсом: каждое изображение дополнялось до прямоугольника, соответствующего его соотношению сторон (512x672 для изображения 480x640), тогда как статические модели OpenVINO всегда работали с размером 640x640.
Миллисекунды на изображение; меньше — лучше. Для каждой модели жирным выделен самый быстрый формат.
| Модель | imgsz | PyTorch | OpenVINO FP32 | OpenVINO FP16 | OpenVINO INT8 |
|---|---|---|---|---|---|
| YOLO26n | 640 | 13.31 | 3.41 | 3.33 | 3.35 |
| YOLO26s | 640 | 24.28 | 5.18 | 5.18 | 4.51 |
| YOLO26m | 640 | 49.94 | 8.39 | 8.34 | 6.60 |
| YOLO26l | 640 | 63.75 | 10.92 | 11.05 | 8.94 |
| YOLO26x | 640 | 115.11 | 17.12 | 17.16 | 12.83 |
YOLO26n на тех же 8 CPU (PyTorch и OpenVINO привязаны к CPU 0–7 этого сервера с помощью taskset):
| Показатель | PyTorch | OpenVINO FP32 | OpenVINO FP16 | OpenVINO INT8 |
|---|---|---|---|---|
| Задержка (мс/изображение) | 9.28 | 7.13 | 7.14 | 6.71 |
| mAPval 50–95 | 40.8 | 40.9 | 40.9 | 40.3 |
- OpenVINO FP32 работал в 3,9–6,7 раза быстрее PyTorch с указанным выше числом потоков по умолчанию, при этом точность отличалась не более чем на 0,1 mAP. Если закрепить оба варианта за теми же 8 CPU, где PyTorch работал быстрее, чем с настройками по умолчанию, OpenVINO FP32 запускал YOLO26n в 1,3 раза быстрее PyTorch, а INT8 — в 1,06 раза быстрее FP32.
- FP16 вдвое уменьшал размер модели при разнице с FP32 не более 0,1 mAP и задержке на уровне FP32 (разница не превышала 3%).
- INT8 работал в 1,02–1,33 раза быстрее FP32, уменьшал размер модели в 3,1–3,9 раза и терял 0,5–0,9 mAP.
Измерения выполнены с ultralytics 8.4.212, OpenVINO 2026.4.1, NNCF 3.4.0 и PyTorch 2.15.0 на batch=1 14 ноября 2026 года. Задержка — это этап инференса, который сообщает val; предварительная и последующая обработка в нее не входят. Значения PyTorch, FP32 и FP16 — среднее по трем запускам, результаты которых различались до 26% для PyTorch и до 6% для OpenVINO. Модели INT8 калибровались на 591 изображении COCO train2017 (split=train fraction=0.005) и собирались трижды; значения INT8 — среднее по трем сборкам. Для таблицы с 8 CPU использовалась одна сборка INT8, запущенная трижды.
CPU, GPU и NPU Intel Core Ultra#
Измерения для этих таблиц выполнены на трех процессорах Intel Core Ultra с openvino 2026.2.1 в режиме тестирования производительности: model.benchmark(data="coco128.yaml", format="openvino", device=...), с параметром device, заданным как cpu, xpu или npu. Точность — это mAP50-95 на датасете COCO128 из 128 изображений, поэтому ее нельзя напрямую сравнивать со значениями для COCO val2017 выше. PyTorch работал на CPU того же процессора. Модели YOLO26 работают на NPU только процессоров Intel Core Ultra серии 2xxV, серии 3xx и новее.
Intel Core Ultra X7 358H#
В Intel Core Ultra X7 358H (Panther Lake) объединены ядра CPU, встроенный GPU Intel Arc и NPU Intel AI Boost.
Миллисекунд на изображение; меньше — лучше. Самый быстрый вариант для каждой модели выделен жирным.
| Модель | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 | NPU FP32 | NPU FP16 | NPU INT8 |
|---|---|---|---|---|---|---|---|---|---|---|
| YOLO26n | 29.28 | 14.35 | 14.23 | 9.99 | 4.09 | 4.03 | 4.24 | 7.68 | 7.71 | 8.60 |
| YOLO26s | 59.32 | 35.03 | 33.55 | 16.68 | 5.08 | 5.14 | 4.47 | 9.89 | 9.94 | 10.69 |
| YOLO26m | 143.21 | 90.53 | 88.82 | 33.33 | 7.10 | 7.06 | 5.61 | 13.02 | 13.13 | 14.84 |
| YOLO26l | 181.16 | 112.83 | 111.31 | 43.27 | 8.45 | 8.49 | 6.25 | 14.53 | 14.55 | 15.64 |
| YOLO26x | 379.75 | 241.21 | 236.87 | 78.92 | 13.03 | 12.98 | 8.74 | 23.48 | 23.41 | 21.56 |
Предыдущие процессоры Intel Core Ultra#
Intel Core Ultra 7 258V (Lunar Lake)
Миллисекунд на изображение; меньше — лучше. Самый быстрый вариант для каждой модели выделен жирным.
| Модель | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 | NPU FP32 | NPU FP16 | NPU INT8 |
|---|---|---|---|---|---|---|---|---|---|---|
| YOLO26n | 27.33 | 16.84 | 16.73 | 8.62 | 3.33 | 3.34 | 3.46 | 23.71 | 23.70 | 23.96 |
| YOLO26s | 60.20 | 54.71 | 54.45 | 20.19 | 4.66 | 4.65 | 3.99 | 26.62 | 26.62 | 25.89 |
| YOLO26m | 152.87 | 178.59 | 179.25 | 53.07 | 9.03 | 8.98 | 5.70 | 32.94 | 33.01 | 30.95 |
| YOLO26l | 201.57 | 238.15 | 233.70 | 67.73 | 11.32 | 11.36 | 7.45 | 36.02 | 35.77 | 32.64 |
| YOLO26x | 431.04 | 567.22 | 561.39 | 151.11 | 19.08 | 19.63 | 13.69 | 49.64 | 49.69 | 41.75 |
Intel Core Ultra 7 155H (Meteor Lake)
Миллисекунд на изображение; меньше — лучше. Самый быстрый вариант для каждой модели выделен жирным.
| Модель | CPU PyTorch | CPU FP32 | CPU FP16 | CPU INT8 | GPU FP32 | GPU FP16 | GPU INT8 |
|---|---|---|---|---|---|---|---|
| YOLO26n | 33.19 | 13.43 | 13.20 | 11.40 | 9.13 | 9.07 | 5.79 |
| YOLO26s | 70.92 | 36.16 | 36.07 | 15.54 | 16.37 | 16.65 | 9.27 |
| YOLO26m | 192.45 | 102.52 | 101.88 | 35.72 | 34.47 | 35.71 | 15.46 |
| YOLO26l | 239.19 | 129.24 | 128.50 | 45.38 | 43.24 | 43.40 | 19.72 |
| YOLO26x | 511.89 | 293.40 | 296.48 | 85.24 | 79.49 | 79.45 | 34.66 |
На всех трёх процессорах:
- CPU: INT8 работал в 1,2–3,8 раза быстрее FP32 и в 2,9–6,0 раза быстрее PyTorch. На X7 358H и 155H FP32 работал в 1,6–2,5 раза быстрее PyTorch, но на 258V — медленнее PyTorch для YOLO26m, YOLO26l и YOLO26x.
- GPU: встроенный GPU запускал модели FP32 в 3,6–29,1 раза быстрее, чем PyTorch на CPU. Для всех моделей, кроме YOLO26n на X7 358H и 258V, INT8 работал быстрее FP32 — максимум в 2,3 раза.
- NPU (X7 358H и 258V): модели FP32 работали в 1,2–16,2 раза быстрее, чем PyTorch на CPU, а INT8 — со скоростью от 0,88 до 1,19 от скорости FP32. Эти модели INT8 были экспортированы до того, как
device=npuвыбрал симметричные активации, поэтому в таблицах не показан экспорт INT8, настроенный для NPU. - Задержка FP16 на всех устройствах отличалась от FP32 не более чем на 5%, а INT8 терял от 0,1 до 2,7 пункта mAP50-95.
Об OpenVINO#
OpenVINO — сокращение от Open Visual Inference and оптимизация нейронных сетей — преобразует модели из таких фреймворков, как PyTorch, в формат IR и запускает их через единый API на CPU, GPU и NPU Intel. Полную справочную информацию см. в документации OpenVINO.
Смотри: Как экспортировать Ultralytics YOLO26 в формат Intel OpenVINO для ускорения инференса 🚀
Часто задаваемые вопросы#
Да, на CPU. Устройство OpenVINO
CPUработает на процессорах x86-64 и ARM64: тесты серверных CPU на этой странице проведены на процессорах AMD EPYC, а тот же экспорт работает на Apple silicon. Для устройствGPUиNPUтребуется оборудование Intel, поэтому на других машинахdevice=xpuиdevice=npuпереключаются на запасной вариант с предупреждением. Другие варианты см. в руководстве по вариантам развёртывания моделей.Это зависит от устройства. FP16 (
quantize=16) не требует калибровочных данных, уменьшает размер модели вдвое и в бенчмарках сохраняет точность и задержку на уровне FP32, поэтому используй его, если для тебя важен размер модели. Для большинства моделей INT8 (quantize=8) обеспечивал минимальную задержку на CPU: на серверном CPU он снизил задержку YOLO26s с 5.18 мс до 4.51 мс на изображение при 47.6 mAPval 50-95 против 48.5 у FP32, а на процессорах Intel Core Ultra он работал в 1.2–3.8 раза быстрее FP32. На встроенных GPU Intel выигрыш от INT8 был меньше — до 2.3 раза, а на NPU модели INT8 в этих запусках, экспортированные безdevice=npu, работали примерно так же быстро, как FP32. Для INT8 нужны репрезентативные калибровочные данные, поэтому проверь модель INT8 на своих данных, прежде чем выбирать её.Выполни экспорт с помощью
dynamic=Trueи передай нужные размер пакета иimgszво время предсказания. Размер изображения должен быть кратен шагу модели — 32 для официальных контрольных точек YOLO26, кроме моделей классификации; исключения см. в разделе Развёртывание.Экспорт с динамическими размерами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) # пакет из 4 изображений размером 320 пикселейВыбирай OpenVINO, если оборудование для развёртывания — Intel:
device=xpuиdevice=npuвыбирают GPU и NPU Intel, а модели OpenVINO INT8 в тестах производительности работали на CPU Intel Core Ultra в 1,2–3,8 раза быстрее FP32. Выбирай ONNX, если один файл должен запускаться также на GPU NVIDIA или AMD либо в средах выполнения, отличных от OpenVINO; в Windows Windows ML может выбрать оборудование Intel для модели ONNX.
Комментарии23
Задай вопрос, поделись результатами или помоги кому-нибудь.
Heyujie96
how can i export a trained cls or obb kind model to openvino kind
EduardoNew
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.appimage 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?
Glenn JocherUltralytics(изменено)@EduardoNew the exit code 0xC0000005 often indicates a memory access violation. Let's address this step-by-step:
-
Path Format: Try using forward slashes in your OpenVINO model path:
"yolov8n_openvino_model/"instead of backslashes. -
OpenVINO Version: Ultralytics requires
openvino>=2024.0.0. Try upgrading to a recent release:
pip install -U openvino- 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!
-
Ranjith3436
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.
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.
Ranjith3436
how do i can know about model's ability?
Glenn JocherUltralyticsTo 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.
kimchi2020
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
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
-
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/' -
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! 🚀
-
kimchi2020
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
Glenn JocherUltralyticsHi @kimchi2020,
Thank you for reaching out! The error you're encountering seems to be related to a circular import issue with the
torchvisionlibrary. This can happen if there's a naming conflict or an import loop in your code.Steps to Resolve the Issue:
-
Check for Naming Conflicts: Ensure that your script name (
onnx.py) is not conflicting with any library names. Rename your script to something unique, likerun_inference.py. -
Verify Installation: Make sure you have the latest versions of
torch,torchvision, andultralyticsinstalled. You can update them using:pip install --upgrade torch torchvision ultralytics -
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! 🚀
-
YA12SHYAM
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
Glenn JocherUltralytics(изменено)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 withdevice="intel:gpu", for exampleov_model("bus.jpg", device="intel:gpu"). For more details, please refer to the OpenVINO integration guide.YA12SHYAM
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
Glenn JocherUltralytics(изменено)@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.
kanishkasw
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'
Paula DerrengerUltralytics(изменено)@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
torchandultralytics. Please run the following commands to update your packages:pip install --upgrade torch ultralyticsNext, 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 requiresopenvino>=2024.0.0). You can install it using the following command:pip install -U openvinoOnce you've updated the packages, try exporting the model again:
yolo export model=runs/classify/train/weights/best.pt format=openvinoIf 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! 😊
renato-rodrig
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.
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
YouROS12
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.
Glenn JocherUltralytics(изменено)@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 ONNXopsetargument does not apply and the oldmoModel 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 trymodel.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.YouROS12
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.
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.
