Exportação DEEPX para modelos Ultralytics YOLO#

A implantação de modelos de visão computacional em hardware NPU especializado exige um formato de modelo compatível e otimizado. A exportação de modelos Ultralytics YOLO para o formato DEEPX permite inferência eficiente, quantizada em INT8, em aceleradores NPU DEEPX. Este guia explica como converter os teus modelos YOLO para o formato DEEPX e implantá-los em hardware com tecnologia DEEPX.

O que é DEEPX?#

DEEPX é uma empresa de semicondutores de IA especializada em unidades de processamento neural (NPUs) projetadas para inferência de aprendizado profundo eficiente em termos de energia na borda. Os NPUs DEEPX foram projetados para aplicações exigentes de IA embarcada e industrial, oferecendo alto rendimento com consumo mínimo de energia. O hardware é ideal para cenários de implantação em que a conectividade com a nuvem não é confiável ou desejável, como robótica, câmeras inteligentes e 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.4.1 fornece wheels para Python 3.8–3.14 em Linux x86-64 com glibc 2.31 ou mais recente. 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 driver NPU da DEEPX, o runtime libdxrt e o pacote 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

Verifique se o runtime está instalado corretamente com dxrt-cli --version. Você deverá ver uma saída semelhante 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

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

Visualização com dxtron#

dxtron é o visualizador de grafos da DEEPX para inspecionar o modelo .dxnn compilado.

Instale dxtron no Linux x86-64 baixando o pacote .deb do SDK da DEEPX e instalando-o com 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

Em seguida, abra o modelo exportado:

dxtron yolo26n_deepx_model/yolo26n.dxnn

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 detecção, COCO128-seg para segmentação, COCO8-pose para estimativa de pose, ImageNet100 para classificação 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.

A combinação de Ultralytics YOLO e da tecnologia NPU da DEEPX oferece uma solução eficaz para executar cargas de trabalho avançadas de visão computacional em dispositivos embarcados e de borda — com alta taxa de processamento e baixo consumo de energia para aplicações em tempo real.

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

Além disso, se quiser saber mais sobre outras integrações da Ultralytics YOLO, acesse nossa página do guia de integrações. Você encontrará muitos recursos e informações úteis.

Perguntas frequentes#