Empezar

Exportación a Intel OpenVINO

OpenVINO es el kit de herramientas de código abierto de Intel para optimizar y ejecutar inferencias de IA. Al exportar un modelo Ultralytics YOLO26 con format="openvino" se crea un directorio yolo26n_openvino_model/ que contiene un modelo OpenVINO IR (archivos .xml y .bin) para CPU Intel, GPU Intel integradas y discretas, y NPU Intel, con precisión FP32, FP16 o INT8.

Resumen#

PropiedadDetalles
Argumento formatopenvino
Salidayolo26n_openvino_model/, un directorio con yolo26n.xml, yolo26n.bin y metadata.yaml; yolo26n_int8_openvino_model/ para una exportación quantize=8
Se ejecuta enCPU Intel, GPU Intel integradas y discretas, y NPU Intel. El dispositivo CPU también funciona en otros procesadores x86-64 y ARM64, como los de AMD y Apple silicon
Entorno de ejecuciónOpenVINO Runtime 2024.0.0 o posterior (el paquete Python openvino)
PrecisiónFP32, FP16, INT8. YOLO26n ocupa 10,1 MB en FP32, 5,3 MB en FP16 y 3,3 MB en INT8
Equipo de exportaciónLinux, macOS o Windows. La exportación se ejecuta en la CPU y no necesita GPU
Exportar en la nube

Ultralytics Platform puede exportar por ti un modelo entrenado a OpenVINO, así que no necesitas un entorno de exportación local.

Inicio rápido#

Instala el paquete Ultralytics con las dependencias de exportación de OpenVINO:

pip install "ultralytics[export-openvino]"

Esto instala openvino y, en Python 3.9 o posterior, nncf para la cuantización INT8. Con un pip install ultralytics normal, la primera exportación instala los paquetes que falten. La exportación requiere estas versiones:

PaqueteVersión requerida
torch2.1 o posterior
openvino2024.0.0 o posterior; 2025.2.0 o posterior en macOS 15.4 y versiones posteriores
nncf2.14.0 o posterior, solo para quantize=8; inferior a 3.0.0 con PyTorch inferior a 2.3

Para otros métodos de instalación, consulta la guía de instalación. Después, exporta el modelo y carga el directorio exportado para ejecutar inferencias o validar su precisión. El curso de OpenVINO en CPU recorre los mismos pasos.

Exportar
from ultralytics import YOLO

# Carga un modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporta el modelo al formato OpenVINO
model.export(format="openvino")  # creates 'yolo26n_openvino_model/'

# Exportar un modelo OpenVINO cuantizado a INT8 con datos de calibración
model.export(format="openvino", quantize=8, data="coco8.yaml")  # creates 'yolo26n_int8_openvino_model/'
Predecir
from ultralytics import YOLO

# Carga el modelo OpenVINO exportado
model = YOLO("yolo26n_openvino_model/")

# Ejecutar inferencia
results = model("https://ultralytics.com/images/bus.jpg")

# Ejecuta inferencias en la GPU Intel; usa "npu" para la NPU Intel o "cpu" para la CPU
results = model("https://ultralytics.com/images/bus.jpg", device="xpu")
Validar
from ultralytics import YOLO

# Carga el modelo OpenVINO exportado
model = YOLO("yolo26n_openvino_model/")

# Valida la precisión con el conjunto de datos COCO8
metrics = model.val(data="coco8.yaml")

Tareas compatibles#

La exportación a OpenVINO admite las siete tareas de Ultralytics con modelos YOLOv8, YOLO11 y YOLO26: detección, segmentación, segmentación semántica, estimación de profundidad, clasificación, estimación de pose y OBB. La segmentación semántica y la estimación de profundidad solo están disponibles con YOLO26, la única familia que incluye esos cabezales.

Argumentos de exportación#

ArgumentoTipoPredeterminadoDescripción
formatstr'openvino'Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación.
imgszint o tuple640Tamaño de imagen de la entrada del modelo: un entero para imágenes cuadradas o una tupla (height, width). Si no se especifica, la exportación utiliza el tamaño con el que se entrenó el punto de control. Los puntos de control oficiales de YOLO26 utilizan 640 para detección, segmentación, pose y modelos semánticos preentrenados con ADE20K, 1024 para OBB y modelos semánticos preentrenados con Cityscapes, 768 para profundidad y 224 para clasificación.
quantizeint o strNonePrecisión de cuantización: 16 (FP16: los pesos se almacenan con precisión de media precisión, mientras que las entradas y salidas siguen siendo FP32) o 8 (cuantización posterior al entrenamiento a INT8 con NNCF usando imágenes de calibración de data, que se guardan en un directorio _int8_openvino_model/); 32/sin definir corresponde a FP32. Un checkpoint entrenado con quantize=8 no se puede exportar a OpenVINO; consulta Limitaciones y resolución de problemas. Sustituye las opciones obsoletas half/int8.
datastrNoneArchivo YAML del conjunto de datos usado para la calibración INT8; en clasificación, en su lugar se indica un directorio de conjunto de datos o un nombre de conjunto de datos integrado. La calibración usa la partición val, salvo que se establezca split. Si se omite con quantize=8, Ultralytics usa el pequeño conjunto de datos predeterminado para la tarea del modelo, como coco8.yaml para detección.
fractionfloat, int o list1.0Subconjunto de calibración expresado como proporción, número de imágenes o proporciones/recuentos [train, val, test]. Las listas de dos elementos dejan completo test, mientras que 0 lo omite.
dynamicboolFalseHace que el tamaño del lote, la altura y la anchura de la entrada sean dinámicos, de modo que un mismo modelo admita distintos tamaños de lote e imágenes. En una NPU Intel, un modelo dinámico sigue ejecutándose con el valor de exportación imgsz; consulta Implementación.
nmsbool, opcionalNoneSelecciona la salida sin procesar (None, valor predeterminado), NMS integrado (True) o el cabezal sin NMS (False). Consulta el formato de salida.
batchint1Tamaño del lote del modelo exportado. En una exportación estática, este tamaño de lote queda fijado en la forma de entrada. También es el tamaño del lote usado para la calibración INT8.
devicestrNoneLa exportación siempre se ejecuta en la CPU. Con quantize=8, device=npu selecciona activaciones INT8 simétricas para los modelos YOLO de detección, segmentación, pose y OBB, que se ejecutan hasta 2 veces más rápido en las NPU Intel.

Para consultar los argumentos comunes a todos los formatos, visita la documentación del modo de exportación.

Cuantización INT8#

quantize=8 aplica cuantización posterior al entrenamiento con NNCF: la exportación ejecuta las imágenes de calibración a través del modelo y almacena los pesos y las activaciones como enteros de 8 bits cuando es posible.

  • Datos de calibración: la exportación calibra con cada lote completo de la partición val de data, o de la partición que se establezca con split. Usa fraction para limitar el número de imágenes. La exportación muestra una advertencia si hay menos de 300 imágenes.
  • Cabezal de detección: en los modelos con un cabezal de detección YOLO (detección, segmentación, pose y OBB) y en RT-DETR, las operaciones que decodifican las salidas del cabezal (cambio de forma, concatenación, decodificación de cajas y DFL) y todas las operaciones sigmoid se mantienen en coma flotante, mientras que las convoluciones del cabezal se cuantizan. Los modelos de clasificación, segmentación semántica y profundidad no tienen operaciones excluidas.
  • Entradas y salidas: un modelo INT8 conserva la entrada float32 y las salidas del modelo FP32, por lo que el código de inferencia escrito para el modelo FP32 se ejecuta sin cambios.
  • NPU Intel: añade device=npu a una exportación INT8 que tengas previsto ejecutar en una NPU Intel. Cambia la cuantización de activaciones de los modelos YOLO de detección, segmentación, pose y OBB, de asimétrica a simétrica.
Ejemplo
from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Calibra con el 10 % de las imágenes de validación de COCO (500 imágenes); sustituye coco.yaml por tu propio conjunto de datos
model.export(format="openvino", quantize=8, data="coco.yaml", fraction=0.1)

# Carga el modelo INT8 exportado y ejecuta inferencias
model = YOLO("yolo26n_int8_openvino_model/")
results = model("https://ultralytics.com/images/bus.jpg")

En los benchmarks, los modelos INT8 se ejecutaron entre 1,02 y 1,33 veces más rápido que los FP32 en una CPU de servidor y perdieron entre 0,5 y 0,9 mAP en COCO val2017. En CPU Intel Core Ultra, INT8 se ejecutó entre 1,2 y 3,8 veces más rápido que FP32. Valida un modelo INT8 con tus propios datos antes de implementarlo.

Formato de salida#

La exportación escribe un directorio con tres archivos:

ArchivoContenido
yolo26n.xmlEl grafo de la red en formato OpenVINO IR
yolo26n.binLos pesos
metadata.yamlNombres de las clases, tarea, tamaño de imagen, tamaño del lote, stride y argumentos de exportación, que Ultralytics lee al cargar el modelo

El modelo recibe una entrada con la forma (batch, 3, height, width), en RGB y escalada a 0-1. La entrada y las salidas son float32 en los modelos FP32, FP16 e INT8, salvo la salida de segmentación semántica, que es un mapa de clases uint8 (int32 para modelos con más de 256 clases). Los tensores no llevan los nombres images y output0 de la exportación ONNX, así que en tu propio código debes acceder a la entrada y las salidas por índice.

Las formas de salida son las mismas que en la exportación ONNX y dependen de la tarea y del argumento nms: un modelo YOLO26n de detección exportado con imgsz=640 devuelve (1, 84, 8400) con los valores predeterminados nms=None y (1, 300, 6) con nms=False o nms=True. Consulta el formato de salida de ONNX para ver las formas y el contenido de cada tarea. Con nms=True, el umbral de confianza conf (valor predeterminado 0.25), el umbral IoU iou, agnostic_nms y max_det quedan fijados en el grafo durante la exportación. Un valor conf más bajo al predecir o validar no puede recuperar las detecciones que el grafo ya haya eliminado, así que vuelve a exportar para cambiar estos valores.

Despliega#

YOLO("yolo26n_openvino_model/") ejecuta el modelo con OpenVINO Runtime y asigna el argumento device a un dispositivo OpenVINO:

deviceDispositivo OpenVINO
sin configurarAUTO, que permite a OpenVINO elegir entre la CPU y las GPU Intel (su lista de prioridades predeterminada excluye la NPU), o CPU cuando la CPU es el único dispositivo que OpenVINO detecta
cpuCPU
xpu o xpu:0GPU o GPU.0, la GPU integrada o discreta Intel. xpu:1 selecciona GPU.1 en un equipo con dos GPU Intel
npuNPU, la unidad de procesamiento neuronal de los procesadores Intel Core Ultra

Otros valores, como 0 o mps, se gestionan como si device no estuviera definido. Los nombres anteriores intel:cpu, intel:gpu y intel:npu siguen funcionando y registran una advertencia de obsolescencia. La tabla de dispositivos de inferencia compara estos nombres en distintos formatos. La línea de registro Using OpenVINO LATENCY mode for batch=1 inference on CPU... indica el dispositivo que OpenVINO comunica al cargar el modelo. Con AUTO, puede ser la CPU mientras una GPU Intel sigue compilando el modelo, así que establece device para asegurarte. Para un modelo .pt, device="xpu" selecciona en su lugar el backend de GPU Intel de PyTorch, que también es el dispositivo para el entrenamiento en GPU Intel, y device="npu" selecciona una NPU Huawei Ascend, no la NPU Intel.

El comportamiento durante la inferencia depende de cómo se haya exportado el modelo:

  • Exportación estática (predeterminada): el modelo siempre se ejecuta con los valores de exportación imgsz y batch, que Ultralytics lee de metadata.yaml. Se ignora un imgsz pasado a predict. Los lotes más grandes se dividen en bloques del tamaño del lote de exportación y los más pequeños se rellenan, por lo que se admite cualquier número de imágenes.
  • Exportación dinámica (dynamic=True): predict admite distintos tamaños de lote y cualquier imgsz que sea múltiplo del stride del modelo. Las NPU Intel y los modelos INT8 en CPU Intel AMX son excepciones; consulta Limitaciones y resolución de problemas.
  • Modo de latencia: Ultralytics compila el modelo con la sugerencia de rendimiento LATENCY de OpenVINO y ejecuta las inferencias de forma síncrona. Para atender muchas solicitudes en paralelo con la sugerencia THROUGHPUT, usa la API OpenVINO Runtime como se muestra en la guía de latencia y rendimiento.
  • NPU Intel: Ultralytics compila el modelo para un tamaño de lote 1 en una NPU y divide los lotes más grandes en imágenes individuales. En una NPU, una exportación dinámica queda fijada al valor de exportación imgsz.

Ejecuta el modelo con la API OpenVINO Runtime#

Para ejecutar el modelo fuera del paquete Ultralytics, carga el archivo .xml con el paquete openvino. El modelo espera una imagen preprocesada y devuelve las salidas sin procesar descritas en Formato de salida, así que el letterboxing y, en una exportación predeterminada, NMS quedan a cargo de tu código:

# Exporta primero: 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")  # o "CPU", "GPU", "NPU"

image = np.zeros((1, 3, 640, 640), dtype=np.float32)  # tu imagen preprocesada: RGB, NCHW, 0-1
detections = compiled(image)[0][0]  # primera salida, primera imagen: forma (300, 6)
detections = detections[detections[:, 4] > 0.25]  # conserva las filas que superen el umbral de confianza

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

Guías de despliegue#

Limitaciones y solución de problemas#

  • Versión de PyTorch: la exportación falla con OpenVINO export requires torch>=2.1 en versiones anteriores de PyTorch.
  • macOS 15.4 y versiones posteriores: OpenVINO 2025.1.0 y versiones anteriores fallan en estas versiones de macOS, por lo que la exportación requiere openvino>=2025.2.0 y actualiza un paquete anterior.
  • Checkpoints entrenados con quantize=8: un checkpoint ajustado con entrenamiento consciente de la cuantización falla con format='openvino' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. En su lugar, exporta con quantize=8 el checkpoint desde el que empezaste el ajuste, o exporta el checkpoint ajustado a ONNX o TensorRT.
  • Exportación INT8 sin data: la exportación registra INT8 export requires a missing 'data' arg for calibration. Using default 'data=coco8.yaml'. y calibra con el pequeño conjunto de datos predeterminado para la tarea. Pasa data con imágenes representativas de los datos de implementación.
  • Tamaño de calibración INT8: la exportación registra >300 images recommended for INT8 calibration, found 4 images. cuando la partición de calibración contiene menos de 300 imágenes. coco8.yaml solo tiene 4 imágenes de validación, suficientes para probar la exportación, pero no para calibrar un modelo para su implementación.
  • Directorio de salida: todas las exportaciones de un checkpoint que no sean INT8 escriben en el mismo directorio yolo26n_openvino_model/, independientemente de su quantize, imgsz, dynamic, nms o batch, por lo que cada exportación posterior sustituye a la anterior. Todas las exportaciones INT8, con o sin device=npu, comparten yolo26n_int8_openvino_model/.
  • Dispositivo no disponible: cuando falta el dispositivo solicitado, Ultralytics registra OpenVINO device 'GPU' not available. Using 'AUTO' instead. (o Using 'CPU' instead. en un equipo donde OpenVINO solo detecta la CPU) y continúa con ese dispositivo. Comprueba que tu procesador sea compatible con OpenVINO e instala el controlador Intel de GPU o NPU.
  • NPU Intel: Ultralytics ejecuta una NPU con tamaño de lote 1 y formas de entrada fijas; consulta Implementación. Pasa device=npu para usarla: si device no está definido, no se selecciona la NPU.
  • Formas dinámicas con NMS: una exportación con dynamic=True y nms=True registra 'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'. cuando batch se deja en 1. Ultralytics ejecuta los lotes más grandes en bloques del tamaño del lote de exportación batch.
  • Modelos INT8 dinámicos en CPU Intel AMX: en Linux, con una CPU compatible con AMX (Intel Sapphire Rapids y posteriores), Ultralytics ejecuta un modelo INT8 dinámico en el dispositivo CPU o AUTO con su valor de exportación imgsz, igual que con un modelo estático: se ignora un imgsz pasado a predict o val, y val usa el valor de exportación batch. predict sigue admitiendo otros tamaños de lote y vuelve a compilar el modelo para cada nuevo tamaño de lote, por lo que la primera inferencia con un tamaño de lote nuevo es más lenta.
  • Windows: en Windows, Ultralytics establece la sugerencia de precisión de inferencia de la CPU en FP32, lo que impide que OpenVINO use kernels de coma flotante de menor precisión (los modelos INT8 siguen ejecutándose en INT8), y limita oneDNN a conjuntos de instrucciones anteriores a AMX. Establece la variable de entorno ONEDNN_MAX_CPU_ISA antes de cargar el modelo para usar un límite distinto.
  • Linux en ARM64: Ultralytics ejecuta el dispositivo CPU en el modo de ejecución de precisión de OpenVINO con precisión de inferencia FP32.
  • NMS integrado: nms=True genera 'nms=True' is not valid for classification models. para clasificación, y se ignora con una advertencia en los modelos de segmentación semántica y estimación de profundidad ('nms=True' is not valid for semantic models. Forcing 'nms=None'.) y en los modelos RT-DETR ('nms=True' is not available for end2end models or non-YOLO heads. Forcing 'nms=None'.).
  • Cabezal sin NMS: nms=False requiere un modelo con un cabezal sin NMS, como YOLO26 o YOLOv10. Para otros modelos, por ejemplo YOLO11, la exportación muestra la advertencia This model has no one-to-one head; using one-to-many outputs. y escribe la salida sin procesar (1, 84, 8400).

Para otros errores, consulta la guía de problemas habituales.

Pruebas de rendimiento de YOLO26 con OpenVINO#

Las tablas siguientes comparan PyTorch con modelos OpenVINO FP32, FP16 e INT8 de todos los modelos YOLO26 de detección. El primer conjunto se midió en una CPU de servidor con precisión COCO val2017, y el segundo en tres procesadores Intel Core Ultra con sus CPU y GPU, además de la NPU de dos de ellos. La página de modelos YOLO26 muestra la precisión, la velocidad de ONNX en CPU y la velocidad de TensorRT en T4 de cada modelo.

FP32, FP16 e INT8 en una CPU de servidor#

Todos los valores de esta sección se midieron en la CPU de un servidor con dos procesadores AMD EPYC 9655 de 96 núcleos, no en una CPU Intel. PyTorch se ejecutó con 8 subprocesos y OpenVINO con 96, los valores predeterminados que Ultralytics y OpenVINO eligieron en ese servidor, así que las columnas de PyTorch y OpenVINO difieren tanto en el número de subprocesos como en el entorno de ejecución. PyTorch también validó con inferencia rectangular: cada imagen se rellenó hasta formar un rectángulo que sigue su relación de aspecto (512x672 para una imagen de 480x640), mientras que los modelos OpenVINO estáticos siempre se ejecutaron a 640x640.

Milisegundos por imagen; cuanto menos, mejor. El formato más rápido de cada modelo aparece en negrita.

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

YOLO26n en las mismas 8 CPU (PyTorch y OpenVINO fijados ambos a las CPU 0-7 de ese servidor con taskset):

MétricaPyTorchOpenVINO FP32OpenVINO FP16OpenVINO INT8
Latencia (ms/imagen)9.287.137.146.71
mAPval 50-9540.840.940.940.3
  • OpenVINO FP32 se ejecutó entre 3,9 y 6,7 veces más rápido que PyTorch con los números predeterminados de subprocesos anteriores, con una precisión equivalente dentro de 0,1 mAP. Al fijar ambos a las mismas 8 CPU, donde PyTorch se ejecutó más rápido que con la configuración predeterminada, OpenVINO FP32 ejecutó YOLO26n 1,3 veces más rápido que PyTorch e INT8, 1,06 veces más rápido que FP32.
  • FP16 redujo a la mitad el tamaño del modelo con una diferencia de hasta 0,1 mAP respecto a FP32 y una latencia equivalente a FP32 (con una diferencia de hasta el 3 %).
  • INT8 se ejecutó entre 1,02 y 1,33 veces más rápido que FP32, redujo el tamaño del modelo entre 3,1 y 3,9 veces y perdió entre 0,5 y 0,9 mAP.

Medido con ultralytics 8.4.212, OpenVINO 2026.4.1, NNCF 3.4.0 y PyTorch 2.15.0 en batch=1, el 14 de noviembre de 2026. La latencia corresponde a la fase de inferencia que indica val y no incluye el preprocesamiento ni el posprocesamiento. Los valores de PyTorch, FP32 y FP16 son la media de tres ejecuciones, que variaron hasta un 26 % en PyTorch y un 6 % en OpenVINO. Los modelos INT8 se calibraron con 591 imágenes de COCO train2017 (split=train fraction=0.005) y se generaron tres veces; los valores INT8 son la media de las tres generaciones. La tabla de 8 CPU usa una generación INT8 ejecutada tres veces.

CPU, GPU y NPU Intel Core Ultra#

Estas tablas se midieron en tres procesadores Intel Core Ultra con openvino 2026.2.1 en modo de benchmark: model.benchmark(data="coco128.yaml", format="openvino", device=...), con device establecido en cpu, xpu o npu. La precisión es mAP50-95 en el conjunto de datos COCO128 de 128 imágenes, por lo que no es comparable con los valores de COCO val2017 anteriores. PyTorch se ejecutó en la CPU del mismo procesador. Los modelos YOLO26 solo se ejecutan en la NPU de los procesadores Intel Core Ultra de las series 2xxV, 3xx y posteriores.

Intel Core Ultra X7 358H#

El Intel Core Ultra X7 358H (Panther Lake) combina núcleos de CPU, una GPU Intel Arc integrada y una NPU Intel AI Boost.

Milisegundos por imagen; cuanto menor, mejor. La columna más rápida de cada modelo aparece en negrita.

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

Procesadores Intel Core Ultra anteriores#

Intel Core Ultra 7 258V (Lunar Lake)

Milisegundos por imagen; cuanto menor, mejor. La columna más rápida de cada modelo aparece en negrita.

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

Milisegundos por imagen; cuanto menor, mejor. La columna más rápida de cada modelo aparece en negrita.

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

En los tres procesadores:

  • CPU: INT8 se ejecutó entre 1.2 y 3.8 veces más rápido que FP32 y entre 2.9 y 6.0 veces más rápido que PyTorch. FP32 se ejecutó entre 1.6 y 2.5 veces más rápido que PyTorch en el X7 358H y el 155H, pero más lento que PyTorch para YOLO26m, YOLO26l y YOLO26x en el 258V.
  • GPU: la GPU integrada ejecutó los modelos FP32 entre 3.6 y 29.1 veces más rápido que PyTorch en la CPU. INT8 fue más rápido que FP32 para todos los modelos excepto YOLO26n en el X7 358H y el 258V, hasta 2.3 veces.
  • NPU (X7 358H y 258V): los modelos FP32 se ejecutaron entre 1.2 y 16.2 veces más rápido que PyTorch en la CPU, e INT8 se ejecutó entre 0.88 y 1.19 veces más rápido que FP32. Estos modelos INT8 se exportaron antes de que device=npu seleccionara activaciones simétricas, por lo que las tablas no muestran la exportación INT8 optimizada para NPU.
  • La latencia de FP16 estuvo dentro del 5 % de la de FP32 en todos los dispositivos, e INT8 perdió entre 0.1 y 2.7 puntos de mAP50-95.

Acerca de OpenVINO#

OpenVINO, abreviatura de Inferencia visual abierta y optimización de red neuronal, convierte modelos de frameworks como PyTorch a su formato IR y los ejecuta mediante una sola API en CPU, GPU y NPU Intel. Consulta la documentación de OpenVINO para ver la referencia completa.

OpenVINO Intel AI inference toolkit



Ver: Cómo exportar Ultralytics YOLO26 al formato Intel OpenVINO para acelerar la inferencia 🚀

Preguntas frecuentes#

  • Sí, en la CPU. El dispositivo OpenVINO CPU funciona en procesadores x86-64 y ARM64: las pruebas de rendimiento de CPU de servidor de esta página se midieron en procesadores AMD EPYC, y la misma exportación funciona en Apple silicon. Los dispositivos GPU y NPU necesitan hardware Intel, por lo que device=xpu y device=npu recurren a una alternativa y muestran una advertencia en otros equipos. Para otros destinos, consulta la guía de opciones de implementación de modelos.

  • Depende del dispositivo. FP16 (quantize=16) no necesita datos de calibración, reduce a la mitad el tamaño del modelo y mantuvo la precisión y la latencia de FP32 en las pruebas de rendimiento, así que úsalo cuando el tamaño del modelo sea importante. INT8 (quantize=8) ofreció la latencia de CPU más baja para la mayoría de los modelos: en la CPU de servidor redujo la latencia de YOLO26s de 5.18 ms a 4.51 ms por imagen, con 47.6 mAPval 50-95 frente a 48.5 en FP32, y en las CPU Intel Core Ultra se ejecutó entre 1.2 y 3.8 veces más rápido que FP32. En las GPU Intel integradas, la mejora de INT8 fue menor, de hasta 2.3 veces, y en las NPU los modelos INT8 de estas pruebas, exportados sin device=npu, fueron aproximadamente igual de rápidos que FP32. INT8 necesita datos de calibración representativos, así que valida el modelo INT8 con tus propios datos antes de elegirlo.

  • Exporta con dynamic=True y pasa el lote y imgsz que necesites en el momento de la predicción. El tamaño de imagen debe ser múltiplo del stride del modelo, 32 para los puntos de control oficiales de YOLO26, excepto los de clasificación; consulta Implementación para ver las excepciones.

    Exportación dinámica
    from ultralytics import YOLO
    
    model = YOLO("yolo26n.pt")
    model.export(format="openvino", dynamic=True)
    
    model = YOLO("yolo26n_openvino_model/")
    results = model(["https://ultralytics.com/images/bus.jpg"] * 4, imgsz=320)  # un lote de 4 imágenes de 320 píxeles
  • Usa OpenVINO cuando el hardware de implementación sea Intel: device=xpu y device=npu seleccionan la GPU y la NPU Intel, y los modelos OpenVINO INT8 se ejecutaron entre 1.2 y 3.8 veces más rápido que FP32 en las CPU Intel Core Ultra en las pruebas de rendimiento. Usa ONNX cuando el mismo archivo también tenga que ejecutarse en GPU NVIDIA o AMD, o en entornos de ejecución distintos de OpenVINO; en Windows, Windows ML puede seleccionar hardware Intel para un modelo ONNX.

Comentarios23

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  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(editado)

      @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(editado)

      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(editado)

      @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(editado)

      @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(editado)

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