Esportazione CVflow di Ambarella per i modelli Ultralytics YOLO#

Per distribuire i modelli Ultralytics YOLO sui SoC Ambarella è necessario compilarli con gli strumenti di compilazione Ambarella; inoltre, 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, validazione ed esportazione, consentendo agli sviluppatori di generare modelli ottimizzati per una distribuzione efficiente sull'hardware Ambarella.

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

Il formato di checkpoint AmbaPB è un'estensione specifica di Ambarella della specifica ONNX IR che supporta le primitive di calcolo 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 che viene eseguito sulla scheda.

Che cos'è Ambarella?#

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

Che cos'è CVflow?#

CVflow è l'architettura di elaborazione visiva di Ambarella. Usa un motore di visione dedicato, separato da CPU e 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 e consentono il rilevamento di oggetti in tempo reale entro i limiti di consumo energetico delle telecamere.
• Addestramento con consapevolezza della compressione: SpongeTorch applica il pruning durante l'addestramento per aiutare il modello a mantenere l'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), la codifica video ultra-HD e CVflow per supportare diversi sistemi di telecamere a basso consumo, consentendo a un singolo SoC Ambarella di gestire l'intera pipeline della telecamera AI.

Panoramica del flusso di lavoro#

La pipeline si articola in sei fasi:

1. Addestramento con consapevolezza della compressione — esegui l'addestramento con una configurazione SpongeKit (amba_config) affinché SpongeTorch applichi progressivamente il pruning non strutturato durante l'addestramento. Quando l'accuratezza della quantizzazione post-training (PTQ) non è accettabile, SpongeTorch supporta anche l'addestramento con consapevolezza della quantizzazione (QAT), ma questo percorso non è ancora integrato in questa integrazione di Ultralytics ed è previsto per una versione futura.
2. Esportazione ONNX — esporta il checkpoint compresso con la stessa configurazione 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. Validazione host — esegui il modello compilato *.ambapb.ckpt.onnx tramite Ultralytics predict/val usando il backend AmbaPB per verificarne l'accuratezza prima della distribuzione.
5. Conversione Cavalry — converti il checkpoint AmbaPB convalidato in un binario Cavalry con gli strumenti dell'SDK.
6. Esecuzione sul dispositivo — esegui il binario Cavalry sul dispositivo con la libreria runtime dell'SDK Ambarella.

Il flusso di lavoro 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 wheel spongetorch distribuito insieme a esso:

# 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), quindi gli strumenti di compilazione dell'SDK devono essere installati e presenti nel tuo PATH prima di eseguire l'inferenza o la validazione con modelli compilati.

File di configurazione SpongeKit#

SpongeTorch utilizza 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 del tuo SDK Ambarella. Per garantire coerenza tra addestramento, validazione e distribuzione, usa la configurazione di addestramento ogni volta che la validazione deve 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 generale per l'esportazione:

Addestramento con consapevolezza della compressione#

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

from ultralytics import YOLO

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

Quando viene 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 passaggi, così la rete impara a mantenere l'accuratezza diventando al contempo sparsa. Il checkpoint addestrato memorizza lo stato sparso di SpongeTorch (tensori _orig/_mask), necessario in seguito per l'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

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

Esporta in ONNX#

Esporta il checkpoint compresso usando la stessa configurazione amba_config dell'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 ricostruisce il modello, riapplica spongetorch.prepare() con la tua configurazione, ricarica i pesi del checkpoint sparso nella struttura preparata e crea una traccia ONNX con la fusione Conv+BN disabilitata, 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 le dimensioni dell'input, mentre il backend AmbaPB legge queste informazioni da un file sidecar metadata.yaml accanto al modello compilato. Se gli strumenti di compilazione dell'SDK non creano questo file sidecar, 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.

Compila con gli strumenti dell'SDK#

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 pianificazione della memoria — e producono il checkpoint AmbaPB per la validazione host.

La PTQ applica la quantizzazione INT8 usando immagini di calibrazione (preparate come descritto nella guida alla compilazione dell'SDK) e gli strumenti di compilazione bilanciano l'accuratezza con la latenza in esecuzione: mappare più operazioni su INT8 riduce la latenza ma può diminuire l'accuratezza, mentre mantenere più operazioni in FP16 preserva l'accuratezza a costo di una latenza maggiore. Quando la PTQ non raggiunge l'obiettivo di accuratezza con il livello INT8 richiesto dai limiti di latenza, la soluzione prevista è la QAT con SpongeTorch: addestra il modello a tollerare una quantizzazione INT8 più aggressiva, recuperando accuratezza con un punto operativo a latenza inferiore. La QAT non è ancora disponibile in questa integrazione ed è prevista 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 tramite 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 dell'accuratezza prima della distribuzione sull'hardware e include tutti gli effetti della quantizzazione del compilatore. Se accanto al modello compilato si trova 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/output a scopo di debug.

Converti in un binario Cavalry#

Dopo che il checkpoint AmbaPB supera la validazione host, usa gli strumenti di compilazione dell'SDK per convertirlo in un binario Cavalry per il dispositivo di destinazione, seguendo la guida alla compilazione dell'SDK. Il binario Cavalry è il formato eseguito sulla scheda dalla libreria runtime dell'SDK.

Distribuisci sulla scheda#

Carica il binario Cavalry sul dispositivo Ambarella usando il runtime dell'SDK Ambarella. Il pre-processing e il post-processing devono corrispondere alla configurazione per cui è stato compilato il modello di rilevamento: input RGB con letterbox nell'intervallo 0–255 e decodifica standard dei risultati del rilevamento YOLO. Consulta la documentazione di distribuzione dell'SDK per le API runtime.

Esportazione senza SpongeTorch#

Se non ti serve il pruning di SpongeTorch in fase di 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 risultante con gli strumenti di compilazione dell'SDK, che eseguono autonomamente la quantizzazione post-training. Questo percorso sacrifica parte delle prestazioni in esecuzione e dell'accuratezza quantizzata in favore di un flusso di lavoro più semplice, senza dipendere da spongetorch durante l'addestramento.

Applicazioni nel mondo reale#

I modelli Ultralytics YOLO sui SoC Ambarella CVflow alimentano la visione edge sempre attiva:

• Telecamere di sicurezza AI: rilevamento in tempo reale di persone e veicoli su telecamere IP 4K con un consumo inferiore a 3 W.
• Droni e robotica: rilevamento e tracciamento di oggetti a bordo per la navigazione, le ispezioni e le 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 consapevolezza della compressione tramite SpongeTorch (amba_config/amba_chipset), esportazione ONNX del checkpoint compresso, compilazione offline in un checkpoint AmbaPB con gli strumenti dell'SDK, validazione host tramite Ultralytics e conversione in un binario Cavalry per la distribuzione sul dispositivo con l'SDK Ambarella.

Per altri dispositivi edge AI, 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à di esportazione e la pagina delle integrazioni.

Domande frequenti#