Exportación de modelos Ultralytics YOLO a DEEPX#

Implementar modelos de visión por computador 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 basado en 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 deep learning con eficiencia energética en el edge. Las NPUs de DEEPX están diseñadas para aplicaciones de IA embebida e industrial exigentes, y ofrecen un alto rendimiento con un consumo energético mínimo. Su hardware es ideal para escenarios de implementación en los que la conectividad con la nube no es fiable o no se desea utilizar, 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. La cadena de compilación utiliza el kit de herramientas dx_com para realizar la cuantización INT8 y la optimización específica del hardware, y genera un directorio de modelo autocontenido 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: durante la exportación, los modelos se cuantizan a precisión INT8, lo que reduce significativamente 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 el hardware NPU DEEPX y aprovecha unidades de aceleración dedicadas para realizar inferencias rápidas y eficientes.
• Bajo consumo energético: al descargar la inferencia en la 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 autocontenida: 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 esas cabezas.

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

Las versiones de PyPI del compilador están retiradas (yanked). Para preinstalar las dependencias de exportación, suministra la página de wheels 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 una instalación de repositorio editable, sustituye "ultralytics[export-deepx]" por -e ".[export-base,export-deepx]". Para reproducir el entorno de Python 3.12 y la exportación de prueba (smoke export) utilizada por CI, ejecuta el constructor de entorno existente desde la raíz del repositorio:

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

El constructor de entorno requiere uv y una copia local instalada de Ultralytics. Este instala el compilador desde el código fuente del SDK y aplica las restricciones de dependencias probadas de forma automática.

Uso#

El formato DEEPX admite 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

# Load a YOLO26 model
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")

# 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")

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 tiempo 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 la cadena de inferencia de Ultralytics.

Implementación de modelos YOLO DEEPX exportados#

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

Instalación del tiempo de ejecución#

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

# 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 tiempo 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 tiempo 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(...).

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 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

Evaluaciones comparativas#

El equipo de Ultralytics comparó modelos YOLO26, evaluando la velocidad y la precisión entre 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 pruebas de rendimiento anteriores se realizó utilizando COCO128 para detección, COCO128-seg para segmentación, COCO8-pose para estimación de postura, ImageNet100 para clasificación y DOTA128 para modelos OBB. El tiempo de inferencia no incluye el procesamiento previo ni posterior.

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 mediante el modo Entrenar de Ultralytics
2. Exporta al formato DEEPX utilizando 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. Predice usando yolo predict para realizar una validación cualitativa
5. Implementa el directorio _deepx_model/ exportado en hardware NPU DEEPX utilizando el tiempo de ejecución dx_engine

Aplicaciones en el mundo real#

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

• Vigilancia inteligente: detección de objetos en tiempo real para sistemas de seguridad y monitorización, con bajo consumo energético y sin depender de la nube.
• Automatización industrial: control de calidad en el dispositivo, detección de defectos y monitorizació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 y drones autónomos.
• Agricultura inteligente: monitorización del estado de los cultivos, detección de plagas y estimación del rendimiento mediante visión por computador aplicada a la agricultura.
• Análisis minorista: análisis del flujo de clientes, monitorización de estanterías y seguimiento del inventario con inferencia en el edge en tiempo real.

Resumen#

En esta guía has aprendido a exportar modelos Ultralytics YOLO al formato DEEPX e implementarlos en hardware NPU DEEPX. La cadena 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 tiempo 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 por computador en dispositivos embebidos y edge, con un alto rendimiento y un bajo consumo energético 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 obtener más información sobre otras integraciones de Ultralytics YOLO, visita nuestra página de la guía de integraciones. Allí encontrarás muchos recursos e información útil.

Preguntas frecuentes#