Saltar al contenido

Intel OpenVINO Exportar

OpenVINO Ecosistema

En esta guía, cubrimos la exportación de modelos de YOLOv8 al formato OpenVINO que puede proporcionar hasta 3 veces más velocidad CPU de velocidad, así como la aceleración de la inferencia de YOLO en Intel GPU y hardware NPU.

OpenVINO, abreviatura de Open Visual Inference & Neural Network Optimization toolkit, es un completo conjunto de herramientas para optimizar y desplegar modelos de inferencia de IA. Aunque el nombre contiene Visual, OpenVINO también admite varias tareas adicionales, como lenguaje, audio, series temporales, etc.



Observa: Cómo exportar y optimizar un modelo Ultralytics YOLOv8 para inferirlo con OpenVINO.

Ejemplos de uso

Exporta un modelo YOLOv8n al formato OpenVINO y ejecuta la inferencia con el modelo exportado.

Ejemplo

from ultralytics import YOLO

# 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
ov_model = YOLO("yolov8n_openvino_model/")

# Run inference
results = ov_model("https://ultralytics.com/images/bus.jpg")
# Export a YOLOv8n PyTorch model to OpenVINO format
yolo export model=yolov8n.pt format=openvino  # creates 'yolov8n_openvino_model/'

# Run inference with the exported model
yolo predict model=yolov8n_openvino_model source='https://ultralytics.com/images/bus.jpg'

Argumentos

Clave Valor Descripción
format 'openvino' formato al que exportar
imgsz 640 tamaño de la imagen como escalar o lista (h, w), por ejemplo (640, 480)
half False Cuantificación FP16

Beneficios de OpenVINO

  1. Rendimiento: OpenVINO ofrece una inferencia de alto rendimiento utilizando la potencia de las CPU de Intel , las GPU integradas y discretas y las FPGA.
  2. Soporte para ejecución heterogénea: OpenVINO proporciona una API para escribir una vez y desplegar en cualquier hardware compatible con Intel (CPU, GPU, FPGA, VPU, etc.).
  3. Optimizador de modelos: OpenVINO proporciona un optimizador de modelos que importa, convierte y optimiza modelos de marcos de aprendizaje profundo populares como PyTorch, TensorFlow, TensorFlow Lite, Keras, ONNX, PaddlePaddle, y Caffe.
  4. Facilidad de uso: El kit de herramientas viene con más de 80 cuadernos tutoriales (incluida la optimizaciónYOLOv8 ) que enseñan diferentes aspectos del kit de herramientas.

OpenVINO Estructura de exportación

Cuando exportas un modelo al formato OpenVINO , el resultado es un directorio que contiene lo siguiente:

  1. Archivo XML: Describe la topología de la red.
  2. Archivo BIN: Contiene los datos binarios de weights and biases .
  3. Archivo de mapeo: Contiene la correspondencia de los tensores de salida del modelo original con los nombres de OpenVINO tensor .

Puedes utilizar estos archivos para ejecutar la inferencia con el motor de inferencia de OpenVINO .

Utilizar la exportación OpenVINO en la implantación

Una vez que tengas los archivos OpenVINO , puedes utilizar el Runtime OpenVINO para ejecutar el modelo. El Runtime proporciona una API unificada para la inferencia en todo el hardware Intel compatible. También proporciona funciones avanzadas como el equilibrio de carga en todo el hardware Intel y la ejecución asíncrona. Para más información sobre la ejecución de la inferencia, consulta la Guía de Inferencia con el Tiempo de Ejecución OpenVINO .

Recuerda que necesitarás los archivos XML y BIN, así como los ajustes específicos de la aplicación, como el tamaño de la entrada, el factor de escala para la normalización, etc., para configurar y utilizar correctamente el modelo con el Runtime.

En tu aplicación de despliegue, normalmente harías los siguientes pasos:

  1. Inicializa OpenVINO creando core = Core().
  2. Carga el modelo utilizando la función core.read_model() método.
  3. Compila el modelo utilizando la función core.compile_model() función.
  4. Prepara la entrada (imagen, texto, audio, etc.).
  5. Ejecuta la inferencia utilizando compiled_model(input_data).

Para pasos más detallados y fragmentos de código, consulta la documentación deOpenVINO o el tutorial de la API.

OpenVINO YOLOv8 Puntos de referencia

YOLOv8 El equipo de Ultralytics ejecutó las siguientes pruebas de rendimiento en 4 formatos de modelo diferentes, midiendo la velocidad y la precisión: PyTorch, TorchScript, ONNX y OpenVINO. Las pruebas se ejecutaron en las GPU Flex y Arc de Intel , y en las CPU Xeon de Intel con precisión FP32 (con la función half=False argumento).

Nota

Los resultados de las pruebas comparativas que se muestran a continuación son de referencia y pueden variar en función de la configuración exacta de hardware y software de un sistema, así como de la carga de trabajo actual del sistema en el momento de ejecutar las pruebas comparativas.

Todas las pruebas se ejecutan con openvino Python versión del paquete 2023.0.1.

Intel Flex GPU

La serie Intel® Data Center GPU Flex es una solución versátil y robusta diseñada para la nube visual inteligente. Este GPU admite una amplia gama de cargas de trabajo, como streaming multimedia, juegos en la nube, inferencia visual de IA y cargas de trabajo de infraestructura de escritorio virtual. Destaca por su arquitectura abierta y su compatibilidad integrada con la codificación AV1, que proporciona una pila de software basada en estándares para aplicaciones de alto rendimiento y arquitectura cruzada. La serie Flex GPU está optimizada para la densidad y la calidad, y ofrece alta fiabilidad, disponibilidad y escalabilidad.

Las siguientes pruebas se ejecutan en Intel® Data Center GPU Flex 170 con precisión FP32.

Puntos de referencia de Flex GPU
Modelo Formato Estado Tamaño (MB) mAP50-95(B) Tiempo de inferencia (ms/im)
YOLOv8n PyTorch 6.2 0.3709 21.79
YOLOv8n TorchScript 12.4 0.3704 23.24
YOLOv8n ONNX 12.2 0.3704 37.22
YOLOv8n OpenVINO 12.3 0.3703 3.29
YOLOv8s PyTorch 21.5 0.4471 31.89
YOLOv8s TorchScript 42.9 0.4472 32.71
YOLOv8s ONNX 42.8 0.4472 43.42
YOLOv8s OpenVINO 42.9 0.4470 3.92
YOLOv8m PyTorch 49.7 0.5013 50.75
YOLOv8m TorchScript 99.2 0.4999 47.90
YOLOv8m ONNX 99.0 0.4999 63.16
YOLOv8m OpenVINO 49.8 0.4997 7.11
YOLOv8l PyTorch 83.7 0.5293 77.45
YOLOv8l TorchScript 167.2 0.5268 85.71
YOLOv8l ONNX 166.8 0.5268 88.94
YOLOv8l OpenVINO 167.0 0.5264 9.37
YOLOv8x PyTorch 130.5 0.5404 100.09
YOLOv8x TorchScript 260.7 0.5371 114.64
YOLOv8x ONNX 260.4 0.5371 110.32
YOLOv8x OpenVINO 260.6 0.5367 15.02

Esta tabla representa los resultados de referencia de cinco modelos diferentes (YOLOv8n, YOLOv8s, YOLOv8m, YOLOv8l, YOLOv8x) en cuatro formatos distintos (PyTorch, TorchScript, ONNX, OpenVINO), dándonos el estado, el tamaño, la métrica mAP50-95(B) y el tiempo de inferencia de cada combinación.

Intel Arco GPU

Intel® Arc™ representa la incursión de Intel en el mercado dedicado de GPU . La serie Arc™, diseñada para competir con los principales fabricantes de GPU como AMD y Nvidia, se dirige tanto al mercado de los portátiles como al de los ordenadores de sobremesa. La serie incluye versiones móviles para dispositivos compactos como los portátiles, y versiones más grandes y potentes para ordenadores de sobremesa.

La serie Arc™ se divide en tres categorías: Arc™ 3, Arc™ 5 y Arc™ 7, y cada número indica el nivel de rendimiento. Cada categoría incluye varios modelos, y la "M" en el nombre del modelo GPU significa una variante móvil e integrada.

Las primeras críticas han elogiado la serie Arc™, en particular el A770M GPU integrado, por su impresionante rendimiento gráfico. La disponibilidad de la serie Arc™ varía según la región, y se espera que pronto se lancen modelos adicionales. Las GPU Intel® Arc™ ofrecen soluciones de alto rendimiento para una amplia gama de necesidades informáticas, desde los juegos hasta la creación de contenidos.

Las siguientes pruebas se ejecutan en Intel® Arc 770 GPU con precisión FP32.

Arco GPU puntos de referencia
Modelo Formato Estado Tamaño (MB) métrica/mAP50-95(B) Tiempo de inferencia (ms/im)
YOLOv8n PyTorch 6.2 0.3709 88.79
YOLOv8n TorchScript 12.4 0.3704 102.66
YOLOv8n ONNX 12.2 0.3704 57.98
YOLOv8n OpenVINO 12.3 0.3703 8.52
YOLOv8s PyTorch 21.5 0.4471 189.83
YOLOv8s TorchScript 42.9 0.4472 227.58
YOLOv8s ONNX 42.7 0.4472 142.03
YOLOv8s OpenVINO 42.9 0.4469 9.19
YOLOv8m PyTorch 49.7 0.5013 411.64
YOLOv8m TorchScript 99.2 0.4999 517.12
YOLOv8m ONNX 98.9 0.4999 298.68
YOLOv8m OpenVINO 99.1 0.4996 12.55
YOLOv8l PyTorch 83.7 0.5293 725.73
YOLOv8l TorchScript 167.1 0.5268 892.83
YOLOv8l ONNX 166.8 0.5268 576.11
YOLOv8l OpenVINO 167.0 0.5262 17.62
YOLOv8x PyTorch 130.5 0.5404 988.92
YOLOv8x TorchScript 260.7 0.5371 1186.42
YOLOv8x ONNX 260.4 0.5371 768.90
YOLOv8x OpenVINO 260.6 0.5367 19

Intel Xeon CPU

El Intel® Xeon® CPU es un procesador de alto rendimiento para servidores diseñado para cargas de trabajo complejas y exigentes. Desde la informática en la nube de gama alta y la virtualización hasta la inteligencia artificial y las aplicaciones de aprendizaje automático, las CPU Xeon® proporcionan la potencia, fiabilidad y flexibilidad necesarias para los centros de datos actuales.

En particular, las CPU Xeon® ofrecen una alta densidad y escalabilidad informática, lo que las hace ideales tanto para pequeñas empresas como para grandes compañías. Al elegir las CPU Intel® Xeon®, las organizaciones pueden gestionar con confianza sus tareas informáticas más exigentes y fomentar la innovación, manteniendo al mismo tiempo la rentabilidad y la eficiencia operativa.

Las siguientes pruebas se ejecutan en Intel® Xeon® Scalable de 4ª generación CPU con precisión FP32.

Puntos de referencia Xeon CPU
Modelo Formato Estado Tamaño (MB) métrica/mAP50-95(B) Tiempo de inferencia (ms/im)
YOLOv8n PyTorch 6.2 0.3709 24.36
YOLOv8n TorchScript 12.4 0.3704 23.93
YOLOv8n ONNX 12.2 0.3704 39.86
YOLOv8n OpenVINO 12.3 0.3704 11.34
YOLOv8s PyTorch 21.5 0.4471 33.77
YOLOv8s TorchScript 42.9 0.4472 34.84
YOLOv8s ONNX 42.8 0.4472 43.23
YOLOv8s OpenVINO 42.9 0.4471 13.86
YOLOv8m PyTorch 49.7 0.5013 53.91
YOLOv8m TorchScript 99.2 0.4999 53.51
YOLOv8m ONNX 99.0 0.4999 64.16
YOLOv8m OpenVINO 99.1 0.4996 28.79
YOLOv8l PyTorch 83.7 0.5293 75.78
YOLOv8l TorchScript 167.2 0.5268 79.13
YOLOv8l ONNX 166.8 0.5268 88.45
YOLOv8l OpenVINO 167.0 0.5263 56.23
YOLOv8x PyTorch 130.5 0.5404 96.60
YOLOv8x TorchScript 260.7 0.5371 114.28
YOLOv8x ONNX 260.4 0.5371 111.02
YOLOv8x OpenVINO 260.6 0.5371 83.28

Intel Núcleo CPU

La serie Intel® Core® es una gama de procesadores de alto rendimiento de Intel. La gama incluye Core i3 (gama básica), Core i5 (gama media), Core i7 (gama alta) y Core i9 (rendimiento extremo). Cada serie satisface diferentes necesidades informáticas y presupuestos, desde las tareas cotidianas hasta las cargas de trabajo profesionales más exigentes. Con cada nueva generación, se introducen mejoras en el rendimiento, la eficiencia energética y las prestaciones.

Las siguientes pruebas se ejecutan en un Intel® Core® i7-13700H de 13ª generación CPU con precisión FP32.

Puntos de referencia Core CPU
Modelo Formato Estado Tamaño (MB) métrica/mAP50-95(B) Tiempo de inferencia (ms/im)
YOLOv8n PyTorch 6.2 0.4478 104.61
YOLOv8n TorchScript 12.4 0.4525 112.39
YOLOv8n ONNX 12.2 0.4525 28.02
YOLOv8n OpenVINO 12.3 0.4504 23.53
YOLOv8s PyTorch 21.5 0.5885 194.83
YOLOv8s TorchScript 43.0 0.5962 202.01
YOLOv8s ONNX 42.8 0.5962 65.74
YOLOv8s OpenVINO 42.9 0.5966 38.66
YOLOv8m PyTorch 49.7 0.6101 355.23
YOLOv8m TorchScript 99.2 0.6120 424.78
YOLOv8m ONNX 99.0 0.6120 173.39
YOLOv8m OpenVINO 99.1 0.6091 69.80
YOLOv8l PyTorch 83.7 0.6591 593.00
YOLOv8l TorchScript 167.2 0.6580 697.54
YOLOv8l ONNX 166.8 0.6580 342.15
YOLOv8l OpenVINO 167.0 0.0708 117.69
YOLOv8x PyTorch 130.5 0.6651 804.65
YOLOv8x TorchScript 260.8 0.6650 921.46
YOLOv8x ONNX 260.4 0.6650 526.66
YOLOv8x OpenVINO 260.6 0.6619 158.73

Reproducir nuestros resultados

Para reproducir las pruebas anteriores de Ultralytics en todos los formatos de exportación, ejecuta este código:

Ejemplo

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
results = model.benchmarks(data="coco8.yaml")
# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all all export formats
yolo benchmark model=yolov8n.pt data=coco8.yaml

Ten en cuenta que los resultados de las pruebas comparativas pueden variar en función de la configuración exacta de hardware y software de un sistema, así como de la carga de trabajo actual del sistema en el momento de ejecutar las pruebas comparativas. Para obtener resultados más fiables, utiliza un conjunto de datos con un gran número de imágenes, es decir data='coco128.yaml' (128 val images), ordata='coco.yaml'` (5000 imágenes val).

Conclusión

Los resultados de las pruebas comparativas demuestran claramente las ventajas de exportar el modelo YOLOv8 al formato OpenVINO . En diferentes modelos y plataformas de hardware, el formato OpenVINO supera sistemáticamente a los demás formatos en cuanto a velocidad de inferencia, manteniendo una precisión comparable.

En la serie Intel® Data Center GPU Flex, el formato OpenVINO fue capaz de ofrecer velocidades de inferencia casi 10 veces más rápidas que el formato original PyTorch . En el Xeon CPU, el formato OpenVINO fue dos veces más rápido que el formato PyTorch . La precisión de los modelos se mantuvo casi idéntica en los distintos formatos.

Las pruebas comparativas subrayan la eficacia de OpenVINO como herramienta para desplegar modelos de aprendizaje profundo. Al convertir los modelos al formato OpenVINO , los desarrolladores pueden conseguir importantes mejoras de rendimiento, lo que facilita el despliegue 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 los modelos de YOLOv8 al formato OpenVINO ?

Exportar modelos YOLOv8 al formato OpenVINO puede mejorar significativamente la velocidad CPU y permitir aceleraciones GPU y NPU en el hardware Intel . Para exportar, puedes utilizar Python o CLI , como se muestra a continuación:

Ejemplo

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Export the model
model.export(format="openvino")  # creates 'yolov8n_openvino_model/'
# Export a YOLOv8n PyTorch model to OpenVINO format
yolo export model=yolov8n.pt format=openvino  # creates 'yolov8n_openvino_model/'

Para más información, consulta la documentación sobre formatos de exportación.

¿Cuáles son las ventajas de utilizar OpenVINO con los modelos YOLOv8 ?

Utilizar el conjunto de herramientas Intel's OpenVINO con los modelos YOLOv8 ofrece varias ventajas:

  1. Rendimiento: Consigue hasta 3 veces más velocidad en la inferencia CPU y aprovecha las GPU y NPU de Intel para la aceleración.
  2. Optimizador de modelos: Convierte, optimiza y ejecuta modelos de marcos populares como PyTorch, TensorFlow y ONNX.
  3. Facilidad de uso: Hay más de 80 cuadernos de tutoriales disponibles para ayudar a los usuarios a empezar, incluidos algunos para YOLOv8.
  4. Ejecución heterogénea: Despliega modelos en diversos equipos Intel con una API unificada.

Para ver comparaciones de rendimiento detalladas, visita nuestra sección de puntos de referencia.

¿Cómo puedo ejecutar la inferencia utilizando un modelo YOLOv8 exportado a OpenVINO?

Después de exportar un modelo YOLOv8 al formato OpenVINO , puedes ejecutar la inferencia utilizando Python o CLI:

Ejemplo

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")
# Run inference with the exported model
yolo predict model=yolov8n_openvino_model source='https://ultralytics.com/images/bus.jpg'

Consulta nuestra documentación sobre el modo predecir para obtener más detalles.

¿Por qué debería elegir Ultralytics YOLOv8 en lugar de otros modelos para la exportación OpenVINO ?

Ultralytics YOLOv8 está optimizado para la detección de objetos en tiempo real con gran precisión y velocidad. En concreto, cuando se combina con OpenVINO, YOLOv8 proporciona:

  • Hasta 3 veces más velocidad en CPUs Intel
  • Implementación sin problemas en GPUs y NPUs Intel
  • Precisión coherente y comparable en varios formatos de exportación

Para un análisis en profundidad del rendimiento, consulta nuestros detallados puntos de referenciaYOLOv8 en diferentes equipos.

¿Puedo comparar los modelos YOLOv8 en diferentes formatos como PyTorch, ONNX, y OpenVINO?

Sí, puedes realizar pruebas de rendimiento con modelos YOLOv8 en varios formatos, como PyTorch, TorchScript, ONNX y OpenVINO. Utiliza el siguiente fragmento de código para ejecutar pruebas comparativas en el conjunto de datos que elijas:

Ejemplo

from ultralytics import YOLO

# Load a YOLOv8n PyTorch model
model = YOLO("yolov8n.pt")

# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all export formats
results = model.benchmarks(data="coco8.yaml")
# Benchmark YOLOv8n speed and accuracy on the COCO8 dataset for all export formats
yolo benchmark model=yolov8n.pt data=coco8.yaml

Para obtener resultados detallados de las pruebas comparativas, consulta nuestra sección de pruebas comparativas y la documentación sobre formatos de exportación.



Creado 2023-11-12, Actualizado 2024-07-05
Autores: glenn-jocher (14), andrei-kochin (1), abirami-vina (1), RizwanMunawar (1), Burhan-Q (1)

Comentarios