Esportazione DEEPX per i modelli Ultralytics YOLO

La distribuzione di modelli di visione artificiale su hardware NPU specializzato richiede un formato del modello compatibile e ottimizzato. L'esportazione dei modelli Ultralytics YOLO in formato DEEPX consente un'inferenza efficiente, quantizzata INT8, sugli acceleratori NPU DEEPX. Questa guida ti illustra come convertire i modelli YOLO in formato DEEPX e distribuirli su hardware basato su DEEPX.

Che cos'è DEEPX?#

DEEPX è un'azienda di semiconduttori per l'IA e un partner di Ultralytics specializzato in unità di elaborazione neurale (NPU), progettate per un'inferenza di deep learning efficiente dal punto di vista energetico all'edge. Le NPU DEEPX sono progettate per le applicazioni IA industriali ed embedded più impegnative e offrono un throughput elevato con consumi energetici minimi. Il loro hardware è particolarmente adatto agli scenari di distribuzione in cui la connessione al cloud è inaffidabile o non desiderata, come la robotica, le telecamere intelligenti e i sistemi di automazione industriale.

Formato di esportazione DEEPX#

L'esportazione DEEPX produce un file binario del modello .dxnn compilato e ottimizzato per l'esecuzione su hardware NPU DEEPX. La pipeline di compilazione usa il toolkit dx_com per eseguire la quantizzazione INT8 e l'ottimizzazione specifica per l'hardware, generando una directory del modello autonoma e pronta per la distribuzione.

Caratteristiche principali dei modelli DEEPX#

I modelli DEEPX offrono diversi vantaggi per la distribuzione edge:

• Quantizzazione INT8: durante l'esportazione i modelli vengono quantizzati con precisione INT8, riducendo notevolmente le dimensioni e massimizzando il throughput dell'NPU. Scopri di più sulla quantizzazione dei modelli.
• Ottimizzato per NPU: il formato .dxnn viene compilato appositamente per l'hardware NPU DEEPX e sfrutta unità di accelerazione dedicate per un'inferenza rapida ed efficiente.
• Basso consumo energetico: trasferendo l'inferenza all'NPU, i modelli DEEPX consumano molta meno energia rispetto a un'inferenza equivalente su CPU o GPU.
• Precisione basata sulla calibrazione: l'esportazione usa una calibrazione basata su EMA con immagini reali del dataset per ridurre al minimo la perdita di precisione durante la quantizzazione.
• Output autonomo: la directory del modello esportato include il binario compilato, la configurazione di calibrazione e i metadati, per semplificare la distribuzione.

Attività supportate#

L'esportazione DEEPX supporta tutti e sette i task di Ultralytics. La segmentazione semantica e la stima della profondità sono disponibili solo con YOLO26, l'unica famiglia che include queste head.

Esportare in DEEPX: convertire il modello YOLO#

Esporta un modello Ultralytics YOLO in formato DEEPX ed esegui l'inferenza con il modello esportato.

Installazione#

Per installare i pacchetti necessari, esegui:

# Install the required package for YOLO
pip install ultralytics

Il compilatore dx_com viene installato automaticamente da PyPI al primo export. DX-COM 2.5.0 fornisce pacchetti wheel per Python 3.8–3.14 su Linux x86-64 con glibc 2.31 o versioni successive e richiede almeno 16 GB di RAM. Per preinstallare le dipendenze per l'export:

pip install "ultralytics[export-deepx]"

Per installare il repository in modalità modificabile, sostituisci "ultralytics[export-deepx]" con -e ".[export-base,export-deepx]". Per ricreare l'ambiente Python 3.14 e l'esportazione di prova usati da CI, esegui il builder dell'ambiente esistente dalla directory principale del repository:

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

Il builder dell'ambiente richiede uv e un checkout di Ultralytics installato. Applica automaticamente i vincoli sulle dipendenze verificati.

Utilizzo#

Il formato DEEPX supporta le modalità Esporta, Prevedi e Convalida. L'inferenza e la convalida vengono eseguite sull'hardware NPU DEEPX. Esporta il modello, quindi carica il modello esportato per eseguire l'inferenza o convalidarne la precisione.

from ultralytics import YOLO

# Carica un modello YOLO26
model = YOLO("yolo26n.pt")

# Esporta il modello in formato DEEPX (quantize=8 viene applicato automaticamente)
model.export(format="deepx")  # creates 'yolo26n_deepx_model/'

from ultralytics import YOLO

# Carica il modello DEEPX esportato
model = YOLO("yolo26n_deepx_model")

# Esegui l'inferenza
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Carica il modello DEEPX esportato
model = YOLO("yolo26n_deepx_model")

# # Convalida l'accuratezza sul dataset COCO8
metrics = model.val(data="coco8.yaml")

Argomenti di esportazione#

Per ulteriori dettagli sul processo di esportazione, visita la pagina della documentazione Ultralytics dedicata all'esportazione.

Struttura dell'output#

Dopo un'esportazione riuscita, viene creata una directory del modello con la seguente struttura:

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

Il file .dxnn è il binario del modello compilato, che il runtime dx_engine carica direttamente sulla NPU. metadata.yaml contiene i nomi delle classi, la dimensione dell'immagine e altre informazioni usate dalla pipeline di inferenza Ultralytics.

Distribuzione dei modelli YOLO DEEPX esportati#

Dopo aver esportato correttamente il modello Ultralytics YOLO in formato DEEPX, il passaggio successivo consiste nel distribuirlo sull'hardware NPU DEEPX.

Installazione del runtime#

L'inferenza richiede il driver NPU DEEPX (v2.7.0 o versioni successive), il runtime DX-RT (v3.5.0 o versioni successive), il firmware NPU v2.7.6 o versioni successive e il pacchetto Python dx_engine. Queste sono le versioni richieste per eseguire modelli compilati con DX-COM 2.5.0.

Installa il driver NPU e il pacchetto runtime libdxrt-bin con una delle seguenti opzioni.

Opzione A: installazione dai pacchetti delle release GitHub#

Scarica e installa i pacchetti .deb del driver e del runtime dai repository GitHub di DEEPX-AI. Il pacchetto runtime è fornito per ciascuna architettura CPU (amd64 o 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

Opzione B: installazione dal repository apt di DEEPX#

Registra una volta il repository apt di DEEPX, quindi installa e aggiorna il driver e il runtime con 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

Dopo aver installato il driver, riavvia l'host affinché il nuovo modulo del kernel venga caricato prima di eseguire dxcli.

Pacchetto Python e firmware#

libdxrt-bin include i pacchetti wheel dx_engine per Python 3.8–3.14 in /usr/share/libdxrt-bin/python/, ma non li installa. Nell'ambiente in cui sono installati Ultralytics e NumPy, installa il pacchetto wheel corrispondente alla tua versione di Python:

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

DX-RT 3.5.0 richiede il firmware NPU v2.7.6 o versioni successive. Controlla la versione del firmware e l'ID del dispositivo con dxcli -s e, se il firmware è più vecchio, aggiornalo con l'immagine firmware per il tuo modulo. I moduli DX-M1 e DX-M1M M.2 usano immagini firmware diverse, quindi scarica solo quella corrispondente al tuo modulo; dxcli -s indica il modulo come M1 o M1M nelle informazioni sul 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

Dopo il flashing, spegni completamente l'host e riavvialo prima di controllare la versione del firmware. Se non è possibile scollegare fisicamente l'alimentazione, riavvia l'host come descritto nella guida alla risoluzione dei problemi di DEEPX.

Verifica l'installazione con dxcli -s, che mostra le versioni del runtime, del driver e del firmware di ciascun dispositivo. import dx_engine genera un RuntimeError se le versioni del pacchetto wheel dx_engine e del runtime libdxrt installato sono diverse; dopo aver aggiornato il runtime, reinstalla quindi il pacchetto wheel da /usr/share/libdxrt-bin/python/.

Una volta installato il runtime, esegui l'inferenza e la convalida sul dispositivo DEEPX esattamente come descritto nella sezione Utilizzo qui sopra: il modello esportato _deepx_model viene caricato direttamente con YOLO(...).

Ispezione del modello compilato#

DX-COM 2.5.0 sostituisce il visualizzatore di grafi DX-TRON con un report interattivo HTML di riepilogo della compilazione, che mostra la struttura del modello compilato e la ripartizione del carico di lavoro tra CPU e NPU. Se necessario, generarlo ricompilando il modello ONNX intermedio prodotto dall'export con la CLI dxcom sull'host x86-64 usato per l'export:

dxcom -m yolo26n.onnx -c yolo26n_deepx_model/config.json -o yolo26n_deepx_report --export_html

Apri yolo26n_deepx_report/yolo26n_summary.html in un browser per visualizzare il report.

Benchmark#

Il team Ultralytics ha eseguito benchmark sui modelli YOLO26, confrontando velocità e precisione tra PyTorch e DEEPX.

Prestazioni

Raspberry Pi 5 + modulo DX-M1 M.2Altri dispositivi in arrivo!

Modello	Formato	Stato	Dimensione (MB)	metrics/mAP50-95(B)	Tempo di inferenza (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

Modello	Formato	Stato	Dimensione (MB)	acc (top1)	acc (top5)	Tempo di inferenza (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

La convalida dei benchmark sopra riportati è stata eseguita usando COCO128 per il rilevamento, COCO128-seg per la segmentazione, ImageNet100 per la classificazione, COCO8-pose per la stima della posa e DOTA128 per i modelli OBB. Il tempo di inferenza non include la pre-elaborazione e la post-elaborazione.

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"

Flusso di lavoro consigliato#

1. Addestra il tuo modello usando la modalità Train di Ultralytics
2. Esporta in formato DEEPX usando model.export(format="deepx")
3. Convalida l'accuratezza con yolo val per verificare che la perdita dovuta alla quantizzazione sia minima
4. Esegui la predizione usando yolo predict per la convalida qualitativa
5. Distribuisci la directory _deepx_model/ esportata sull'hardware NPU DEEPX usando il runtime dx_engine

Applicazioni nel mondo reale#

I modelli YOLO distribuiti sull'hardware NPU DEEPX sono adatti a un'ampia gamma di applicazioni di IA edge:

• Videosorveglianza intelligente: Rilevamento di oggetti in tempo reale per sistemi di sicurezza e monitoraggio, con un basso consumo energetico e senza dipendenza dal cloud.
• Automazione industriale: controllo qualità sul dispositivo, rilevamento dei difetti e monitoraggio dei processi in fabbrica.
• Robotica: navigazione basata sulla visione, evitamento degli ostacoli e riconoscimento degli oggetti su robot autonomi e droni.
• Agricoltura intelligente: monitoraggio della salute delle colture, rilevamento dei parassiti e stima della resa usando la visione artificiale in agricoltura.
• Analisi per il commercio al dettaglio: analisi dei flussi di clienti, monitoraggio degli scaffali e tracciamento delle scorte con inferenza edge in tempo reale.

Riepilogo#

In questa guida hai imparato a esportare i modelli Ultralytics YOLO in formato DEEPX e a distribuirli sull'hardware NPU DEEPX. La pipeline di esportazione usa la calibrazione INT8 e il compilatore dx_com per generare un binario .dxnn ottimizzato per l'hardware, mentre il runtime dx_engine gestisce l'inferenza sul dispositivo.

Insieme, Ultralytics YOLO e le NPU DEEPX eseguono workload di visione artificiale su dispositivi embedded ed edge, con throughput elevato e consumi ridotti per applicazioni in tempo reale.

Per maggiori dettagli sull'utilizzo, visita il sito ufficiale di DEEPX.

Domande frequenti#