Exportación a 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 Ultralytics YOLO modelos al formato DeepX permite una inferencia eficiente cuantizada a INT8 en los 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.

¿Qué es DeepX?

DeepX es una empresa de semiconductores de IA especializada en unidades de procesamiento neuronal (NPU) diseñadas para deep learning de bajo consumo en el borde (edge). Las NPU de DeepX están diseñadas para aplicaciones de IA industrial y embebidas exigentes, ofreciendo un alto rendimiento con un consumo de energía mínimo. Su hardware es muy adecuado para escenarios de despliegue 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.

Formato de exportación DeepX

La exportación a DeepX genera un binario de modelo .dxnn optimizado para su ejecución en hardware NPU de DeepX. La tubería de compilación utiliza el dx_com kit de herramientas para realizar la cuantización a INT8 y la optimización específica del hardware, generando un directorio de modelo autónomo listo para el despliegue.

Características clave de los modelos DeepX

Los modelos DeepX ofrecen varias ventajas para el despliegue en el borde (edge):

• Cuantización INT8: Los modelos se cuantizan a 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 el 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 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 autónoma: El directorio del modelo exportado agrupa el binario compilado, la configuración de calibración y los metadatos para un despliegue directo.

Tareas admitidas

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

Exportar a DeepX: convirtiendo tu modelo YOLO

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

Instalación

Para instalar los paquetes necesarios, ejecuta:

# Install the required package for YOLO
pip install ultralytics

El dx_com paquete del compilador 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. Mientras instalas los paquetes necesarios para YOLO, si encuentras alguna dificultad, consulta nuestra guía de problemas comunes para obtener soluciones y consejos.

Uso

from ultralytics import YOLO

# Load the 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/'

Argumentos de exportación

Para más detalles 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 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 .dxnn el archivo es el binario del modelo compilado que el dx_engine tiempo de ejecución carga directamente en la NPU. El metadata.yaml contiene los nombres de clase, el tamaño de la imagen y otra información utilizada por la tubería de inferencia de Ultralytics.

Desplegar modelos YOLO DeepX exportados

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

Instalación del tiempo de ejecución

La inferencia requiere el controlador NPU de DeepX, el libdxrt tiempo de ejecución y el dx_engine paquete 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.0/dxrt-driver-dkms_2.4.0-2_all.deb
sudo apt install ./dxrt-driver-dkms_2.4.0-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:

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

Uso

from ultralytics import YOLO

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

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

# Process results
for r in results:
    print(f"Detected {len(r.boxes)} objects")
    r.show()

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 .deb paquete del 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

Luego, abre tu modelo exportado:

dxtron yolo26n_deepx_model/yolo26n.dxnn

Benchmarks

El equipo de Ultralytics evaluó los modelos YOLO26, comparando la velocidad y precisión entre PyTorch y DeepX.

sudo nano /boot/firmware/config.txt

dtparam=pciex1
dtparam=pciex1_gen=3

sudo reboot

Flujo de trabajo recomendado

1. Predict tu modelo usando Ultralytics Modo Train
2. , al formato DeepX usando model.export(format="deepx")
3. Validate la precisión con yolo val para verificar una pérdida de cuantización mínima
4. consulta las páginas de documentación de usando yolo predict para la validación cualitativa
5. Deploy el directorio exportado _deepx_model/ al hardware de la NPU DeepX usando el dx_engine runtime

Aplicaciones en el mundo real

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

• Smart Surveillance: 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.
• Industrial Automation: Control de calidad en el dispositivo, detección de defectos y monitoreo de procesos en entornos de fábrica.
• Robotics: Navegación basada en visión, evitación de obstáculos y reconocimiento de objetos en robots y drones autónomos.
• Smart Agriculture: Monitoreo de salud de cultivos, detección de plagas y estimación de rendimiento utilizando computer vision en agricultura.
• Retail Analytics: Análisis del flujo de clientes, monitoreo de estantes y seguimiento de inventario con inferencia edge en tiempo real.

Resumen

En esta guía, has aprendido cómo exportar modelos Ultralytics YOLO al formato DeepX y desplegarlos en hardware NPU DeepX. El pipeline de exportación utiliza calibración INT8 y el compilador dx_com para producir un binario optimizado para hardware .dxnn, mientras que el dx_engine runtime 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 computer vision en dispositivos integrados y edge, ofreciendo un alto rendimiento con bajo consumo de energía para aplicaciones en tiempo real.

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

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

FAQ

¿Cómo exporto mi modelo Ultralytics YOLO al formato DeepX?

Puedes exportar tu modelo usando el método export() en Python o a través de la CLI. La exportación habilita automáticamente la cuantización INT8 y utiliza un conjunto de datos 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")

¿Por qué la exportación a DeepX requiere cuantización INT8?

Las NPU DeepX están diseñadas para ejecutar cálculos INT8 con la máxima eficiencia. El dx_com compilador cuantiza el modelo durante la exportación utilizando una calibración basada en EMA con imágenes reales del conjunto de datos, permitiendo a la NPU ofrecer su máximo rendimiento. INT8 se aplica siempre para las exportaciones a DeepX; si pasas int8=False, se sobrescribirá y recibirás una advertencia.

¿Qué plataformas son compatibles para la exportación a DeepX?

La exportación (compilación) de modelos DeepX requiere un equipo x86-64 Linux anfitrión. El paso de exportación no es compatible con máquinas ARM64 (aarch64) ni Windows. La inferencia utilizando el modelo .dxnn exportado puede ejecutarse en cualquier plataforma Linux (x86-64 y ARM64) compatible con el tiempo de ejecución de dx_engine.

¿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, incluyendo nombres de clases y tamaño de imagen

¿Puedo desplegar modelos entrenados a medida en hardware DeepX?

Sí. Cualquier modelo entrenado usando Ultralytics Train Mode y exportado con format="deepx" puede desplegarse 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.

¿Cuántas imágenes de calibración debo usar para la exportación a DeepX?

La canalización de exportación DeepX utiliza cada imagen del conjunto de datos de calibración (tras el filtrado de fraction) 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 conjunto de datos más pequeño (o establece fraction por debajo de 1.0) si el tiempo de compilación se convierte en un problema con grandes conjuntos de datos.

¿Cómo instalo el tiempo de ejecución DeepX para inferencia?

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