Exportación a Intel OpenVINO
En esta guía, cubrimos la exportación de modelos YOLO11 al formato OpenVINO, que puede proporcionar hasta 3 veces más velocidad de CPU, así como la aceleración de la inferencia de YOLO en hardware GPU y NPU de Intel.
OpenVINO, abreviatura de Open Visual Inference & Neural Network Optimization toolkit (conjunto de herramientas de optimización de redes neuronales y de inferencia visual abierta), es un conjunto de herramientas completo para optimizar e implementar modelos de inferencia de IA. Aunque el nombre contiene Visual, OpenVINO también admite varias tareas adicionales, incluyendo lenguaje, audio, series de tiempo, etc.
Ver: Cómo exportar Ultralytics YOLO11 al formato Intel OpenVINO para una inferencia más rápida 🚀
Ejemplos de uso
Exporta un modelo YOLO11n a formato OpenVINO y ejecuta la inferencia con el modelo exportado.
Ejemplo
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Export the model
model.export(format="openvino") # creates 'yolo11n_openvino_model/'
# Load the exported OpenVINO model
ov_model = YOLO("yolo11n_openvino_model/")
# Run inference
results = ov_model("https://ultralytics.com/images/bus.jpg")
# Run inference with specified device, available devices: ["intel:gpu", "intel:npu", "intel:cpu"]
results = ov_model("https://ultralytics.com/images/bus.jpg", device="intel:gpu")
# Export a YOLO11n PyTorch model to OpenVINO format
yolo export model=yolo11n.pt format=openvino # creates 'yolo11n_openvino_model/'
# Run inference with the exported model
yolo predict model=yolo11n_openvino_model source='https://ultralytics.com/images/bus.jpg'
# Run inference with specified device, available devices: ["intel:gpu", "intel:npu", "intel:cpu"]
yolo predict model=yolo11n_openvino_model source='https://ultralytics.com/images/bus.jpg' device="intel:gpu"
Argumentos de exportación
Argumento | Tipo | Predeterminado | Descripción |
---|---|---|---|
format |
str |
'openvino' |
Formato de destino para el modelo exportado, que define la compatibilidad con varios entornos de implementación. |
imgsz |
int o tuple |
640 |
Tamaño de imagen deseado para la entrada del modelo. Puede ser un entero para imágenes cuadradas o una tupla (height, width) para dimensiones específicas. |
half |
bool |
False |
Activa la cuantización FP16 (media precisión), reduciendo el tamaño del modelo y, potencialmente, acelerando la inferencia en hardware compatible. |
int8 |
bool |
False |
Activa la cuantización INT8, comprimiendo aún más el modelo y acelerando la inferencia con una pérdida mínima de precisión, principalmente para dispositivos de borde. |
dynamic |
bool |
False |
Permite tamaños de entrada dinámicos, lo que mejora la flexibilidad en el manejo de diferentes dimensiones de imagen. |
nms |
bool |
False |
Añade la supresión no máxima (NMS), esencial para un post-procesamiento de detección preciso y eficiente. |
batch |
int |
1 |
Especifica el tamaño del lote de inferencia del modelo exportado o el número máximo de imágenes que el modelo exportado procesará simultáneamente en predict modo. |
data |
str |
'coco8.yaml' |
Ruta al conjunto de datos archivo de configuración (por defecto: coco8.yaml ), esencial para la cuantificación. |
fraction |
float |
1.0 |
Especifica la fracción del conjunto de datos que se utilizará para la calibración de la cuantificación INT8. Permite calibrar en un subconjunto del conjunto de datos completo, útil para experimentos o cuando los recursos son limitados. Si no se especifica con INT8 habilitado, se utilizará el conjunto de datos completo. |
Para obtener más detalles sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre la exportación.
Advertencia
OpenVINO™ es compatible con la mayoría de los procesadores Intel®, pero para garantizar un rendimiento óptimo:
-
Verificar la compatibilidad con OpenVINO™ Comprueba si tu chip Intel® es oficialmente compatible con OpenVINO™ utilizando la lista de compatibilidad de Intel.
-
Identifique su acelerador Determine si su procesador incluye una NPU (Unidad de Procesamiento Neuronal) o GPU integrada (GPU integrada) consultando la guía de hardware de Intel.
-
Instale los controladores más recientes Si su chip es compatible con una NPU o GPU pero OpenVINO™ no lo detecta, es posible que deba instalar o actualizar los controladores asociados. Siga las instrucciones de instalación de los controladores para habilitar la aceleración completa.
Siguiendo estos tres pasos, puedes asegurar que OpenVINO™ se ejecute de manera óptima en tu hardware Intel®.
Ventajas de OpenVINO
- Rendimiento: OpenVINO ofrece una inferencia de alto rendimiento utilizando la potencia de las CPU, las GPU integradas y discretas, y los FPGA de Intel.
- Soporte para ejecución heterogénea: OpenVINO proporciona una API para escribir una vez e implementar en cualquier hardware Intel compatible (CPU, GPU, FPGA, VPU, etc.).
- Optimizador de Modelos: OpenVINO proporciona un Optimizador de Modelos que importa, convierte y optimiza modelos de frameworks populares de aprendizaje profundo como PyTorch, TensorFlow, TensorFlow Lite, Keras, ONNX, PaddlePaddle y Caffe.
- Facilidad de uso: El kit de herramientas viene con más de 80 cuadernos de tutoriales (incluyendo la optimización de YOLOv8) que enseñan diferentes aspectos del kit de herramientas.
Estructura de exportación de OpenVINO
Cuando se exporta un modelo al formato OpenVINO, se obtiene un directorio que contiene lo siguiente:
- Archivo XML: Describe la topología de la red.
- Archivo BIN: Contiene los datos binarios de pesos y sesgos.
- Archivo de mapeo: Contiene el mapeo de los tensores de salida del modelo original a los nombres de los tensores de OpenVINO.
Puedes usar estos archivos para ejecutar la inferencia con el motor de inferencia OpenVINO.
Usar la exportación OpenVINO en la implementación
Una vez que tu modelo se ha exportado correctamente al formato OpenVINO, tienes dos opciones principales para ejecutar la inferencia:
-
Utilice el
ultralytics
paquete, que proporciona una API de alto nivel y envuelve el OpenVINO Runtime. -
Usar el nativo
openvino
paquete para un control más avanzado o personalizado sobre el comportamiento de la inferencia.
Inferencia con Ultralytics
El paquete ultralytics te permite ejecutar fácilmente la inferencia utilizando el modelo OpenVINO exportado a través del método predict. También puedes especificar el dispositivo de destino (p. ej., intel:gpu
, intel:npu
, intel:cpu
) usando el argumento device.
from ultralytics import YOLO
# Load the exported OpenVINO model
ov_model = YOLO("yolo11n_openvino_model/") # the path of your exported OpenVINO model
# Run inference with the exported model
ov_model.predict(device="intel:gpu") # specify the device you want to run inference on
Este enfoque es ideal para la creación rápida de prototipos o la implementación cuando no necesita un control total sobre el pipeline de inferencia.
Inferencia con OpenVINO Runtime
El runtime de OpenVINO proporciona una API unificada para la inferencia en todo el hardware de Intel compatible. También proporciona capacidades avanzadas como el equilibrio de carga en todo el hardware de Intel y la ejecución asíncrona. Para obtener más información sobre cómo ejecutar la inferencia, consulte los cuadernos de YOLO11.
Recuerda que necesitarás los archivos XML y BIN, así como cualquier configuración específica de la aplicación, como el tamaño de entrada, el factor de escala para la normalización, etc., para configurar y utilizar correctamente el modelo con el Runtime.
En su aplicación de implementación, normalmente realizaría los siguientes pasos:
- Inicializar OpenVINO creando
core = Core()
. - Cargue el modelo usando el
core.read_model()
método. - Compila el modelo utilizando el
core.compile_model()
función. - Prepara la entrada (imagen, texto, audio, etc.).
- Ejecutar inferencia usando
compiled_model(input_data)
.
Para obtener pasos y fragmentos de código más detallados, consulta la documentación de OpenVINO o el tutorial de la API.
Benchmarks de OpenVINO YOLO11
El equipo de Ultralytics evaluó YOLO11 en varios formatos de modelo y precisión, evaluando la velocidad y la exactitud en diferentes dispositivos Intel compatibles con OpenVINO.
Nota
Los resultados de las pruebas de rendimiento que se muestran a continuación son de referencia y pueden variar en función de la configuración exacta del hardware y el software de un sistema, así como de la carga de trabajo actual del sistema en el momento en que se ejecutan las pruebas.
Todos los benchmarks se ejecutan con openvino
Versión del paquete de Python 2025.1.0.
CPU Intel Core
La serie Intel® Core® es una gama de procesadores de alto rendimiento de Intel. La línea incluye Core i3 (nivel de entrada), Core i5 (gama media), Core i7 (gama alta) y Core i9 (rendimiento extremo). Cada serie satisface diferentes necesidades y presupuestos informáticos, desde tareas cotidianas hasta cargas de trabajo profesionales exigentes. Con cada nueva generación, se realizan mejoras en el rendimiento, la eficiencia energética y las características.
Los benchmarks que se muestran a continuación se ejecutan en una CPU Intel® Core® i9-12900KS de 12ª generación con precisión FP32.

Resultados detallados del benchmark
Modelo | Formato | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|
YOLO11n | PyTorch | ✅ | 5.4 | 0.5071 | 21.00 |
YOLO11n | TorchScript | ✅ | 10.5 | 0.5077 | 21.39 |
YOLO11n | ONNX | ✅ | 10.2 | 0.5077 | 15.55 |
YOLO11n | OpenVINO | ✅ | 10.4 | 0.5077 | 11.49 |
YOLO11s | PyTorch | ✅ | 18.4 | 0.5770 | 43.16 |
YOLO11s | TorchScript | ✅ | 36.6 | 0.5781 | 50.06 |
YOLO11s | ONNX | ✅ | 36.3 | 0.5781 | 31.53 |
YOLO11s | OpenVINO | ✅ | 36.4 | 0.5781 | 30.82 |
YOLO11m | PyTorch | ✅ | 38.8 | 0.6257 | 110.60 |
YOLO11m | TorchScript | ✅ | 77.3 | 0.6306 | 128.09 |
YOLO11m | ONNX | ✅ | 76.9 | 0.6306 | 76.06 |
YOLO11m | OpenVINO | ✅ | 77.1 | 0.6306 | 79.38 |
YOLO11l | PyTorch | ✅ | 49.0 | 0.6367 | 150.38 |
YOLO11l | TorchScript | ✅ | 97.7 | 0.6408 | 172.57 |
YOLO11l | ONNX | ✅ | 97.0 | 0.6408 | 108.91 |
YOLO11l | OpenVINO | ✅ | 97.3 | 0.6408 | 102.30 |
YOLO11x | PyTorch | ✅ | 109.3 | 0.6989 | 272.72 |
YOLO11x | TorchScript | ✅ | 218.1 | 0.6900 | 320.86 |
YOLO11x | ONNX | ✅ | 217.5 | 0.6900 | 196.20 |
YOLO11x | OpenVINO | ✅ | 217.8 | 0.6900 | 195.32 |
Intel® Core™ Ultra
La serie Intel® Core™ Ultra™ representa un nuevo punto de referencia en la computación de alto rendimiento, diseñada para satisfacer las demandas cambiantes de los usuarios modernos, desde jugadores y creadores hasta profesionales que aprovechan la IA. Esta línea de nueva generación es más que una serie de CPU tradicional; combina potentes núcleos de CPU, capacidades de GPU integradas de alto rendimiento y una Unidad de Procesamiento Neural (NPU) dedicada dentro de un solo chip, ofreciendo una solución unificada para diversas e intensivas cargas de trabajo informáticas.
En el corazón de la arquitectura Intel® Core Ultra™ se encuentra un diseño híbrido que permite un rendimiento excepcional en tareas de procesamiento tradicionales, cargas de trabajo aceleradas por GPU y operaciones impulsadas por IA. La inclusión de la NPU mejora la inferencia de IA en el dispositivo, lo que permite un aprendizaje automático y un procesamiento de datos más rápidos y eficientes en una amplia gama de aplicaciones.
La familia Core Ultra™ incluye varios modelos adaptados para diferentes necesidades de rendimiento, con opciones que van desde diseños de bajo consumo hasta variantes de alta potencia marcadas con la designación "H", ideales para portátiles y formatos compactos que exigen una gran potencia de cálculo. En toda la línea, los usuarios se benefician de la sinergia de la integración de CPU, GPU y NPU, que ofrece una eficiencia, capacidad de respuesta y capacidades multitarea notables.
Como parte de la innovación continua de Intel, la serie Core Ultra™ establece un nuevo estándar para la computación preparada para el futuro. Con múltiples modelos disponibles y más en el horizonte, esta serie subraya el compromiso de Intel de ofrecer soluciones de vanguardia para la próxima generación de dispositivos inteligentes mejorados con IA.
Los benchmarks que se muestran a continuación se ejecutan en Intel® Core™ Ultra™ 7 258V e Intel® Core™ Ultra™ 7 265K con precisión FP32 e INT8.
Intel® Core™ Ultra™ 7 258V
Benchmarks

Resultados detallados del benchmark
Modelo | Formato | Precisión | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|---|
YOLO11n | PyTorch | FP32 | ✅ | 5.4 | 0.5052 | 32.27 |
YOLO11n | OpenVINO | FP32 | ✅ | 10.4 | 0.5068 | 11.84 |
YOLO11n | OpenVINO | INT8 | ✅ | 3.3 | 0.4969 | 11.24 |
YOLO11s | PyTorch | FP32 | ✅ | 18.4 | 0.5776 | 92.09 |
YOLO11s | OpenVINO | FP32 | ✅ | 36.4 | 0.5797 | 14.82 |
YOLO11s | OpenVINO | INT8 | ✅ | 9.8 | 0.5751 | 12.88 |
YOLO11m | PyTorch | FP32 | ✅ | 38.8 | 0.6262 | 277.24 |
YOLO11m | OpenVINO | FP32 | ✅ | 77.1 | 0.6306 | 22.94 |
YOLO11m | OpenVINO | INT8 | ✅ | 20.2 | 0.6126 | 17.85 |
YOLO11l | PyTorch | FP32 | ✅ | 49.0 | 0.6361 | 348.97 |
YOLO11l | OpenVINO | FP32 | ✅ | 97.3 | 0.6365 | 27.34 |
YOLO11l | OpenVINO | INT8 | ✅ | 25.7 | 0.6242 | 20.83 |
YOLO11x | PyTorch | FP32 | ✅ | 109.3 | 0.6984 | 666.07 |
YOLO11x | OpenVINO | FP32 | ✅ | 217.8 | 0.6890 | 39.09 |
YOLO11x | OpenVINO | INT8 | ✅ | 55.9 | 0.6856 | 30.60 |

Resultados detallados del benchmark
Modelo | Formato | Precisión | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|---|
YOLO11n | PyTorch | FP32 | ✅ | 5.4 | 0.5052 | 32.27 |
YOLO11n | OpenVINO | FP32 | ✅ | 10.4 | 0.5077 | 32.55 |
YOLO11n | OpenVINO | INT8 | ✅ | 3.3 | 0.4980 | 22.98 |
YOLO11s | PyTorch | FP32 | ✅ | 18.4 | 0.5776 | 92.09 |
YOLO11s | OpenVINO | FP32 | ✅ | 36.4 | 0.5782 | 98.38 |
YOLO11s | OpenVINO | INT8 | ✅ | 9.8 | 0.5745 | 52.84 |
YOLO11m | PyTorch | FP32 | ✅ | 38.8 | 0.6262 | 277.24 |
YOLO11m | OpenVINO | FP32 | ✅ | 77.1 | 0.6307 | 275.74 |
YOLO11m | OpenVINO | INT8 | ✅ | 20.2 | 0.6172 | 132.63 |
YOLO11l | PyTorch | FP32 | ✅ | 49.0 | 0.6361 | 348.97 |
YOLO11l | OpenVINO | FP32 | ✅ | 97.3 | 0.6361 | 348.97 |
YOLO11l | OpenVINO | INT8 | ✅ | 25.7 | 0.6240 | 171.36 |
YOLO11x | PyTorch | FP32 | ✅ | 109.3 | 0.6984 | 666.07 |
YOLO11x | OpenVINO | FP32 | ✅ | 217.8 | 0.6900 | 783.16 |
YOLO11x | OpenVINO | INT8 | ✅ | 55.9 | 0.6890 | 346.82 |

Resultados detallados del benchmark
Modelo | Formato | Precisión | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|---|
YOLO11n | PyTorch | FP32 | ✅ | 5.4 | 0.5052 | 32.27 |
YOLO11n | OpenVINO | FP32 | ✅ | 10.4 | 0.5085 | 8.33 |
YOLO11n | OpenVINO | INT8 | ✅ | 3.3 | 0.5019 | 8.91 |
YOLO11s | PyTorch | FP32 | ✅ | 18.4 | 0.5776 | 92.09 |
YOLO11s | OpenVINO | FP32 | ✅ | 36.4 | 0.5788 | 9.72 |
YOLO11s | OpenVINO | INT8 | ✅ | 9.8 | 0.5710 | 10.58 |
YOLO11m | PyTorch | FP32 | ✅ | 38.8 | 0.6262 | 277.24 |
YOLO11m | OpenVINO | FP32 | ✅ | 77.1 | 0.6301 | 19.41 |
YOLO11m | OpenVINO | INT8 | ✅ | 20.2 | 0.6124 | 18.26 |
YOLO11l | PyTorch | FP32 | ✅ | 49.0 | 0.6361 | 348.97 |
YOLO11l | OpenVINO | FP32 | ✅ | 97.3 | 0.6362 | 23.70 |
YOLO11l | OpenVINO | INT8 | ✅ | 25.7 | 0.6240 | 21.40 |
YOLO11x | PyTorch | FP32 | ✅ | 109.3 | 0.6984 | 666.07 |
YOLO11x | OpenVINO | FP32 | ✅ | 217.8 | 0.6892 | 43.91 |
YOLO11x | OpenVINO | INT8 | ✅ | 55.9 | 0.6890 | 34.04 |
Intel® Core™ Ultra™ 7 265K
Benchmarks

Resultados detallados del benchmark
Modelo | Formato | Precisión | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|---|
YOLO11n | PyTorch | FP32 | ✅ | 5.4 | 0.5072 | 16.29 |
YOLO11n | OpenVINO | FP32 | ✅ | 10.4 | 0.5079 | 13.13 |
YOLO11n | OpenVINO | INT8 | ✅ | 3.3 | 0.4976 | 8.86 |
YOLO11s | PyTorch | FP32 | ✅ | 18.4 | 0.5771 | 39.61 |
YOLO11s | OpenVINO | FP32 | ✅ | 36.4 | 0.5808 | 18.26 |
YOLO11s | OpenVINO | INT8 | ✅ | 9.8 | 0.5726 | 13.24 |
YOLO11m | PyTorch | FP32 | ✅ | 38.8 | 0.6258 | 100.65 |
YOLO11m | OpenVINO | FP32 | ✅ | 77.1 | 0.6310 | 43.50 |
YOLO11m | OpenVINO | INT8 | ✅ | 20.2 | 0.6137 | 20.90 |
YOLO11l | PyTorch | FP32 | ✅ | 49.0 | 0.6367 | 131.37 |
YOLO11l | OpenVINO | FP32 | ✅ | 97.3 | 0.6371 | 54.52 |
YOLO11l | OpenVINO | INT8 | ✅ | 25.7 | 0.6226 | 27.36 |
YOLO11x | PyTorch | FP32 | ✅ | 109.3 | 0.6990 | 212.45 |
YOLO11x | OpenVINO | FP32 | ✅ | 217.8 | 0.6884 | 112.76 |
YOLO11x | OpenVINO | INT8 | ✅ | 55.9 | 0.6900 | 52.06 |

Resultados detallados del benchmark
Modelo | Formato | Precisión | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|---|
YOLO11n | PyTorch | FP32 | ✅ | 5.4 | 0.5072 | 16.29 |
YOLO11n | OpenVINO | FP32 | ✅ | 10.4 | 0.5077 | 15.04 |
YOLO11n | OpenVINO | INT8 | ✅ | 3.3 | 0.4980 | 11.60 |
YOLO11s | PyTorch | FP32 | ✅ | 18.4 | 0.5771 | 39.61 |
YOLO11s | OpenVINO | FP32 | ✅ | 36.4 | 0.5782 | 33.45 |
YOLO11s | OpenVINO | INT8 | ✅ | 9.8 | 0.5745 | 20.64 |
YOLO11m | PyTorch | FP32 | ✅ | 38.8 | 0.6258 | 100.65 |
YOLO11m | OpenVINO | FP32 | ✅ | 77.1 | 0.6307 | 81.15 |
YOLO11m | OpenVINO | INT8 | ✅ | 20.2 | 0.6172 | 44.63 |
YOLO11l | PyTorch | FP32 | ✅ | 49.0 | 0.6367 | 131.37 |
YOLO11l | OpenVINO | FP32 | ✅ | 97.3 | 0.6409 | 103.77 |
YOLO11l | OpenVINO | INT8 | ✅ | 25.7 | 0.6240 | 58.00 |
YOLO11x | PyTorch | FP32 | ✅ | 109.3 | 0.6990 | 212.45 |
YOLO11x | OpenVINO | FP32 | ✅ | 217.8 | 0.6900 | 208.37 |
YOLO11x | OpenVINO | INT8 | ✅ | 55.9 | 0.6897 | 113.04 |

Resultados detallados del benchmark
Modelo | Formato | Precisión | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|---|
YOLO11n | PyTorch | FP32 | ✅ | 5.4 | 0.5072 | 16.29 |
YOLO11n | OpenVINO | FP32 | ✅ | 10.4 | 0.5075 | 8.02 |
YOLO11n | OpenVINO | INT8 | ✅ | 3.3 | 0.3656 | 9.28 |
YOLO11s | PyTorch | FP32 | ✅ | 18.4 | 0.5771 | 39.61 |
YOLO11s | OpenVINO | FP32 | ✅ | 36.4 | 0.5801 | 13.12 |
YOLO11s | OpenVINO | INT8 | ✅ | 9.8 | 0.5686 | 13.12 |
YOLO11m | PyTorch | FP32 | ✅ | 38.8 | 0.6258 | 100.65 |
YOLO11m | OpenVINO | FP32 | ✅ | 77.1 | 0.6310 | 29.88 |
YOLO11m | OpenVINO | INT8 | ✅ | 20.2 | 0.6111 | 26.32 |
YOLO11l | PyTorch | FP32 | ✅ | 49.0 | 0.6367 | 131.37 |
YOLO11l | OpenVINO | FP32 | ✅ | 97.3 | 0.6356 | 37.08 |
YOLO11l | OpenVINO | INT8 | ✅ | 25.7 | 0.6245 | 30.81 |
YOLO11x | PyTorch | FP32 | ✅ | 109.3 | 0.6990 | 212.45 |
YOLO11x | OpenVINO | FP32 | ✅ | 217.8 | 0.6894 | 68.48 |
YOLO11x | OpenVINO | INT8 | ✅ | 55.9 | 0.6417 | 49.76 |
GPU Intel® Arc
Intel® Arc™ es la línea de tarjetas gráficas discretas de Intel diseñada para juegos de alto rendimiento, creación de contenido y cargas de trabajo de IA. La serie Arc presenta arquitecturas de GPU avanzadas que admiten el trazado de rayos en tiempo real, gráficos mejorados con IA y juegos de alta resolución. Con un enfoque en el rendimiento y la eficiencia, Intel® Arc™ tiene como objetivo competir con otras marcas líderes de GPU al tiempo que proporciona características únicas como la codificación AV1 acelerada por hardware y soporte para las últimas API de gráficos.
Los benchmarks que se muestran a continuación se ejecutan en Intel Arc A770 e Intel Arc B580 con precisión FP32 e INT8.
Intel Arc A770

Resultados detallados del benchmark
Modelo | Formato | Precisión | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|---|
YOLO11n | PyTorch | FP32 | ✅ | 5.4 | 0.5072 | 16.29 |
YOLO11n | OpenVINO | FP32 | ✅ | 10.4 | 0.5073 | 6.98 |
YOLO11n | OpenVINO | INT8 | ✅ | 3.3 | 0.4978 | 7.24 |
YOLO11s | PyTorch | FP32 | ✅ | 18.4 | 0.5771 | 39.61 |
YOLO11s | OpenVINO | FP32 | ✅ | 36.4 | 0.5798 | 9.41 |
YOLO11s | OpenVINO | INT8 | ✅ | 9.8 | 0.5751 | 8.72 |
YOLO11m | PyTorch | FP32 | ✅ | 38.8 | 0.6258 | 100.65 |
YOLO11m | OpenVINO | FP32 | ✅ | 77.1 | 0.6311 | 14.88 |
YOLO11m | OpenVINO | INT8 | ✅ | 20.2 | 0.6126 | 11.97 |
YOLO11l | PyTorch | FP32 | ✅ | 49.0 | 0.6367 | 131.37 |
YOLO11l | OpenVINO | FP32 | ✅ | 97.3 | 0.6364 | 19.17 |
YOLO11l | OpenVINO | INT8 | ✅ | 25.7 | 0.6241 | 15.75 |
YOLO11x | PyTorch | FP32 | ✅ | 109.3 | 0.6990 | 212.45 |
YOLO11x | OpenVINO | FP32 | ✅ | 217.8 | 0.6888 | 18.13 |
YOLO11x | OpenVINO | INT8 | ✅ | 55.9 | 0.6930 | 18.91 |
Intel Arc B580

Resultados detallados del benchmark
Modelo | Formato | Precisión | Estado | Tamaño (MB) | métricas/mAP50-95(B) | Tiempo de inferencia (ms/im) |
---|---|---|---|---|---|---|
YOLO11n | PyTorch | FP32 | ✅ | 5.4 | 0.5072 | 16.29 |
YOLO11n | OpenVINO | FP32 | ✅ | 10.4 | 0.5072 | 4.27 |
YOLO11n | OpenVINO | INT8 | ✅ | 3.3 | 0.4981 | 4.33 |
YOLO11s | PyTorch | FP32 | ✅ | 18.4 | 0.5771 | 39.61 |
YOLO11s | OpenVINO | FP32 | ✅ | 36.4 | 0.5789 | 5.04 |
YOLO11s | OpenVINO | INT8 | ✅ | 9.8 | 0.5746 | 4.97 |
YOLO11m | PyTorch | FP32 | ✅ | 38.8 | 0.6258 | 100.65 |
YOLO11m | OpenVINO | FP32 | ✅ | 77.1 | 0.6306 | 6.45 |
YOLO11m | OpenVINO | INT8 | ✅ | 20.2 | 0.6125 | 6.28 |
YOLO11l | PyTorch | FP32 | ✅ | 49.0 | 0.6367 | 131.37 |
YOLO11l | OpenVINO | FP32 | ✅ | 97.3 | 0.6360 | 8.23 |
YOLO11l | OpenVINO | INT8 | ✅ | 25.7 | 0.6236 | 8.49 |
YOLO11x | PyTorch | FP32 | ✅ | 109.3 | 0.6990 | 212.45 |
YOLO11x | OpenVINO | FP32 | ✅ | 217.8 | 0.6889 | 11.10 |
YOLO11x | OpenVINO | INT8 | ✅ | 55.9 | 0.6924 | 10.30 |
Reproducir nuestros resultados
Para reproducir los benchmarks de Ultralytics anteriores en todos los formatos de exportación, ejecuta este código:
Ejemplo
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all export formats
results = model.benchmark(data="coco128.yaml")
# Benchmark YOLO11n speed and accuracy on the COCO128 dataset for all export formats
yolo benchmark model=yolo11n.pt data=coco128.yaml
Tenga en cuenta que los resultados de los benchmarks pueden variar según la configuración exacta de hardware y software de un sistema, así como la carga de trabajo actual del sistema en el momento en que se ejecutan los benchmarks. Para obtener los resultados más fiables, utilice un conjunto de datos con un gran número de imágenes, es decir, data='coco.yaml'
(5000 imágenes de validación).
Conclusión
Los resultados de las pruebas de referencia demuestran claramente los beneficios de exportar el modelo YOLO11 al formato OpenVINO. En diferentes modelos y plataformas de hardware, el formato OpenVINO supera constantemente a otros formatos en términos de velocidad de inferencia, manteniendo al mismo tiempo una precisión comparable.
Las pruebas de rendimiento subrayan la eficacia de OpenVINO como herramienta para implementar modelos de aprendizaje profundo. Al convertir los modelos al formato OpenVINO, los desarrolladores pueden lograr mejoras significativas en el rendimiento, lo que facilita la implementación de estos modelos en aplicaciones del mundo real.
Para obtener información más detallada e instrucciones sobre el uso de OpenVINO, consulta la documentación oficial de OpenVINO.
Preguntas frecuentes
¿Cómo exporto modelos YOLO11 a formato OpenVINO?
Exportar modelos YOLO11 al formato OpenVINO puede mejorar significativamente la velocidad de la CPU y habilitar aceleraciones de GPU y NPU en hardware de Intel. Para exportar, puedes usar Python o CLI como se muestra a continuación:
Ejemplo
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Export the model
model.export(format="openvino") # creates 'yolo11n_openvino_model/'
# Export a YOLO11n PyTorch model to OpenVINO format
yolo export model=yolo11n.pt format=openvino # creates 'yolo11n_openvino_model/'
Para más información, consulta la documentación de formatos de exportación.
¿Cuáles son los beneficios de usar OpenVINO con los modelos YOLO11?
El uso del kit de herramientas OpenVINO de Intel con modelos YOLO11 ofrece varias ventajas:
- Rendimiento: Consiga una aceleración de hasta 3 veces en la inferencia de la CPU y aproveche las GPU e NPU de Intel para la aceleración.
- Optimizador de Modelos: Convierta, optimice y ejecute modelos de frameworks populares como PyTorch, TensorFlow y ONNX.
- Facilidad de uso: Hay más de 80 cuadernos de tutoriales disponibles para ayudar a los usuarios a empezar, incluyendo algunos para YOLO11.
- Ejecución heterogénea: Implemente modelos en varios hardware de Intel con una API unificada.
Para obtener comparaciones de rendimiento detalladas, visita nuestra sección de referencias.
¿Cómo puedo ejecutar la inferencia utilizando un modelo YOLO11 exportado a OpenVINO?
Después de exportar un modelo YOLO11n a formato OpenVINO, puedes ejecutar la inferencia usando Python o CLI:
Ejemplo
from ultralytics import YOLO
# Load the exported OpenVINO model
ov_model = YOLO("yolo11n_openvino_model/")
# Run inference
results = ov_model("https://ultralytics.com/images/bus.jpg")
# Run inference with the exported model
yolo predict model=yolo11n_openvino_model source='https://ultralytics.com/images/bus.jpg'
Consulte nuestra documentación del modo predict para obtener más detalles.
¿Por qué debería elegir Ultralytics YOLO11 en lugar de otros modelos para la exportación de OpenVINO?
Ultralytics YOLO11 está optimizado para la detección de objetos en tiempo real con alta precisión y velocidad. Específicamente, cuando se combina con OpenVINO, YOLO11 proporciona:
- Aceleración de hasta 3 veces en las CPU de Intel
- Implementación perfecta en GPUs y NPUs de Intel
- Precisión consistente y comparable en varios formatos de exportación
Para un análisis de rendimiento en profundidad, consulte nuestros benchmarks detallados de YOLO11 en diferentes hardwares.
¿Puedo evaluar modelos YOLO11 en diferentes formatos como PyTorch, ONNX y OpenVINO?
Sí, puede evaluar los modelos YOLO11 en varios formatos, incluidos PyTorch, TorchScript, ONNX y OpenVINO. Utilice el siguiente fragmento de código para ejecutar evaluaciones comparativas en el conjunto de datos elegido:
Ejemplo
from ultralytics import YOLO
# Load a YOLO11n PyTorch model
model = YOLO("yolo11n.pt")
# Benchmark YOLO11n speed and [accuracy](https://www.ultralytics.com/glossary/accuracy) on the COCO8 dataset for all export formats
results = model.benchmark(data="coco8.yaml")
# Benchmark YOLO11n speed and accuracy on the COCO8 dataset for all export formats
yolo benchmark model=yolo11n.pt data=coco8.yaml
Para obtener resultados de referencia detallados, consulta nuestra sección de referencias y la documentación de formatos de exportación.