Link to this sectionEsportazione DEEPX per i modelli Ultralytics YOLO#

L'implementazione di modelli di computer vision su hardware NPU specializzato richiede un formato di modello compatibile e ottimizzato. Esportare i modelli Ultralytics YOLO nel formato DEEPX abilita un'inferenza efficiente e quantizzata INT8 sugli acceleratori NPU DEEPX. Questa guida ti accompagna nella conversione dei tuoi modelli YOLO nel formato DEEPX e nella loro implementazione su hardware basato su DEEPX.

Link to this sectionCos'è DEEPX?#

DEEPX è un'azienda di semiconduttori IA specializzata in Neural Processing Units (NPU) progettate per un'inferenza di deep learning edge ad alta efficienza energetica. Le NPU DEEPX sono progettate per applicazioni IA embedded e industriali esigenti, offrendo un throughput elevato con un consumo energetico minimo. Il loro hardware è particolarmente adatto a scenari di implementazione in cui la connettività cloud è inaffidabile o indesiderata, come robotica, smart camera e sistemi di automazione industriale.

Link to this sectionFormato di esportazione DEEPX#

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

Link to this sectionCaratteristiche principali dei modelli DEEPX#

I modelli DEEPX offrono diversi vantaggi per l'implementazione edge:

• Quantizzazione INT8: I modelli vengono quantizzati a precisione INT8 durante l'esportazione, riducendo significativamente le dimensioni del modello e massimizzando il throughput della NPU. Scopri di più sulla quantizzazione del modello.
• Ottimizzato per NPU: Il formato .dxnn viene compilato specificamente per l'hardware NPU DEEPX, sfruttando unità di accelerazione dedicate per un'inferenza rapida ed efficiente.
• Basso consumo energetico: Scaricando l'inferenza sulla NPU, i modelli DEEPX consumano molta meno energia rispetto a un'inferenza equivalente su CPU o GPU.
• Precisione basata sulla calibrazione: L'esportazione utilizza una calibrazione basata su EMA con immagini di dataset reali per ridurre al minimo la perdita di precisione durante la quantizzazione.
• Output autonomo: La directory del modello esportato raggruppa il binario compilato, la configurazione di calibrazione e i metadati per una facile implementazione.

Link to this sectionAttività supportate#

Tutte le attività standard di Ultralytics sono supportate per l'esportazione DEEPX attraverso le famiglie di modelli YOLO26, YOLO11 e YOLOv8.

Link to this sectionEsportazione in DEEPX: convertire il tuo modello YOLO#

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

Link to this sectionInstallazione#

Per installare i pacchetti richiesti, esegui:

# Install the required package for YOLO
pip install ultralytics

Il pacchetto del compilatore dx_com verrà installato automaticamente dal repository dell'SDK DEEPX alla prima esportazione. Per istruzioni dettagliate e best practice relative al processo di installazione, consulta la nostra guida all'installazione di Ultralytics. Se riscontri difficoltà durante l'installazione dei pacchetti richiesti per YOLO, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Link to this sectionUtilizzo#

Il formato DEEPX supporta le modalità Export, Predict e Validate. L'inferenza e la validazione vengono eseguite sull'hardware NPU DEEPX. Esporta il tuo modello, quindi caricalo per eseguire l'inferenza o validarne la precisione.

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 sectionArgomenti di esportazione#

Per maggiori dettagli sul processo di esportazione, visita la pagina della documentazione di Ultralytics sull'esportazione.

Link to this sectionStruttura di output#

Dopo un'esportazione riuscita, viene creata una directory del modello con il seguente 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.)

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

Link to this sectionImplementazione di modelli YOLO DEEPX esportati#

Una volta esportato con successo il tuo modello Ultralytics YOLO nel formato DEEPX, il passo successivo è l'implementazione di questi modelli sull'hardware NPU DEEPX.

Link to this sectionInstallazione del runtime#

L'inferenza richiede il driver NPU DEEPX, il runtime libdxrt e il pacchetto 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

Verifica che il runtime sia installato correttamente con dxrt-cli --version. Dovresti vedere un output simile 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

Una volta installato il runtime, esegui l'inferenza e la validazione sul tuo dispositivo DEEPX esattamente come mostrato nella sezione Utilizzo sopra: il file _deepx_model esportato si carica direttamente con YOLO(...).

Link to this sectionVisualizzazione con dxtron#

dxtron è il visualizzatore di grafici di DEEPX per ispezionare il modello .dxnn compilato.

Installa dxtron su Linux x86-64 scaricando il pacchetto .deb dall'SDK DEEPX e installandolo tramite 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

Quindi apri il tuo modello esportato:

dxtron yolo26n_deepx_model/yolo26n.dxnn

Link to this sectionBenchmark#

Il team di Ultralytics ha testato i 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 validazione per i benchmark di cui sopra è stata effettuata utilizzando coco128 per il rilevamento, coco128-seg per la segmentazione, coco8-pose per la stima della posa, imagenet100 per la classificazione e dota128 per i modelli OBB. Il tempo di inferenza non include la pre/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"

Link to this sectionFlusso di lavoro consigliato#

1. Addestra il tuo modello utilizzando la Modalità Addestramento di Ultralytics
2. Esporta nel formato DEEPX utilizzando model.export(format="deepx")
3. Valida l'accuratezza con yolo val per verificare una perdita di quantizzazione minima
4. Predici utilizzando yolo predict per una validazione qualitativa
5. Distribuisci la directory _deepx_model/ esportata sull'hardware NPU DEEPX utilizzando il runtime dx_engine

Link to this sectionApplicazioni nel mondo reale#

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

• Smart Surveillance: rilevamento di oggetti in tempo reale per sistemi di sicurezza e monitoraggio con basso consumo energetico e nessuna dipendenza dal cloud.
• Automazione industriale: controllo qualità on-device, rilevamento dei difetti e monitoraggio dei processi in ambienti di fabbrica.
• Robotica: navigazione basata sulla visione, evitamento degli ostacoli e riconoscimento degli oggetti su robot e droni autonomi.
• Agricoltura intelligente: monitoraggio della salute delle colture, rilevamento dei parassiti e stima della resa utilizzando la visione artificiale in agricoltura.
• Analisi della vendita al dettaglio: analisi del flusso dei clienti, monitoraggio degli scaffali e gestione dell'inventario con inferenza edge in tempo reale.

Link to this sectionRiepilogo#

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

La combinazione di Ultralytics YOLO e della tecnologia NPU di DEEPX fornisce una soluzione efficace per eseguire carichi di lavoro avanzati di visione artificiale su dispositivi embedded ed edge, offrendo un throughput elevato con un basso consumo energetico per applicazioni in tempo reale.

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

Inoltre, se desideri saperne di più su altre integrazioni di Ultralytics YOLO, visita la nostra pagina delle guide all'integrazione. Lì troverai molte risorse e approfondimenti utili.

Link to this sectionFAQ#

Link to this sectionCome esporto il mio modello Ultralytics YOLO nel formato DEEPX?#

Puoi esportare il tuo modello utilizzando il metodo export() in Python o tramite la CLI. L'esportazione abilita automaticamente la quantizzazione INT8 e utilizza un set di dati di calibrazione per ridurre al minimo la perdita di precisione. Il pacchetto del compilatore dx_com viene installato automaticamente se non è già presente.

from ultralytics import YOLO

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

Link to this sectionPerché l'esportazione DEEPX richiede la quantizzazione INT8?#

Le NPU DEEPX sono progettate per eseguire calcoli INT8 alla massima efficienza. Il compilatore dx_com quantizza il modello durante l'esportazione utilizzando la calibrazione basata su EMA con immagini reali del set di dati, consentendo alla NPU di fornire le sue massime prestazioni. L'INT8 è sempre applicato per le esportazioni DEEPX: se imposti int8=False, verrà ignorato con un avviso.

Link to this sectionQuali piattaforme sono supportate per l'esportazione DEEPX?#

L'esportazione (compilazione) del modello DEEPX richiede un host x86-64 Linux. Il passaggio di esportazione non è supportato su macchine ARM64 (aarch64) e Windows. L'inferenza utilizzando il modello .dxnn esportato può essere eseguita su qualsiasi piattaforma Linux (x86-64 e ARM64) supportata dal runtime dx_engine.

Link to this sectionQual è l'output di un'esportazione DEEPX?#

L'esportazione crea una directory (ad esempio, yolo26n_deepx_model/) contenente:

• yolo26n.dxnn — il binario NPU compilato
• config.json — impostazioni di calibrazione e pre-elaborazione
• metadata.yaml — metadati del modello inclusi nomi delle classi e dimensioni dell'immagine

Link to this sectionPosso distribuire modelli addestrati personalizzati sull'hardware DEEPX?#

Sì. Qualsiasi modello addestrato utilizzando la Modalità Addestramento di Ultralytics ed esportato con format="deepx" può essere distribuito sull'hardware NPU DEEPX, a condizione che utilizzi operazioni di livello supportate. L'esportazione supporta attività di rilevamento, segmentazione, stima della posa, riquadro di delimitazione orientato (OBB) e classificazione.

Link to this sectionQuante immagini di calibrazione dovrei utilizzare per l'esportazione DEEPX?#

La pipeline di esportazione DEEPX utilizza ogni immagine nel set di dati di calibrazione (dopo il filtro fraction) con il metodo di calibrazione EMA. Alcune centinaia di immagini sono solitamente sufficienti per una buona precisione di quantizzazione. Punta data a un set di dati più piccolo (o imposta fraction sotto 1.0) se il tempo di compilazione diventa un problema su set di dati di grandi dimensioni.

Link to this sectionCome installo il runtime DEEPX per l'inferenza?#

Il runtime DEEPX non è incluso con ultralytics e deve essere installato separatamente prima di eseguire l'inferenza. Su macchine Linux x86-64 e Linux ARM64 (ad esempio, Raspberry Pi 5), installa il driver NPU (dxrt-driver-dkms) e il runtime (libdxrt) dalle release GitHub di DEEPX-AI, quindi installa il wheel Python dx_engine fornito. Consulta la sezione Installazione del runtime sopra per i comandi passo dopo passo.