Exportação DeepX para Modelos YOLO da Ultralytics

Implantar modelos de visão computacional em hardware NPU especializado requer um formato de modelo compatível e otimizado. Exportar Ultralytics YOLO modelos para o formato DeepX permite uma inferência INT8 quantizada e eficiente em aceleradores NPU DeepX. Este guia te orienta a converter seus modelos YOLO para o formato DeepX e implantá-los em hardware com tecnologia DeepX.

O que é o DeepX?

DeepX é uma empresa de semicondutores de IA especializada em Unidades de Processamento Neural (NPUs) projetadas para deep learning eficiente em termos de energia na borda (edge). As NPUs da DeepX são projetadas para aplicações de IA industrial e embarcadas exigentes, entregando alto rendimento com consumo mínimo de energia. Seu hardware é bem adequado para cenários de implantação onde a conectividade com a nuvem é instável ou indesejada, 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 .dxnn compilado, otimizado para execução em hardware NPU DeepX. O pipeline de compilação usa o dx_com kit de ferramentas para realizar a quantização INT8 e otimização específica de hardware, gerando um diretório de modelo independente pronto para implantação.

Principais Recursos dos Modelos DeepX

Modelos DeepX oferecem diversas 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 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 transferir a inferência para a NPU, os modelos DeepX consomem muito menos energia do que uma 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 conjuntos de dados reais para minimizar a perda de precisão durante a quantização.
• Saída Independente: O diretório do modelo exportado agrupa o binário compilado, a configuração de calibração e metadados para uma implantação direta.

Tarefas Suportadas

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

Exportar para DeepX: Convertendo seu Modelo YOLO

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

Instalação

Para instalar os pacotes necessários, execute:

# Install the required package for YOLO
pip install ultralytics

O dx_com pacote do compilador será instalado automaticamente a partir do repositório SDK do 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 YOLO, se você encontrar dificuldades, consulte nosso guia de Problemas Comuns para soluções e dicas.

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

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

Estrutura 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 .dxnn o arquivo é o binário do modelo compilado que o dx_engine tempo de execução (runtime) 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.

Implantando 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 em hardware NPU DeepX.

Instalação do Runtime

A inferência requer o driver da NPU DeepX, o libdxrt runtime, e o dx_engine pacote 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

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

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

Visualizando com dxtron

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

Instale dxtron no Linux x86-64 baixando o .deb pacote 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

Em seguida, abra seu modelo exportado:

dxtron yolo26n_deepx_model/yolo26n.dxnn

Benchmarks

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

sudo nano /boot/firmware/config.txt

dtparam=pciex1
dtparam=pciex1_gen=3

sudo reboot

Fluxo de trabalho recomendado

1. , seu modelo usando Ultralytics Modo Treino
2. Val para o formato DeepX usando model.export(format="deepx")
3. Validar precisão com yolo val para verificar a perda mínima de quantização
4. Predict usando yolo predict para validação qualitativa
5. Implantar o diretório _deepx_model/ exportado para o hardware NPU DeepX usando o dx_engine runtime

Aplicações no mundo real

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 vigilância 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 de fábrica.
• 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 plantações, 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 controle de estoque com inferência de borda em tempo real.

Resumo

Neste guia, você aprendeu como exportar modelos Ultralytics YOLO 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 dx_engine runtime lida com a inferência no dispositivo.

A combinação de Ultralytics YOLO e da tecnologia NPU da DeepX fornece uma solução eficaz para executar cargas de trabalho avançadas de visão computacional em dispositivos embarcados e de borda — entregando alto rendimento 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á.

FAQ

Como exporto 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 caso não esteja presente.

from ultralytics import YOLO

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

Por que a exportação DeepX requer quantização INT8?

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

Quais plataformas são suportadas para a 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) e Windows. A inferência usando o modelo .dxnn exportado pode ser executada em qualquer plataforma Linux (x86-64 e ARM64) suportada pelo runtime dx_engine.

Qual é 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 da NPU compilado
• config.json — configurações de calibração e pré-processamento
• metadata.yaml — metadados do modelo, incluindo nomes das classes e tamanho da imagem

Posso implantar modelos treinados de forma personalizada no hardware DeepX?

Sim. Qualquer modelo treinado usando Ultralytics Train Mode e exportado com format="deepx" pode ser implantado no hardware NPU DeepX, desde que utilize 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.

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

Como instalo o runtime DeepX para inferência?

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