Exportação DEEPX para modelos Ultralytics YOLO

A implementação de modelos de visão computacional em hardware NPU especializado requer um formato de modelo compatível e otimizado. Exportar modelos Ultralytics YOLO para o formato DEEPX permite realizar inferência eficiente, quantizada para INT8, nos aceleradores NPU da DEEPX. Este guia explica como converter os teus modelos YOLO para o formato DEEPX e implementá-los em hardware equipado com DEEPX.

O que é DEEPX?#

A DEEPX é uma empresa de semicondutores para IA e parceira da Ultralytics, especializada em unidades de processamento neural (NPUs) concebidas para realizar inferência de aprendizagem profunda na periferia com baixo consumo energético. As NPUs da DEEPX foram concebidas para aplicações de IA exigentes em sistemas integrados e industriais, oferecendo elevado débito com um consumo mínimo de energia. O hardware é adequado para cenários de implementação em que a ligação à nuvem não é fiável ou não é desejável, como a robótica, as câmaras inteligentes e os sistemas de automação industrial.

Formato de exportação DEEPX#

A exportação DEEPX produz um binário de modelo compilado .dxnn, otimizado para execução em hardware NPU DEEPX. O pipeline de compilação usa o conjunto de ferramentas dx_com para realizar a quantização INT8 e a otimização específica para o hardware, gerando um diretório de modelo independente pronto para implantação.

Principais recursos dos modelos DEEPX#

Os modelos DEEPX oferecem várias vantagens para implantação na borda:

• Quantização INT8: os modelos são quantizados para a precisão INT8 durante a exportação, reduzindo significativamente o tamanho do modelo e maximizando o rendimento do NPU. Saiba mais sobre quantização de modelos.
• Otimizado para NPU: o formato .dxnn é compilado especificamente para hardware NPU DEEPX e aproveita unidades de aceleração dedicadas para uma inferência rápida e eficiente.
• Baixo consumo de energia: ao transferir a inferência para o NPU, os modelos DEEPX consomem muito menos energia do que a inferência equivalente em CPU ou GPU.
• Precisão baseada em calibração: a exportação usa calibração baseada em EMA com imagens reais do conjunto de dados para minimizar a perda de precisão durante a quantização.
• Saída independente: o diretório do modelo exportado reúne o binário compilado, a configuração de calibração e os metadados para facilitar a implantação.

Tarefas suportadas#

A exportação para DEEPX oferece suporte às sete tarefas da Ultralytics. A segmentação semântica e a estimativa de profundidade estão disponíveis apenas no YOLO26, a única família que inclui essas cabeças.

Exportação para DEEPX: convertendo seu modelo YOLO#

Exporte um modelo Ultralytics YOLO para o formato DEEPX e execute inferências com o modelo exportado.

Instalação#

Para instalar os pacotes necessários, executa:

# Install the required package for YOLO
pip install ultralytics

O compilador dx_com é instalado automaticamente do PyPI na primeira exportação. O DX-COM 2.5.0 fornece wheels para Python 3.8–3.14 em Linux x86-64 com glibc 2.31 ou mais recente e requer pelo menos 16 GB de RAM. Para pré-instalar as dependências de exportação:

pip install "ultralytics[export-deepx]"

Para instalar o repositório em modo editável, substitua "ultralytics[export-deepx]" por -e ".[export-base,export-deepx]". Para reproduzir o ambiente Python 3.14 e a exportação de teste rápido usados pela CI, execute o construtor de ambiente existente a partir da raiz do repositório:

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

O construtor de ambiente requer uv e um checkout do Ultralytics instalado. Ele aplica automaticamente as restrições de dependências testadas.

Uso#

O formato DEEPX é compatível com os modos Exportar, Prever e Validar. A inferência e a validação são executadas no hardware NPU da DEEPX. Exporte seu modelo e, em seguida, carregue o modelo exportado para executar inferências ou validar sua precisão.

from ultralytics import YOLO

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporte o modelo para o formato DEEPX (quantize=8 é aplicado automaticamente)
model.export(format="deepx")  # creates 'yolo26n_deepx_model/'

from ultralytics import YOLO

# Carregue o modelo DEEPX exportado
model = YOLO("yolo26n_deepx_model")

# Executar inferência
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carregue o modelo DEEPX exportado
model = YOLO("yolo26n_deepx_model")

# Validar a precisão no conjunto de dados COCO8
metrics = model.val(data="coco8.yaml")

Argumentos de exportação#

Para mais detalhes sobre o processo de exportação, visita a página da documentação da Ultralytics sobre exportação.

Estrutura de saída#

Após uma exportação bem-sucedida, é criado um diretório do modelo com a seguinte estrutura:

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

O arquivo .dxnn é o binário do modelo compilado que o runtime dx_engine carrega diretamente na NPU. O metadata.yaml contém os nomes das classes, o tamanho da imagem e outras informações usadas pelo pipeline de inferência da Ultralytics.

Implantação de modelos YOLO DEEPX exportados#

Depois de exportar com sucesso seu modelo Ultralytics YOLO para o formato DEEPX, a próxima etapa é implantá-lo no hardware NPU da DEEPX.

Instalação do runtime#

A inferência requer o controlador NPU DEEPX (v2.7.0 ou mais recente), o runtime DX-RT (v3.5.0 ou mais recente), o firmware NPU v2.7.6 ou mais recente e o pacote Python dx_engine. Estas são as versões necessárias para executar modelos compilados com o DX-COM 2.5.0.

Instala o controlador NPU e o pacote runtime libdxrt-bin com uma das opções seguintes.

Opção A: instalar a partir dos pacotes de lançamento do GitHub#

Transfere os pacotes .deb do controlador e do runtime dos repositórios GitHub da DEEPX-AI e instala-os. O pacote runtime é fornecido para cada arquitetura de CPU (amd64 ou 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

Opção B: instalar a partir do repositório apt da DEEPX#

Regista o repositório apt da DEEPX uma vez e, em seguida, instala e atualiza o controlador e o runtime com 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 o host depois de instalar o controlador para que o novo módulo do kernel seja carregado antes de executar dxcli.

Pacote Python e firmware#

libdxrt-bin inclui wheels dx_engine para Python 3.8–3.14 em /usr/share/libdxrt-bin/python/, mas não os instala. No ambiente onde o Ultralytics e o NumPy estão instalados, instala o wheel correspondente à tua versão do Python:

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

O DX-RT 3.5.0 requer firmware NPU v2.7.6 ou mais recente. Verifica a versão do firmware e o ID do dispositivo com dxcli -s e, se for uma versão mais antiga, atualiza-o com a imagem de firmware correspondente ao teu módulo. Os módulos DX-M1 e DX-M1M M.2 utilizam imagens de firmware diferentes; transfere apenas a imagem correspondente ao teu módulo. dxcli -s apresenta o módulo como M1 ou M1M nas informações do 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

Depois de atualizar o firmware, desliga completamente o host e volta a iniciá-lo antes de verificar a versão do firmware. Se não for possível desligar fisicamente a alimentação, reinicia o host conforme descrito no guia de resolução de problemas da DEEPX.

Verifica a instalação com dxcli -s, que apresenta as versões do runtime, do controlador e do firmware de cada dispositivo. import dx_engine gera um RuntimeError se as versões do wheel dx_engine e do runtime libdxrt instalado forem diferentes. Por isso, reinstala o wheel de /usr/share/libdxrt-bin/python/ depois de atualizar o runtime.

Depois de instalar o runtime, execute inferências e validações no dispositivo DEEPX exatamente como mostrado na seção Uso acima — o _deepx_model exportado é carregado diretamente com YOLO(...).

Inspecionar o modelo compilado#

O DX-COM 2.5.0 substitui o visualizador de grafos DX-TRON por um relatório interativo de compilação em HTML, que apresenta a estrutura do modelo compilado e a distribuição da carga de trabalho entre CPU e NPU. Se necessário, gera-o recompilando o modelo ONNX intermédio criado pela exportação com a CLI dxcom no host de exportação 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 num navegador para ver o relatório.

Benchmarks#

A equipe da Ultralytics avaliou modelos YOLO26, comparando a velocidade e a precisão entre PyTorch e DEEPX.

Desempenho

Raspberry Pi 5 + módulo DX-M1 M.2Mais dispositivos em breve!

Modelo	Formato	Status	Tamanho (MB)	metrics/mAP50-95(B)	Tempo de inferência (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	Status	Tamanho (MB)	acc (top1)	acc (top5)	Tempo de inferência (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

A validação dos benchmarks acima foi realizada com COCO128 para deteção, COCO128-seg para segmentação, ImageNet100 para classificação, COCO8-pose para estimativa de pose e DOTA128 para modelos OBB. O tempo de inferência não inclui o pré-processamento nem o pós-processamento.

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"

Fluxo de trabalho recomendado#

1. Treina o teu modelo com o Modo de Treino da Ultralytics
2. Exporte para o formato DEEPX usando model.export(format="deepx")
3. Valida a precisão com yolo val para verificar se a perda de quantização é mínima
4. Faz previsões com yolo predict para validação qualitativa
5. Implante o diretório _deepx_model/ exportado no hardware NPU da DEEPX usando o runtime dx_engine

Aplicações no mundo real#

Os modelos YOLO implantados no hardware NPU da DEEPX são adequados para uma ampla variedade de aplicações de IA de borda:

• Vigilância inteligente: Detecção de objetos em tempo real para sistemas de segurança e monitoramento, com baixo consumo de energia e sem depender da nuvem.
• Automação industrial: controle de qualidade no dispositivo, detecção de defeitos e monitoramento de processos em ambientes fabris.
• Robótica: navegação baseada em visão, desvio de obstáculos e reconhecimento de objetos em robôs autônomos e drones.
• Agricultura inteligente: monitoramento da saúde das lavouras, detecção de pragas e estimativa de rendimento usando visão computacional na agricultura.
• Análise de varejo: análise do fluxo de clientes, monitoramento de prateleiras e acompanhamento de estoque com inferência de borda em tempo real.

Resumo#

Neste guia, você aprendeu a exportar modelos Ultralytics YOLO para o formato DEEPX e implantá-los no hardware NPU da DEEPX. O pipeline de exportação usa calibração INT8 e o compilador dx_com para gerar um binário .dxnn otimizado para o hardware, enquanto o runtime dx_engine executa a inferência no dispositivo.

Em conjunto, o Ultralytics YOLO e as NPUs da DEEPX executam cargas de trabalho de visão computacional em sistemas integrados e dispositivos de periferia, com elevado débito e baixo consumo energético para aplicações em tempo real.

Para mais detalhes sobre o uso, acesse o site oficial da DEEPX.

Perguntas frequentes#