Exportación de DEEPX para modelos Ultralytics YOLO#

Implementar modelos de visión artificial en hardware NPU especializado requiere un formato de modelo compatible y optimizado. Exportar modelos Ultralytics YOLO al formato DEEPX permite realizar inferencias eficientes cuantizadas a INT8 en aceleradores NPU 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 especializada en unidades de procesamiento neuronal (NPUs) diseñadas para realizar inferencias de aprendizaje profundo en el edge con un consumo eficiente de energía. Las NPU de DEEPX están diseñadas para aplicaciones de IA integradas e industriales exigentes y ofrecen un alto rendimiento con un consumo de energía mínimo. Su hardware es ideal para escenarios de implementación en los que la conectividad a la nube no es fiable o no se desea, como la robótica, las cámaras inteligentes y los sistemas de automatización industrial.

Formato de exportación de 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 realizar la cuantización INT8 y la optimización específica para el hardware, y genera un directorio de modelo independiente listo para la 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 de la 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 las unidades de aceleración dedicadas para realizar inferencias rápidas y eficientes.
• Bajo consumo de energía: Al descargar la inferencia en la NPU, los modelos DEEPX consumen mucha menos energía que la 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 conjuntos de datos reales para minimizar la pérdida de precisión durante la cuantización.
• Salida independiente: El directorio del modelo exportado incluye el binario compilado, la configuración de calibración y los metadatos para facilitar la implementación.

Tareas compatibles#

La exportación a DEEPX es compatible con 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.

Exportar 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 el repositorio del SDK de DEEPX en la primera exportación. El flujo de trabajo de exportación actual utiliza DX-COM 2.3.0, que proporciona paquetes wheel para Python 3.8–3.12 en Linux x86-64 con glibc 2.31 o posterior.

Las versiones del compilador publicadas en PyPI se han retirado. Para preinstalar las dependencias de exportación, proporciona la página de paquetes wheel del SDK con --find-links; esto funciona tanto con pip como con uv pip:

pip install "ultralytics[export-deepx]" --find-links https://sdk.deepx.ai/release/dxcom/v2.3.0/index.html

Para instalar el repositorio en modo editable, sustituye "ultralytics[export-deepx]" por -e ".[export-base,export-deepx]". Para reproducir el entorno de Python 3.12 y la prueba rápida de exportación utilizados 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 instalación local de Ultralytics. Instala el compilador desde el origen del SDK y aplica automáticamente las restricciones de dependencias probadas.

Uso#

El formato DEEPX es compatible con los modos Export, Predict y Validate. La inferencia y la validación se ejecutan en hardware NPU DEEPX. Exporta tu modelo y, después, carga el modelo exportado para ejecutar inferencias o validar su precisión.

from ultralytics import YOLO

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

# Exporta el modelo al formato DEEPX (quantize=8 se aplica automáticamente)
model.export(format="deepx")  # creates 'yolo26n_deepx_model/'

from ultralytics import YOLO

# Carga el modelo DEEPX exportado
model = YOLO("yolo26n_deepx_model")

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

from ultralytics import YOLO

# Carga el modelo DEEPX exportado
model = YOLO("yolo26n_deepx_model")

# Validar 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 la documentación de Ultralytics sobre exportación.

Estructura de salida#

Tras una exportación correcta, se crea un directorio de 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 que utiliza el proceso de inferencia de Ultralytics.

Implementación de modelos YOLO DEEPX exportados#

Una vez que hayas exportado correctamente tu modelo Ultralytics YOLO al formato DEEPX, el siguiente paso es implementarlo en hardware NPU DEEPX.

Instalación del entorno de ejecución#

La inferencia requiere el controlador NPU de DEEPX, el entorno de ejecución libdxrt y el paquete Python dx_engine.

# Install the NPU driver and libdxrt runtime
sudo apt update
wget https://github.com/DEEPX-AI/dx_rt_npu_linux_driver/raw/main/release/2.4.1/dxrt-driver-dkms_2.4.1-2_all.deb
sudo apt install ./dxrt-driver-dkms_2.4.1-2_all.deb
wget https://github.com/DEEPX-AI/dx_rt/raw/main/release/3.3.2/libdxrt_3.3.2_all.deb
sudo apt install ./libdxrt_3.3.2_all.deb

# Create dx-engine wheel
cd /usr/share/libdxrt/python_package && sudo ./make_whl.sh

# Install the bundled dx_engine Python wheel
pip install dx_engine-*.whl

Comprueba que el entorno de ejecución se haya instalado correctamente con dxrt-cli --version. Deberías ver un resultado similar a:

DXRT v3.3.2
Minimum Driver Versions
Device Driver: v2.4.0
PCIe Driver: v2.2.0
Firmware: v2.5.2
Minimum Compiler Versions
Compiler: v1.18.1
.dxnn File Format: v6

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

Visualización con dxtron#

dxtron es el visualizador de grafos de DEEPX para inspeccionar el modelo .dxnn compilado.

Instala dxtron en Linux x86-64 descargando el paquete .deb del SDK de DEEPX e instalándolo con dpkg:

wget https://sdk.deepx.ai/release/dxtron/v2.0.1/dxtron_2.0.1_amd64.deb
sudo dpkg -i dxtron_2.0.1_amd64.deb

A continuación, abre el modelo exportado:

dxtron yolo26n_deepx_model/yolo26n.dxnn

Benchmarks#

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

Rendimiento

Raspberry Pi 5 + módulo DX-M1 M.2¡Próximamente 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 evaluaciones anteriores se realizó con COCO128 para detección, COCO128-seg para segmentación, COCO8-pose para estimación de pose, ImageNet100 para clasificación 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 de entrenamiento de Ultralytics
2. Exporta al formato DEEPX con model.export(format="deepx")
3. Valida la precisión con yolo val para verificar que la pérdida por cuantización sea mínima
4. Realiza predicciones con yolo predict para la validación cualitativa
5. Implementa el directorio _deepx_model/ exportado en hardware NPU DEEPX con el entorno de ejecución dx_engine

Aplicaciones en el mundo real#

Los modelos YOLO implementados en hardware NPU DEEPX son ideales para una amplia gama de aplicaciones de IA en el edge:

• Vigilancia inteligente: Detección de objetos en tiempo real para sistemas de seguridad y supervisión, con bajo consumo de energía 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 del estado de los cultivos, detección de plagas y estimación del rendimiento mediante visión artificial en 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 tiempo real en el edge.

Resumen#

En esta guía has aprendido a exportar modelos Ultralytics YOLO al formato DEEPX e implementarlos en hardware NPU DEEPX. El proceso de exportación utiliza la 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 gestiona la inferencia en el dispositivo.

La combinación de Ultralytics YOLO y la tecnología NPU de DEEPX ofrece una solución eficaz para ejecutar cargas de trabajo avanzadas de visión artificial en dispositivos integrados y edge, con un alto rendimiento y un bajo consumo de energía para aplicaciones en tiempo real.

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

Además, si quieres saber más sobre otras integraciones de Ultralytics YOLO, visita nuestra página de guías de integración. Allí encontrarás muchos recursos e información útiles.

Preguntas frecuentes#