Esportazione per Ambarella CVflow dei modelli Ultralytics YOLO#

La distribuzione dei modelli Ultralytics YOLO sui SoC Ambarella richiede la compilazione del modello con gli strumenti di compilazione Ambarella; i modelli ottimizzati per l'architettura CVflow offrono prestazioni migliori in fase di inferenza. Questo fork di Ultralytics integra direttamente il toolkit di compressione SpongeTorch di Ambarella nella pipeline di addestramento, convalida ed esportazione, consentendo agli sviluppatori di generare modelli ottimizzati per una distribuzione efficiente sull'hardware Ambarella.

Questa guida illustra l'attuale flusso di lavoro di distribuzione per il rilevamento di oggetti, dall'addestramento consapevole della compressione all'inferenza sul dispositivo (per l'intera pipeline, consulta la panoramica del flusso di lavoro).

Il formato di checkpoint AmbaPB è un'estensione specifica di Ambarella della specifica ONNX IR, che supporta le primitive computazionali CVflow e include gli artefatti generati dagli strumenti SDK. È l'artefatto lato host usato per convalidare l'accuratezza del modello compilato prima della distribuzione; il binario Cavalry separato prodotto per il dispositivo di destinazione è quello eseguito sulla scheda.

Chi è Ambarella?#

Ambarella, con sede a Santa Clara, in California, è un'azienda di semiconduttori che progetta SoC per l'IA edge. I suoi processori combinano elaborazione del segnale d'immagine, codifica video e calcolo IA sul chip e vengono usati in dispositivi per la sicurezza, il settore automobilistico, la robotica, l'industria e il mercato consumer.

Che cos'è CVflow?#

CVflow è l'architettura di elaborazione della visione di Ambarella. Usa un motore di visione dedicato, separato dalla CPU e dalla GPU, per eseguire carichi di lavoro di visione artificiale e reti neurali. I modelli addestrati con framework come PyTorch vengono compilati nel formato nativo di CVflow con l'SDK Ambarella prima di essere eseguiti sul motore.

Famiglie di SoC CVflow attuali e relative applicazioni tipiche:

Perché distribuire YOLO su Ambarella?#

• Prestazioni per watt: i SoC CVflow sono progettati per l'IA edge sempre attiva ed eseguono il rilevamento di oggetti in tempo reale rispettando i limiti di consumo energetico tipici delle telecamere.
• Addestramento consapevole della compressione: SpongeTorch applica il pruning durante l'addestramento per aiutare il modello a mantenere la propria accuratezza diventando al contempo più sparso ed efficiente per la distribuzione su CVflow.
• Pipeline per telecamere integrata: i SoC Ambarella combinano un processore del segnale d'immagine (ISP), codifica video ultra-HD e CVflow per supportare diversi sistemi di telecamere con consumi ridotti; un singolo SoC Ambarella gestisce quindi l'intera pipeline della telecamera IA.

Panoramica del flusso di lavoro#

La pipeline si articola in sei fasi:

1. Addestramento consapevole della compressione — addestra con una configurazione SpongeKit (amba_config) affinché SpongeTorch applichi progressivamente il pruning non strutturato durante l'addestramento. Se l'accuratezza della quantizzazione post-addestramento (PTQ) non è soddisfacente, SpongeTorch supporta anche l'addestramento consapevole della quantizzazione (QAT), ma questo flusso non è ancora integrato in questa integrazione di Ultralytics ed è previsto per una versione futura.
2. Esportazione ONNX — esporta il checkpoint compresso con lo stesso amba_config, mantenendo la struttura di compressione nel grafo ONNX.
3. Compilazione — compila il modello ONNX in un checkpoint AmbaPB con gli strumenti di compilazione dell'SDK, che applicano la PTQ per il motore CVflow.
4. Convalida sull'host — esegui il modello compilato *.ambapb.ckpt.onnx tramite Ultralytics predict/val con il backend AmbaPB per verificarne l'accuratezza prima della distribuzione.
5. Conversione Cavalry — converti il checkpoint AmbaPB convalidato in un binario Cavalry usando gli strumenti SDK.
6. Esecuzione sul dispositivo — esegui il binario Cavalry sul dispositivo con la libreria runtime dell'SDK Ambarella.

Il flusso di addestramento ed esportazione con SpongeTorch è facoltativo e può essere sostituito da una semplice esportazione ONNX (consulta Esportazione senza SpongeTorch).

Prerequisiti#

Installazione#

Installa questo fork di Ultralytics, quindi configura l'SDK Ambarella CVflow — che include gli strumenti di compilazione e la libreria cvflowbackend — e installa il pacchetto wheel spongetorch distribuito insieme all'SDK:

# Install this Ultralytics fork from source
git clone https://github.com/Ambarella-Inc/ultralytics
cd ultralytics
git checkout amba_v8.4.46
pip install -e .

# Access and set up the Ambarella SDK compilation tools
# After the environment is ready, install the spongetorch library
pip install /path/to/spongetorch-*.whl

AutoBackend individua cvflowbackend tramite il comando tv2 degli strumenti di compilazione dell'SDK (tv2 -libpath cvflowbackend); pertanto, gli strumenti di compilazione dell'SDK devono essere installati e disponibili nel tuo PATH prima di eseguire inferenze o convalide con modelli compilati.

File di configurazione SpongeKit#

SpongeTorch usa un file di configurazione SpongeKit (formato protobuf-text, .prototxt) che definisce i passaggi di pruning, inclusi gli obiettivi di sparsità e la pianificazione della compressione. Recupera le configurazioni di esempio e la documentazione dello schema corrispondente dalla versione dell'SDK Ambarella in uso. Per garantire coerenza tra addestramento, convalida e distribuzione, usa la configurazione di addestramento ogni volta che la convalida richiede di preparare nuovamente il modello e usa sempre la stessa configurazione quando esporti un checkpoint compresso.

Argomenti Amba#

Due argomenti controllano l'integrazione di SpongeTorch nelle modalità train, val e export:

Il fork aggiunge anche un argomento di esportazione generico:

Addestramento consapevole della compressione#

Addestra (o perfeziona) il modello con la compressione SpongeTorch attivata:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")
model.train(
    data="coco8.yaml",
    epochs=100,
    amba_config="config.prototxt",
    amba_chipset="CV72",
)

Quando è impostato amba_config, durante la configurazione il trainer avvolge il modello e l'ottimizzatore con spongetorch.prepare(). La compressione viene applicata progressivamente secondo una pianificazione a passi, così la rete impara a mantenere l'accuratezza diventando al contempo sparsa. Il checkpoint addestrato memorizza lo stato sparso di SpongeTorch (tensori _orig/_mask), necessari nel successivo passaggio di esportazione. Il file di configurazione viene copiato nella directory dell'esecuzione come amba_config.prototxt per garantire la riproducibilità.

Convalida del checkpoint compresso#

Convalida l'accuratezza prima della compilazione, usando la stessa configurazione:

yolo val model=runs/detect/train/weights/best.pt data=coco8.yaml \
  amba_config=config.prototxt amba_chipset=CV72

Se necessario, il convalidatore riapplica spongetorch.prepare() e disattiva la fusione Conv+BN per preservare la struttura di compressione. Confronta mAP con il tuo riferimento non compresso; se il calo di accuratezza è eccessivo, modifica la configurazione SpongeKit e ripeti l'addestramento.

Esportazione in ONNX#

Esporta il checkpoint compresso usando la stessa amba_config usata durante l'addestramento:

from ultralytics import YOLO

model = YOLO("runs/detect/train/weights/best.pt")
model.export(
    format="onnx",
    amba_config="config.prototxt",
    amba_chipset="CV72",
)

L'esportatore ricrea il modello, riapplica spongetorch.prepare() con la tua configurazione, ricarica i pesi sparsi del checkpoint nella struttura predisposta e genera una traccia ONNX con la fusione Conv+BN disattivata, producendo un grafo nel formato esatto previsto dagli strumenti di compilazione dell'SDK.

Mantieni i metadati del modello#

L'esportazione ONNX incorpora nel file ONNX l'attività del modello, i nomi delle classi, lo stride e la dimensione dell'input, mentre il backend AmbaPB legge queste informazioni da un file associato metadata.yaml accanto al modello compilato. Se gli strumenti di compilazione dell'SDK non creano questo file associato, estrailo dal modello ONNX prima della compilazione:

import onnx

from ultralytics.utils import YAML

model = onnx.load("model.onnx")
YAML.save("metadata.yaml", {item.key: item.value for item in model.metadata_props})

Mantieni metadata.yaml nella stessa directory del file compilato *.ambapb.ckpt.onnx o *.ambapb.fastckpt.onnx.

Compilazione con SDK Tools#

Compila il modello ONNX esportato per il chipset di destinazione usando gli strumenti di compilazione dell'SDK e seguendo la guida alla compilazione dell'SDK. Gli strumenti mappano il grafo sul motore AI CVflow — applicando PTQ, pianificazione e gestione della memoria — e generano il checkpoint AmbaPB per la convalida sull'host.

PTQ applica la quantizzazione INT8 usando immagini di calibrazione (preparate come descritto nella guida alla compilazione dell'SDK) e gli strumenti di compilazione bilanciano la precisione rispetto alla latenza in esecuzione: mappare più operazioni su INT8 riduce la latenza, ma può diminuire la precisione, mentre mantenere più operazioni in FP16 preserva la precisione a una latenza maggiore. Quando PTQ non riesce a raggiungere il livello di precisione desiderato con la quantizzazione INT8 necessaria per il tuo budget di latenza, la soluzione prevista è QAT con SpongeTorch: addestra il modello a tollerare una quantizzazione INT8 più aggressiva, recuperando precisione con un punto operativo a latenza inferiore. QAT non è ancora disponibile in questa integrazione ed è previsto per una versione futura.

Esegui l'inferenza con il modello compilato#

Il modello AmbaPB compilato viene caricato direttamente tramite l'API Ultralytics: AutoBackend rileva il suffisso .ambapb e instrada l'inferenza attraverso cvflowbackend, eseguendo il modello come verrà eseguito sul motore AI:

from ultralytics import YOLO

model = YOLO("model.ambapb.ckpt.onnx")

# Inference
results = model("https://ultralytics.com/images/bus.jpg")

# Validation
metrics = model.val(data="coco8.yaml")

Questo è il controllo finale della precisione prima della distribuzione sull'hardware, inclusi tutti gli effetti della quantizzazione del compilatore. Se accanto al modello compilato è presente un file metadata.yaml, il backend ne legge i nomi delle classi, lo stride e le informazioni sull'attività. Per impostazione predefinita, il backend usa la modalità di inferenza CVflow acinf; imposta la variabile d'ambiente ULTRALYTICS_AMBAPB_DEBUG=1 per registrare i dettagli di input e output a scopo di debug.

Converti in un binario Cavalry#

Dopo aver superato la convalida sull'host, converti il checkpoint AmbaPB in un binario Cavalry per il dispositivo di destinazione usando gli strumenti di compilazione dell'SDK e seguendo la guida alla compilazione dell'SDK. Il binario Cavalry è il formato eseguito dalla libreria runtime dell'SDK sulla scheda.

Distribuisci sulla scheda#

Carica il binario Cavalry sul tuo dispositivo Ambarella usando il runtime dell'SDK Ambarella. Il pre-processing e il post-processing devono corrispondere a quelli per cui è stato compilato il modello di rilevamento: input RGB con letterboxing nell'intervallo 0–255 e decodifica standard delle rilevazioni YOLO negli output. Consulta la documentazione di distribuzione dell'SDK per le API runtime.

Esportazione senza SpongeTorch#

Se non ti serve il pruning di SpongeTorch durante l'addestramento, anche la pipeline standard di Ultralytics produce un modello compilabile con gli strumenti dell'SDK:

yolo export model=yolo26n.pt format=onnx

Compila il modello ONNX ottenuto con gli strumenti di compilazione dell'SDK, che eseguono autonomamente la quantizzazione post-addestramento. Questo percorso sacrifica parte delle prestazioni in esecuzione e della precisione quantizzata per semplificare il flusso di lavoro, senza dipendere da spongetorch durante l'addestramento.

Applicazioni nel mondo reale#

I modelli Ultralytics YOLO sui SoC Ambarella CVflow consentono la visione sempre attiva all'edge:

• Telecamere di sicurezza AI: rilevamento in tempo reale di persone e veicoli su telecamere IP 4K, con un budget energetico inferiore a 3 W.
• Droni e robotica: rilevamento e tracciamento degli oggetti a bordo per navigazione, ispezione e consegne su chip della classe CV5.
• Analisi industriale e retail: conteggio delle persone su più flussi, rilevamento dei DPI e monitoraggio degli scaffali su dispositivi edge.

Riepilogo#

Questa guida ha illustrato il flusso di lavoro attuale per distribuire i modelli Ultralytics YOLO sui SoC Ambarella CVflow: addestramento con SpongeTorch consapevole della compressione (amba_config/amba_chipset), esportazione ONNX del checkpoint compresso, compilazione offline in un checkpoint AmbaPB con gli strumenti SDK, convalida sull'host tramite Ultralytics e conversione in un binario Cavalry per la distribuzione sul dispositivo con l'SDK Ambarella.

Per altre piattaforme AI edge, consulta le guide correlate per Hailo, Rockchip RKNN, Sony IMX500, Qualcomm QNN, DEEPX e Axelera. Per l'elenco completo dei formati di esportazione, consulta la documentazione della modalità Export e la pagina delle integrazioni.

Domande frequenti#