Link to this sectionExportação DEEPX para Modelos Ultralytics YOLO#

Implantar 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 uma inferência eficiente e quantizada em INT8 em aceleradores NPU DEEPX. Este guia te orienta na conversão de seus modelos YOLO para o formato DEEPX e na implantação deles em hardware alimentado por DEEPX.

Link to this sectionO que é DEEPX?#

DEEPX é uma empresa de semicondutores de IA especializada em Unidades de Processamento Neural (NPUs) projetadas para inferência de deep learning energeticamente eficiente na borda (edge). As NPUs da DEEPX são projetadas para aplicações industriais e embarcadas de IA exigentes, entregando alto rendimento com consumo mínimo de energia. Seu hardware é bem adequado para cenários de implantação onde a conectividade em nuvem não é confiável ou desejável, como robótica, câmeras inteligentes e sistemas de automação industrial.

Link to this sectionFormato de Exportação DEEPX#

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

Link to this sectionPrincipais 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 precisão INT8 durante a exportação, reduzindo significativamente o tamanho do modelo e maximizando o rendimento da NPU. Saiba mais sobre quantização de modelo.
• Otimizado para NPU: O formato .dxnn é compilado especificamente para hardware NPU DEEPX, aproveitando unidades de aceleração dedicadas para uma inferência rápida e eficiente.
• Baixo Consumo de Energia: Ao descarregar a inferência para a 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 de conjunto de dados reais para minimizar a perda de precisão durante a quantização.
• Saída Autônoma: O diretório do modelo exportado agrupa o binário compilado, a configuração de calibração e os metadados para uma implantação direta.

Link to this sectionTarefas Suportadas#

Todas as tarefas padrão da Ultralytics são suportadas para exportação DEEPX nas famílias de modelos YOLO26, YOLO11 e YOLOv8.

Link to this sectionExportar para DEEPX: Convertendo seu Modelo YOLO#

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

Link to this sectionInstalação#

Para instalar os pacotes necessários, execute:

# Install the required package for YOLO
pip install ultralytics

O pacote de compilador dx_com será instalado automaticamente a partir do repositório SDK da DEEPX na primeira exportação. Para instruções detalhadas e melhores práticas relacionadas ao processo de instalação, verifique nosso guia de Instalação Ultralytics. Ao instalar os pacotes necessários para o YOLO, se você encontrar alguma dificuldade, consulte nosso guia de Problemas Comuns para soluções e dicas.

Link to this sectionUso#

O formato DEEPX suporta os modos Exportar, Prever e Validar. A inferência e a validação são executadas no hardware NPU DEEPX. Exporte seu modelo, depois carregue o modelo exportado para executar a inferência ou validar sua precisão.

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 Exportação#

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

Link to this sectionEstrutura de Saída#

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

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 nomes de classes, tamanho da imagem e outras informações usadas pelo pipeline de inferência da Ultralytics.

Link to this sectionImplantando Modelos YOLO DEEPX Exportados#

Uma vez que você tenha exportado com sucesso seu modelo Ultralytics YOLO para o formato DEEPX, o próximo passo é implantar esses modelos no hardware NPU DEEPX.

Link to this sectionInstalação do Runtime#

A inferência requer o driver NPU 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ê deve 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

Uma vez que o runtime esteja instalado, execute a inferência e a validação no seu dispositivo DEEPX exatamente como mostrado na seção Uso acima — o _deepx_model exportado carrega diretamente com YOLO(...).

Link to this sectionVisualizando com dxtron#

dxtron é o visualizador de gráficos da DEEPX para inspecionar o modelo .dxnn compilado.

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

Depois abra seu modelo exportado:

dxtron yolo26n_deepx_model/yolo26n.dxnn

Link to this sectionBenchmarks#

A equipe da Ultralytics realizou benchmarks dos modelos YOLO26, comparando velocidade e precisão entre PyTorch e DEEPX.

Desempenho

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

Modelo	Formato	Status	Tamanho (MB)	métricas/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 para os benchmarks acima foi feita usando 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 pré/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"

Link to this sectionFluxo de Trabalho Recomendado#

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

Link to this sectionAplicações no Mundo Real#

Os modelos YOLO implantados no hardware NPU DEEPX são adequados para uma ampla gama de aplicações de edge AI:

• Monitoramento Inteligente: detecção de objetos em tempo real para sistemas de segurança e monitoramento com baixo consumo de energia e sem dependência de 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 culturas, detecção de pragas e estimativa de rendimento usando visão computacional na agricultura.
• Análise de Varejo: Análise de fluxo de clientes, monitoramento de prateleiras e rastreamento de inventário com inferência de borda em tempo real.

Link to this sectionResumo#

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

A combinação do 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, proporcionando alta taxa de transferência com baixo consumo de energia para aplicações em tempo real.

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

Além disso, se você quiser saber mais sobre outras integrações do Ultralytics YOLO, visite nossa página de guia de integração. Você encontrará muitos recursos e insights úteis por lá.

Link to this sectionPerguntas Frequentes#

Link to this sectionComo faço para exportar meu modelo Ultralytics YOLO para o formato DEEPX?#

Você pode exportar seu modelo usando o método export() em Python ou via CLI. A exportação habilita automaticamente a quantização INT8 e usa um conjunto de dados de calibração para minimizar a perda de precisão. O pacote do compilador dx_com é instalado automaticamente se ainda não estiver presente.

from ultralytics import YOLO

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

Link to this sectionPor que a exportação DEEPX requer quantização INT8?#

As NPUs DEEPX são projetadas para executar cálculos INT8 com eficiência máxima. O compilador dx_com quantiza o modelo durante a exportação usando calibração baseada em EMA com imagens de conjuntos de dados reais, permitindo que a NPU entregue seu desempenho total. INT8 é sempre aplicado para exportações DEEPX — se você definir int8=False, isso será substituído com um aviso.

Link to this sectionQuais plataformas são suportadas para exportação DEEPX?#

A exportação (compilação) de modelos DEEPX requer um host x86-64 Linux. A etapa de exportação não é suportada em máquinas ARM64 (aarch64) ou Windows. A inferência usando o modelo .dxnn exportado pode ser executada em qualquer plataforma Linux (x86-64 e ARM64) suportada pelo tempo de execução dx_engine.

Link to this sectionQual é a saída de uma exportação DEEPX?#

A exportação cria um diretório (por exemplo, yolo26n_deepx_model/) contendo:

• yolo26n.dxnn — o binário NPU compilado
• config.json — configurações de calibração e pré-processamento
• metadata.yaml — metadados do modelo, incluindo nomes de classes e tamanho da imagem

Link to this sectionPosso implantar modelos treinados personalizados no hardware DEEPX?#

Sim. Qualquer modelo treinado usando o Modo Treino da Ultralytics e exportado com format="deepx" pode ser implantado no hardware NPU DEEPX, desde que use operações de camada suportadas. A exportação suporta tarefas de detecção, segmentação, estimativa de pose, caixa delimitadora orientada (OBB) e classificação.

Link to this sectionQuantas imagens de calibração devo usar para a exportação DEEPX?#

O pipeline de exportação DEEPX usa todas as imagens no conjunto de dados de calibração (após a filtragem por fraction) com o método de calibração EMA. Algumas centenas de imagens geralmente são suficientes para uma boa precisão de quantização. Aponte data para um conjunto de dados menor (ou defina fraction abaixo de 1.0) se o tempo de compilação se tornar uma preocupação em grandes conjuntos de dados.

Link to this sectionComo instalo o tempo de execução DEEPX para inferência?#

O tempo de execução DEEPX não vem incluído com o ultralytics e deve ser instalado separadamente antes de executar a inferência. Em máquinas Linux x86-64 e ARM64 (como o Raspberry Pi 5), instale o driver NPU (dxrt-driver-dkms) e o tempo de execução (libdxrt) a partir dos lançamentos do GitHub da DEEPX-AI, em seguida, instale o arquivo Python wheel do dx_engine incluído. Consulte a seção Instalação do Tempo de Execução acima para comandos passo a passo.