Esportazione DeepX per modelli Ultralytics YOLO

Il deploy di modelli di computer vision su hardware NPU specializzato richiede un formato di modello compatibile e ottimizzato. Esportare Ultralytics YOLO modelli in formato DeepX abilita un'inferenza efficiente e quantizzata a INT8 sugli acceleratori NPU DeepX. Questa guida ti accompagna attraverso la conversione dei tuoi modelli YOLO nel formato DeepX e il loro deploy su hardware basato su DeepX.

Cos'è DeepX?

DeepX è un'azienda di semiconduttori IA specializzata in Neural Processing Units (NPUs) progettate per un'deep learning inferenza efficiente dal punto di vista energetico all'edge. 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 deploy in cui la connettività cloud non è affidabile o desiderabile, come robotica, smart camera e sistemi di automazione industriale.

Formato di esportazione DeepX

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

Caratteristiche principali dei modelli DeepX

I modelli DeepX offrono diversi vantaggi per il deploy all'edge:

• Quantizzazione INT8: i modelli vengono quantizzati alla precisione INT8 durante l'esportazione, riducendo significativamente le dimensioni del modello e massimizzando il throughput della NPU. Scopri di più sulla quantizzazione dei modelli.
• Ottimizzato per NPU: Il formato .dxnn è compilato specificamente per l'hardware NPU DeepX, sfruttando unità di accelerazione dedicate per un'inferenza veloce 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.
• Accuratezza basata sulla calibrazione: L'esportazione utilizza una calibrazione basata su EMA con immagini di dataset reali per ridurre al minimo la perdita di accuratezza durante la quantizzazione.
• Output autosufficiente: La directory del modello esportato raggruppa il binario compilato, la configurazione di calibrazione e i metadati per un deploy semplificato.

Task supportati

Tutti i task standard di Ultralytics sono supportati per l'esportazione DeepX attraverso le famiglie di modelli YOLO26, YOLO11 e YOLOv8.

Esportazione in DeepX: Conversione del tuo modello YOLO

Esporta un modello Ultralytics YOLO nel 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 pacchetto del compilatore dx_com verrà installato automaticamente dal repository dell'SDK DeepX al primo tentativo di esportazione. Per istruzioni dettagliate e best practice relative al processo di installazione, consulta la nostra guida all'installazione Ultralytics. Se durante l'installazione dei pacchetti necessari per YOLO incontri delle difficoltà, consulta la nostra guida ai problemi comuni per soluzioni e suggerimenti.

Utilizzo

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/'

Argomenti di esportazione

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

Struttura 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 pacchetto del compilatore .dxnn il file è il binario del modello compilato che il runtime dx_engine carica direttamente sulla NPU. Il metadata.yaml contiene i nomi delle classi, la dimensione dell'immagine e altre informazioni utilizzate dalla pipeline di inferenza Ultralytics.

Deploy dei modelli DeepX YOLO esportati

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

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

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

Utilizzo

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

Visualizzazione con dxtron

dxtron è il visualizzatore di grafi 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

Benchmark

Il team di Ultralytics ha effettuato il benchmark dei modelli YOLO26, confrontando velocità e accuratezza tra PyTorch e DeepX.

sudo nano /boot/firmware/config.txt

dtparam=pciex1
dtparam=pciex1_gen=3

sudo reboot

Flusso di lavoro consigliato

1. Train il tuo modello utilizzando Ultralytics Modalità Train
2. Export in formato DeepX utilizzando model.export(format="deepx")
3. Valida la precisione con yolo val per verificare una perdita di quantizzazione minima
4. Predict usando yolo predict per una validazione qualitativa
5. Distribuisci la directory _deepx_model/ esportata sull'hardware NPU DeepX utilizzando il dx_engine runtime

Applicazioni nel mondo reale

I modelli YOLO distribuiti su hardware NPU DeepX sono adatti a una vasta gamma di applicazioni di edge AI:

• Sorveglianza intelligente: object detection in tempo reale per sistemi di sicurezza e monitoraggio con basso consumo energetico e senza dipendenza dal cloud.
• Automazione industriale: Controllo qualità su dispositivo, rilevamento difetti e monitoraggio dei processi in ambienti di fabbrica.
• Robotica: Navigazione basata sulla visione, evitamento ostacoli e riconoscimento oggetti su robot autonomi e droni.
• Agricoltura intelligente: Monitoraggio dello stato delle colture, rilevamento parassiti e stima della resa utilizzando computer vision in agricoltura.
• Analisi retail: Analisi del flusso clienti, monitoraggio scaffali e tracciamento dell'inventario con inferenza edge in tempo reale.

Riepilogo

In questa guida, hai imparato come esportare i modelli Ultralytics YOLO nel formato DeepX e distribuirli su hardware NPU DeepX. La pipeline di esportazione utilizza la calibrazione INT8 e il dx_com compilatore per produrre un binario .dxnn ottimizzato per l'hardware, mentre il dx_engine runtime 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 computer vision su dispositivi embedded ed edge, offrendo un'elevata velocità di trasmissione con un basso consumo energetico per applicazioni in tempo reale.

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

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

FAQ

Come esporto il mio modello Ultralytics YOLO nel formato DeepX?

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

from ultralytics import YOLO

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

Perché l'esportazione DeepX richiede la quantizzazione INT8?

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

Quali 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 che utilizza il modello .dxnn esportato può essere eseguita su qualsiasi piattaforma Linux (x86-64 e ARM64) supportata dal runtime dx_engine.

Qual è l'output di un'esportazione DeepX?

L'esportazione crea una directory (ad es. 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

Posso distribuire modelli addestrati personalizzati sull'hardware DeepX?

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

Quante immagini di calibrazione dovrei usare per l'esportazione DeepX?

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

Come installo il runtime DeepX per l'inferenza?

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