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#
| Propiedad | Detalles |
|---|---|
Argumento format | openvino |
| Salida | yolo26n_openvino_model/, un directorio con yolo26n.xml, yolo26n.bin y metadata.yaml; yolo26n_int8_openvino_model/ para una exportación quantize=8 |
| Se ejecuta en | CPU 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ón | OpenVINO Runtime 2024.0.0 o posterior (el paquete Python openvino) |
| Precisión | FP32, FP16, INT8. YOLO26n ocupa 10,1 MB en FP32, 5,3 MB en FP16 y 3,3 MB en INT8 |
| Equipo de exportación | Linux, macOS o Windows. La exportación se ejecuta en la CPU y no necesita GPU |
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:
| Paquete | Versión requerida |
|---|---|
torch | 2.1 o posterior |
openvino | 2024.0.0 o posterior; 2025.2.0 o posterior en macOS 15.4 y versiones posteriores |
nncf | 2.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.
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/'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")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#
| Argumento | Tipo | Predeterminado | Descripción |
|---|---|---|---|
format | str | 'openvino' | Formato de destino del modelo exportado, que define su compatibilidad con distintos entornos de implementación. |
imgsz | int o tuple | 640 | Tamañ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. |
quantize | int o str | None | Precisió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. |
data | str | None | Archivo 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. |
fraction | float, int o list | 1.0 | Subconjunto 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. |
dynamic | bool | False | Hace 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. |
nms | bool, opcional | None | Selecciona la salida sin procesar (None, valor predeterminado), NMS integrado (True) o el cabezal sin NMS (False). Consulta el formato de salida. |
batch | int | 1 | Tamañ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. |
device | str | None | La 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
valdedata, o de la partición que se establezca consplit. Usafractionpara 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
float32y 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=npua 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.
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:
| Archivo | Contenido |
|---|---|
yolo26n.xml | El grafo de la red en formato OpenVINO IR |
yolo26n.bin | Los pesos |
metadata.yaml | Nombres 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:
device | Dispositivo OpenVINO |
|---|---|
| sin configurar | AUTO, 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 |
cpu | CPU |
xpu o xpu:0 | GPU o GPU.0, la GPU integrada o discreta Intel. xpu:1 selecciona GPU.1 en un equipo con dos GPU Intel |
npu | NPU, 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
imgszybatch, que Ultralytics lee demetadata.yaml. Se ignora unimgszpasado apredict. 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):predictadmite distintos tamaños de lote y cualquierimgszque 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
LATENCYde OpenVINO y ejecuta las inferencias de forma síncrona. Para atender muchas solicitudes en paralelo con la sugerenciaTHROUGHPUT, 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#
- Modos de latencia y rendimiento de OpenVINO: elige entre la latencia más baja para un flujo y el mayor rendimiento para muchos.
- Intel DL Streamer: ejecuta modelos exportados en canalizaciones de análisis de vídeo GStreamer en CPU, GPU y NPU Intel Core Ultra.
- Dispositivos de inferencia OpenVINO: los dispositivos CPU, GPU y NPU, y el modo
AUTOen la documentación de OpenVINO. - Notebooks de OpenVINO: notebooks de tutoriales de Intel, incluida la optimización de YOLO26.
Limitaciones y solución de problemas#
- Versión de PyTorch: la exportación falla con
OpenVINO export requires torch>=2.1en 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.0y actualiza un paquete anterior. - Checkpoints entrenados con
quantize=8: un checkpoint ajustado con entrenamiento consciente de la cuantización falla conformat='openvino' cannot export a QAT model: its Q/DQ ranges are only read by the 'onnx' and 'engine' backends. En su lugar, exporta conquantize=8el checkpoint desde el que empezaste el ajuste, o exporta el checkpoint ajustado a ONNX o TensorRT. - Exportación INT8 sin
data: la exportación registraINT8 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. Pasadatacon 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.yamlsolo 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 suquantize,imgsz,dynamic,nmsobatch, por lo que cada exportación posterior sustituye a la anterior. Todas las exportaciones INT8, con o sindevice=npu, compartenyolo26n_int8_openvino_model/. - Dispositivo no disponible: cuando falta el dispositivo solicitado, Ultralytics registra
OpenVINO device 'GPU' not available. Using 'AUTO' instead.(oUsing '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=npupara usarla: sideviceno está definido, no se selecciona la NPU. - Formas dinámicas con NMS: una exportación con
dynamic=Trueynms=Trueregistra'dynamic=True' export requires a maximum batch size, e.g. 'batch=16'.cuandobatchse deja en1. Ultralytics ejecuta los lotes más grandes en bloques del tamaño del lote de exportaciónbatch. - 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
CPUoAUTOcon su valor de exportaciónimgsz, igual que con un modelo estático: se ignora unimgszpasado apredictoval, yvalusa el valor de exportaciónbatch.predictsigue 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_ISAantes de cargar el modelo para usar un límite distinto. - Linux en ARM64: Ultralytics ejecuta el dispositivo
CPUen el modo de ejecución de precisión de OpenVINO con precisión de inferencia FP32. - NMS integrado:
nms=Truegenera'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=Falserequiere un modelo con un cabezal sin NMS, como YOLO26 o YOLOv10. Para otros modelos, por ejemplo YOLO11, la exportación muestra la advertenciaThis 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.
| Modelo | 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 en las mismas 8 CPU (PyTorch y OpenVINO fijados ambos a las CPU 0-7 de ese servidor con taskset):
| Métrica | PyTorch | OpenVINO FP32 | OpenVINO FP16 | OpenVINO INT8 |
|---|---|---|---|---|
| Latencia (ms/imagen) | 9.28 | 7.13 | 7.14 | 6.71 |
| mAPval 50-95 | 40.8 | 40.9 | 40.9 | 40.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.
| Modelo | CPU de 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 |
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.
| Modelo | CPU de 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)
Milisegundos por imagen; cuanto menor, mejor. La columna más rápida de cada modelo aparece en negrita.
| Modelo | CPU de 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 |
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=npuseleccionara 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.
Ver: Cómo exportar Ultralytics YOLO26 al formato Intel OpenVINO para acelerar la inferencia 🚀
Preguntas frecuentes#
Sí, en la CPU. El dispositivo OpenVINO
CPUfunciona 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 dispositivosGPUyNPUnecesitan hardware Intel, por lo quedevice=xpuydevice=npurecurren 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 sindevice=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=Truey pasa el lote yimgszque 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ámicafrom 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íxelesUsa OpenVINO cuando el hardware de implementación sea Intel:
device=xpuydevice=npuseleccionan 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.
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(editado)@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(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 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(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.
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(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
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(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 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.
