Exportación DEEPX para modelos Ultralytics YOLO

La implementación de modelos de visión artificial en hardware NPU especializado requiere un formato de modelo compatible y optimizado. Exportar modelos de Ultralytics YOLO al formato DEEPX permite realizar inferencias eficientes con cuantización INT8 en aceleradores NPU de DEEPX. Esta guía te explica cómo convertir tus modelos YOLO al formato DEEPX e implementarlos en hardware con DEEPX.

¿Qué es DEEPX?#

DEEPX es una empresa de semiconductores de IA y socio de Ultralytics especializada en unidades de procesamiento neuronal (NPUs) diseñadas para realizar inferencias de aprendizaje profundo en el perímetro con un consumo energético eficiente. Las NPU de DEEPX están diseñadas para aplicaciones de IA exigentes en sistemas integrados e industriales, y ofrecen un alto rendimiento con un consumo mínimo. Su hardware es idóneo para implementaciones en las que la conexión a la nube no es fiable o no resulta conveniente, como la robótica, las cámaras inteligentes y los sistemas de automatización industrial.

Formato de exportación DEEPX#

La exportación a DEEPX genera un binario de modelo .dxnn compilado y optimizado para ejecutarse en hardware NPU DEEPX. El proceso de compilación utiliza el kit de herramientas dx_com para aplicar cuantización INT8 y optimizaciones específicas del hardware, y genera un directorio de modelo autónomo listo para su implementación.

Características principales de los modelos DEEPX#

Los modelos DEEPX ofrecen varias ventajas para la implementación en el edge:

• Cuantización INT8: los modelos se cuantizan a precisión INT8 durante la exportación, lo que reduce considerablemente su tamaño y maximiza el rendimiento del NPU. Obtén más información sobre la cuantización de modelos.
• Optimizado para NPU: el formato .dxnn se compila específicamente para hardware NPU DEEPX y aprovecha unidades de aceleración dedicadas para realizar inferencias rápidas y eficientes.
• Bajo consumo: al delegar la inferencia en el NPU, los modelos DEEPX consumen mucha menos energía que una inferencia equivalente en CPU o GPU.
• Precisión basada en calibración: La exportación utiliza una calibración basada en EMA con imágenes de un conjunto de datos real para minimizar la pérdida de precisión durante la cuantización.
• Salida autónoma: El directorio del modelo exportado incluye el binario compilado, la configuración de calibración y los metadatos para facilitar el despliegue.

Tareas compatibles#

La exportación a DEEPX admite las siete tareas de Ultralytics. La segmentación semántica y la estimación de profundidad solo están disponibles con YOLO26, la única familia que incluye esos cabezales.

Exportación a DEEPX: convertir tu modelo YOLO#

Exporta un modelo Ultralytics YOLO al formato DEEPX y ejecuta inferencias con el modelo exportado.

Instalación#

Para instalar los paquetes necesarios, ejecuta:

# Install the required package for YOLO
pip install ultralytics

El compilador dx_com se instala automáticamente desde PyPI durante la primera exportación. DX-COM 2.5.0 proporciona paquetes wheel para Python 3.8–3.14 en Linux x86-64 con glibc 2.31 o posterior y requiere al menos 16 GB de RAM. Para preinstalar las dependencias de exportación:

pip install "ultralytics[export-deepx]"

Para instalar el repositorio en modo editable, sustituye "ultralytics[export-deepx]" por -e ".[export-base,export-deepx]". Para reproducir el entorno de Python 3.14 y la exportación de prueba usados por CI, ejecuta el generador de entornos existente desde la raíz del repositorio:

ULTRALYTICS_ISOLATED_VENVS="$PWD/.venvs" python .github/scripts/create-export-env.py --env isolated-deepx

El generador de entornos requiere uv y una copia de trabajo de Ultralytics instalada. Aplica automáticamente las restricciones de dependencias probadas.

Uso#

El formato DEEPX admite los modos Exportar, Predecir y Validar. La inferencia y la validación se ejecutan en hardware NPU de DEEPX. Exporta el modelo y, a continuación, carga el modelo exportado para ejecutar inferencias o validar su precisión.

from ultralytics import YOLO

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

# Export the model to DEEPX format (quantize=8 is enforced automatically)
model.export(format="deepx")  # creates 'yolo26n_deepx_model/'

from ultralytics import YOLO

# Load the exported DEEPX model
model = YOLO("yolo26n_deepx_model")

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

from ultralytics import YOLO

# Load the exported DEEPX model
model = YOLO("yolo26n_deepx_model")

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

Argumentos de exportación#

Para obtener más información sobre el proceso de exportación, visita la página de documentación de Ultralytics sobre exportación.

Estructura de salida#

Tras una exportación correcta, se crea un directorio del modelo con la siguiente estructura:

yolo26n_deepx_model/
├── yolo26n.dxnn     # Compiled DEEPX model binary (NPU executable)
├── config.json      # Calibration and preprocessing configuration
└── metadata.yaml    # Model metadata (classes, image size, task, etc.)

El archivo .dxnn es el binario del modelo compilado que el entorno de ejecución dx_engine carga directamente en la NPU. metadata.yaml contiene los nombres de las clases, el tamaño de imagen y otra información utilizada por el proceso de inferencia de Ultralytics.

Despliegue de modelos YOLO DEEPX exportados#

Cuando hayas exportado correctamente tu modelo Ultralytics YOLO al formato DEEPX, el siguiente paso es desplegar estos modelos en hardware NPU de DEEPX.

Instalación del entorno de ejecución#

La inferencia requiere el controlador NPU de DEEPX (v2.7.0 o posterior), el entorno de ejecución DX-RT (v3.5.0 o posterior), el firmware NPU v2.7.6 o posterior y el paquete Python dx_engine. Estas son las versiones necesarias para ejecutar modelos compilados con DX-COM 2.5.0.

Instala el controlador NPU y el paquete del entorno de ejecución libdxrt-bin con una de las siguientes opciones.

Opción A: instalar desde los paquetes de versiones de GitHub#

Descarga los paquetes .deb del controlador y del entorno de ejecución desde los repositorios de DEEPX-AI en GitHub e instálalos. El paquete del entorno de ejecución se proporciona para cada arquitectura de CPU (amd64 o arm64):

# Install the NPU driver and DX-RT runtime
sudo apt update
wget https://github.com/DEEPX-AI/dx_rt_npu_linux_driver/raw/main/release/2.7.0/dxrt-driver-dkms_2.7.0-2_all.deb
sudo apt install ./dxrt-driver-dkms_2.7.0-2_all.deb
wget https://github.com/DEEPX-AI/dx_rt/raw/main/release/3.5.0/libdxrt-bin_3.5.0_$(dpkg --print-architecture).deb
sudo apt install ./libdxrt-bin_3.5.0_$(dpkg --print-architecture).deb

Opción B: instalar desde el repositorio apt de DEEPX#

Registra una vez el repositorio apt de DEEPX y, después, instala y actualiza el controlador y el entorno de ejecución con apt:

# Add the DEEPX apt repository
wget -O - https://apt.releases.deepx.ai/gpg | sudo gpg --dearmor -o /usr/share/keyrings/deepx-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/deepx-archive-keyring.gpg] https://apt.releases.deepx.ai $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") main" | sudo tee /etc/apt/sources.list.d/deepx.list

# Install the NPU driver and DX-RT runtime
sudo apt update
sudo apt install dxrt-driver-dkms libdxrt-bin

Reinicia el host después de instalar el controlador para que se cargue el nuevo módulo del kernel antes de ejecutar dxcli.

Paquete Python y firmware#

libdxrt-bin incluye paquetes wheel de dx_engine para Python 3.8–3.14 en /usr/share/libdxrt-bin/python/, pero no los instala. En el entorno donde están instalados Ultralytics y NumPy, instala el paquete wheel que corresponda a tu versión de Python:

python -m pip install --upgrade --no-index --find-links /usr/share/libdxrt-bin/python dx_engine

DX-RT 3.5.0 requiere firmware NPU v2.7.6 o posterior. Comprueba la versión del firmware y el ID del dispositivo con dxcli -s y, si es anterior, actualízalo con la imagen de firmware correspondiente a tu módulo. Los módulos DX-M1 y DX-M1M M.2 usan imágenes de firmware distintas, así que descarga solo la que corresponda a tu módulo; dxcli -s indica el módulo como M1 o M1M en la información del dispositivo:

# Download the firmware image matching your module (DX-M1 shown)
wget -O dx-m1-2.7.6.bin https://github.com/DEEPX-AI/dx_fw/raw/main/m1/2.7.6/mdot2/fw.bin
# wget -O dx-m1m-2.7.6.bin https://github.com/DEEPX-AI/dx_fw/raw/main/m1m/2.7.6/mdot2/fw.bin # DX-M1M

# Update the selected device; replace DEVICE_ID with its ID from dxcli -s
sudo systemctl stop dxrt.service
dxcli -d DEVICE_ID -u dx-m1-2.7.6.bin # for DX-M1M use dx-m1m-2.7.6.bin instead

Después de instalar el firmware, apaga completamente el host y vuelve a encenderlo antes de comprobar la versión del firmware. Si no es posible desconectar físicamente la alimentación, reinicia el host tal como se describe en la guía de resolución de problemas de DEEPX.

Verifica la instalación con dxcli -s, que muestra las versiones del entorno de ejecución, el controlador y el firmware de cada dispositivo. import dx_engine genera un error RuntimeError si las versiones del paquete wheel dx_engine y del entorno de ejecución libdxrt instalado no coinciden, así que vuelve a instalar el paquete wheel desde /usr/share/libdxrt-bin/python/ después de actualizar el entorno de ejecución.

Una vez instalado el entorno de ejecución, ejecuta inferencias y validaciones en tu dispositivo DEEPX exactamente como se muestra en la sección Uso anterior: el _deepx_model exportado se carga directamente con YOLO(...).

Inspección del modelo compilado#

DX-COM 2.5.0 sustituye el visualizador de grafos DX-TRON por un informe interactivo de compilación en HTML que muestra la estructura del modelo compilado y el reparto de la carga de trabajo entre CPU y NPU. Si lo necesitas, genéralo recompilando el modelo ONNX intermedio escrito durante la exportación con la CLI dxcom en el host de exportación x86-64:

dxcom -m yolo26n.onnx -c yolo26n_deepx_model/config.json -o yolo26n_deepx_report --export_html

Abre yolo26n_deepx_report/yolo26n_summary.html en un navegador para ver el informe.

Pruebas de rendimiento#

El equipo de Ultralytics comparó la velocidad y la precisión de los modelos YOLO26 en PyTorch y DEEPX.

Rendimiento

Raspberry Pi 5 + módulo DX-M1 M.2¡Pronto habrá más dispositivos!

Modelo	Formato	Estado	Tamaño (MB)	metrics/mAP50-95(B)	Tiempo de inferencia (ms/im)
YOLO26n	PyTorch	✅	5.3	0.4760	315.2
YOLO26n	DEEPX	✅	6.6	0.4660	34.6
YOLO26n-seg	PyTorch	✅	6.5	0.4080	485.4
YOLO26n-seg	DEEPX	✅	7.9	0.3920	53.8
YOLO26n-pose	PyTorch	✅	7.6	0.4230	506.3
YOLO26n-pose	DEEPX	✅	8.8	0.4590	37.6
YOLO26n-obb	PyTorch	✅	5.7	0.817	1094.4
YOLO26n-obb	DEEPX	✅	7.3	0.783	56.4

Modelo	Formato	Estado	Tamaño (MB)	precisión (top1)	precisión (top5)	Tiempo de inferencia (ms/im)
YOLO26n-cls	PyTorch	✅	5.6	0.431	0.716	23.8
YOLO26n-cls	DEEPX	✅	5.9	0.333	0.686	2.7

Nota

La validación de las pruebas comparativas anteriores se realizó con COCO128 para detección, COCO128-seg para segmentación, ImageNet100 para clasificación, COCO8-pose para estimación de pose y DOTA128 para modelos OBB. El tiempo de inferencia no incluye el preprocesamiento ni el posprocesamiento.

sudo nano /boot/firmware/config.txt

dtparam=pciex1
dtparam=pciex1_gen=3

sudo reboot

sudo lspci -vvv | grep -iA 33 accelerators | grep -E "LnkCap|LnkSta"

Flujo de trabajo recomendado#

1. Entrena tu modelo con el modo Train de Ultralytics
2. Exporta al formato DEEPX con model.export(format="deepx")
3. Valida la precisión con yolo val para comprobar que la pérdida por cuantización es mínima
4. Predice con yolo predict para realizar una validación cualitativa
5. Despliega el directorio _deepx_model/ exportado en hardware NPU de DEEPX con el entorno de ejecución dx_engine

Aplicaciones en el mundo real#

Los modelos YOLO desplegados en hardware NPU de DEEPX son ideales para una amplia variedad de aplicaciones de IA en el borde:

• Vigilancia inteligente: Detección de objetos en tiempo real para sistemas de seguridad y supervisión, con un bajo consumo energético y sin depender de la nube.
• Automatización industrial: Control de calidad en el dispositivo, detección de defectos y supervisión de procesos en entornos de fábrica.
• Robótica: Navegación basada en visión, evitación de obstáculos y reconocimiento de objetos en robots autónomos y drones.
• Agricultura inteligente: Supervisión de la salud de los cultivos, detección de plagas y estimación del rendimiento mediante visión artificial aplicada a la agricultura.
• Analítica para el comercio minorista: Análisis del flujo de clientes, supervisión de estanterías y seguimiento del inventario con inferencia en el borde en tiempo real.

Resumen#

En esta guía has aprendido a exportar modelos Ultralytics YOLO al formato DEEPX y a desplegarlos en hardware NPU de DEEPX. El proceso de exportación utiliza calibración INT8 y el compilador dx_com para generar un binario .dxnn optimizado para el hardware, mientras que el entorno de ejecución dx_engine se encarga de la inferencia en el dispositivo.

Juntos, Ultralytics YOLO y las NPU de DEEPX ejecutan cargas de trabajo de visión artificial en dispositivos integrados y perimetrales con alto rendimiento y bajo consumo, para aplicaciones en tiempo real.

Para obtener más información sobre el uso, visita el sitio web oficial de DEEPX.

Preguntas frecuentes#