Link to this sectionExportación DEEPX para modelos YOLO de Ultralytics#

Desplegar 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 una inferencia eficiente cuantizada a INT8 en aceleradores NPU de DEEPX. Esta guía te explica cómo convertir tus modelos YOLO al formato DEEPX y desplegarlos en hardware con tecnología DEEPX.

Link to this section¿Qué es DEEPX?#

DEEPX es una empresa de semiconductores de IA especializada en unidades de procesamiento neuronal (NPU) diseñadas para una inferencia de deep learning energéticamente eficiente en el borde. Las NPU de DEEPX están diseñadas para aplicaciones de IA embebidas e industriales exigentes, ofreciendo un alto rendimiento con un consumo de energía mínimo. Su hardware es muy adecuado para escenarios de implementación donde la conectividad a la nube no es fiable o no es deseable, como en robótica, cámaras inteligentes y sistemas de automatización industrial.

Link to this sectionFormato de exportación DEEPX#

La exportación DEEPX genera un binario de modelo .dxnn compilado que está optimizado para su ejecución en hardware NPU de DEEPX. El proceso de compilación utiliza el kit de herramientas dx_com para realizar la cuantización a INT8 y la optimización específica del hardware, generando un directorio de modelo autocontenido listo para su despliegue.

Link to this sectionCaracterísticas clave de los modelos DEEPX#

Los modelos DEEPX ofrecen varias ventajas para el despliegue en el borde:

• Cuantización INT8: Los modelos se cuantizan a una precisión INT8 durante la exportación, lo que reduce significativamente el tamaño del modelo y maximiza el rendimiento de la NPU. Aprende más sobre la cuantización de modelos.
• Optimizado para NPU: El formato .dxnn está compilado específicamente para hardware NPU de DEEPX, aprovechando unidades de aceleración dedicadas para una inferencia rápida y eficiente.
• Bajo consumo de energía: Al descargar la inferencia a 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 autocontenida: El directorio del modelo exportado agrupa el binario compilado, la configuración de calibración y los metadatos para un despliegue directo.

Link to this sectionTareas compatibles#

Todas las tareas estándar de Ultralytics son compatibles para la exportación DEEPX en las familias de modelos YOLO26, YOLO11 y YOLOv8.

Link to this sectionExportar a DEEPX: cómo convertir tu modelo YOLO#

Exporta un modelo YOLO de Ultralytics al formato DEEPX y ejecuta la inferencia con el modelo exportado.

Link to this sectionInstalación#

Para instalar los paquetes necesarios, ejecuta:

# Install the required package for YOLO
pip install ultralytics

El paquete de compilación dx_com se instalará automáticamente desde el repositorio del SDK de DEEPX en la primera exportación. Para obtener instrucciones detalladas y mejores prácticas relacionadas con el proceso de instalación, consulta nuestra guía de instalación de Ultralytics. Si encuentras alguna dificultad al instalar los paquetes necesarios para YOLO, consulta nuestra guía de problemas comunes para ver soluciones y consejos.

Link to this sectionUso#

El formato DEEPX admite los modos Export, Predict y Validate. La inferencia y la validación se ejecutan en hardware NPU de DEEPX. Exporta tu modelo y luego cárgalo para realizar la inferencia o validar su precisión.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to DEEPX format (int8=True 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")

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

from ultralytics import YOLO

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

# Validate accuracy on the COCO8 dataset
metrics = model.val(data="coco8.yaml")

Link to this sectionArgumentos de exportación#

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

Link to this sectionEstructura de salida#

Tras una exportación exitosa, 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. El archivo metadata.yaml contiene los nombres de las clases, el tamaño de la imagen y otra información utilizada por el pipeline de inferencia de Ultralytics.

Link to this sectionDespliegue de modelos YOLO DEEPX exportados#

Una vez que hayas exportado con éxito tu modelo YOLO de Ultralytics al formato DEEPX, el siguiente paso es desplegar estos modelos en hardware NPU de DEEPX.

Link to this sectionInstalación del entorno de ejecución#

La inferencia requiere el controlador NPU de DEEPX, el entorno de ejecución libdxrt y el paquete de 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

Verifica que el entorno de ejecución esté instalado correctamente con dxrt-cli --version. Deberías ver una salida similar a esta:

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 la inferencia y la validación en tu dispositivo DEEPX exactamente como se muestra en la sección Uso anterior: el _deepx_model exportado se carga directamente con YOLO(...).

Link to this sectionVisualizació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 desde el SDK de DEEPX e instálalo mediante 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 tu modelo exportado:

dxtron yolo26n_deepx_model/yolo26n.dxnn

Link to this sectionBenchmarks#

El equipo de Ultralytics ha evaluado los modelos YOLO26, comparando la velocidad y la precisión entre PyTorch y DEEPX.

Rendimiento

Raspberry Pi 5 + Módulo M.2 DX-M1¡Más dispositivos próximamente!

Modelo	Formato	Estado	Tamaño (MB)	métricas/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)	acc (top1)	acc (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 para los benchmarks anteriores se realizó utilizando 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 preprocesamiento ni 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"

Link to this sectionFlujo de trabajo recomendado#

1. Entrena tu modelo usando el Modo de Entrenamiento de Ultralytics
2. Exporta al formato DEEPX usando model.export(format="deepx")
3. Valida la precisión con yolo val para verificar una pérdida de cuantización mínima
4. Predice usando yolo predict para una validación cualitativa
5. Despliega el directorio _deepx_model/ exportado en el hardware NPU de DEEPX usando el runtime dx_engine

Link to this sectionAplicaciones en el mundo real#

Los modelos YOLO desplegados en hardware NPU DEEPX son ideales para una amplia gama de aplicaciones de edge AI:

• Vigilancia inteligente: detección de objetos en tiempo real para sistemas de seguridad y monitoreo con bajo consumo de energía y sin dependencia de la nube.
• Automatización industrial: Control de calidad en el dispositivo, detección de defectos y monitoreo 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: Monitoreo de la salud de los cultivos, detección de plagas y estimación del rendimiento utilizando visión artificial en agricultura.
• Análisis minorista: Análisis de flujo de clientes, monitoreo de estantes y seguimiento de inventario con inferencia en el borde en tiempo real.

Link to this sectionResumen#

En esta guía, has aprendido cómo exportar modelos YOLO de Ultralytics al formato DEEPX y desplegarlos en hardware NPU de DEEPX. El pipeline de exportación utiliza calibración INT8 y el compilador dx_com para producir un binario .dxnn optimizado para hardware, mientras que el runtime dx_engine gestiona la inferencia en el dispositivo.

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

Para más detalles sobre su uso, visita el sitio web oficial de DEEPX.

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

Link to this sectionFAQ#

Link to this section¿Cómo exporto mi modelo YOLO de Ultralytics al formato DEEPX?#

Puedes exportar tu modelo usando el método export() en Python o mediante la CLI. La exportación habilita automáticamente la cuantización INT8 y utiliza un dataset de calibración para minimizar la pérdida de precisión. El paquete del compilador dx_com se instala automáticamente si no está presente.

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.export(format="deepx")

Link to this section¿Por qué la exportación a DEEPX requiere cuantización INT8?#

Las NPU de DEEPX están diseñadas para ejecutar cálculos INT8 con la máxima eficiencia. El compilador dx_com cuantiza el modelo durante la exportación usando calibración basada en EMA con imágenes del dataset real, permitiendo que la NPU ofrezca su máximo rendimiento. INT8 siempre se aplica en las exportaciones DEEPX; si pasas int8=False, se sobrescribirá con una advertencia.

Link to this section¿Qué plataformas son compatibles para la exportación a DEEPX?#

La exportación (compilación) del modelo DEEPX requiere un host x86-64 Linux. El paso de exportación no es compatible en máquinas ARM64 (aarch64) ni Windows. La inferencia usando el modelo .dxnn exportado puede ejecutarse en cualquier plataforma Linux (x86-64 y ARM64) compatible con el runtime dx_engine.

Link to this section¿Cuál es el resultado de una exportación DEEPX?#

La exportación crea un directorio (p. ej., yolo26n_deepx_model/) que contiene:

• yolo26n.dxnn — el binario compilado para NPU
• config.json — ajustes de calibración y preprocesamiento
• metadata.yaml — metadatos del modelo, incluidos nombres de clases y tamaño de imagen

Link to this section¿Puedo desplegar modelos entrenados personalizados en hardware DEEPX?#

Sí. Cualquier modelo entrenado usando el Modo de Entrenamiento de Ultralytics y exportado con format="deepx" puede ser desplegado en hardware NPU DEEPX, siempre que utilice operaciones de capa compatibles. La exportación admite tareas de detección, segmentación, estimación de pose, cajas delimitadoras orientadas (OBB) y clasificación.

Link to this section¿Cuántas imágenes de calibración debo usar para la exportación a DEEPX?#

El pipeline de exportación DEEPX utiliza cada imagen en el dataset de calibración con el método de calibración EMA. Unos pocos cientos de imágenes suelen ser suficientes para una buena precisión de cuantización. Apunta data a un dataset más pequeño si el tiempo de compilación es una preocupación con datasets grandes.

Link to this section¿Cómo instalo el runtime DEEPX para inferencia?#

El runtime DEEPX no viene incluido con ultralytics y debe instalarse por separado antes de ejecutar la inferencia. En máquinas Linux x86-64 y máquinas Linux ARM64 (por ejemplo, Raspberry Pi 5), instala el driver de la NPU (dxrt-driver-dkms) y el runtime (libdxrt) desde los lanzamientos de GitHub de DEEPX-AI, luego instala el wheel de Python dx_engine incluido. Consulta la sección Instalación del Runtime arriba para ver los comandos paso a paso.