Esportazione Ambarella CVflow per modelli Ultralytics YOLO#

La distribuzione dei modelli Ultralytics YOLO sui SoC Ambarella richiede un formato di modello ottimizzato per il motore di IA CVflow®. Questo fork di Ultralytics integra il toolkit di compressione SpongeTorch di Ambarella direttamente nella pipeline di addestramento, validazione ed esportazione, consentendoti di produrre modelli potati e ottimizzati per la quantizzazione che vengono eseguiti in modo efficiente sull'hardware Ambarella. Questa guida descrive il flusso di lavoro corrente per il rilevamento di oggetti: addestramento consapevole della compressione, esportazione ONNX, compilazione con la toolchain CVflow e inferenza con il modello AmbaPB compilato.

Che cos'è Ambarella CVflow?#

Ambarella è un'azienda di semiconduttori con sede a Santa Clara nota per i suoi SoC di visione IA a basso consumo, ampiamente utilizzati in telecamere di sicurezza IP, dash cam, droni, robotica e sistemi automobilistici. I suoi chip sono basati su CVflow®, un'architettura di elaborazione vettoriale neurale dedicata (l'acceleratore IA on-chip o NPU) che offre una velocità di throughput di inferenza elevata a consumi molto ridotti — il CV72S esegue carichi di lavoro di IA per telecamere di sicurezza 4K a meno di 3 W. I modelli addestrati in framework standard come PyTorch vengono compilati nel formato nativo di CVflow con la toolchain offline di Ambarella prima della distribuzione.

Famiglie di SoC CVflow attuali e le loro applicazioni tipiche:

Perché distribuire YOLO su Ambarella?#

• Prestazioni per watt: i SoC CVflow sono progettati per l'IA edge sempre attiva, eseguendo il rilevamento di oggetti in tempo reale entro budget energetici tipici delle telecamere.
• Addestramento consapevole della compressione: SpongeTorch applica l'ottimizzazione basata su pruning e quantizzazione durante l'addestramento, in modo che il modello impari a mantenere l'accuratezza pur diventando compatibile con la NPU.
• Validazione host bit-exact: il modello AmbaPB compilato viene eseguito tramite Ultralytics predict/val sulla tua workstation esattamente come verrà eseguito sul chip, permettendoti di misurare l'mAP quantizzato prima di toccare l'hardware.
• Pipeline telecamera integrata: i SoC Ambarella combinano il motore AI con un ISP e codificatori video, rendendoli una soluzione a chip singolo per telecamere AI.

Panoramica del flusso di lavoro#

La pipeline ha quattro fasi:

1. Addestramento consapevole della compressione — addestra con una configurazione SpongeKit (amba_config) in modo che SpongeTorch applichi pruning e quantizzazione in modo progressivo durante l'addestramento.
2. Esportazione ONNX — esporta il checkpoint compresso con lo stesso amba_config, preservando la struttura di compressione nel grafo ONNX.
3. Compilazione CVflow — compila il modello ONNX in un artefatto AmbaPB con la toolchain CVflow.
4. Inferenza e validazione — esegui il modello compilato *.ambapb.ckpt.onnx tramite Ultralytics predict/val utilizzando il backend AmbaPB, quindi effettua il deployment sulla scheda.

L'addestramento con SpongeTorch e l'esportazione con consapevolezza di SpongeTorch possono essere sostituiti da una semplice esportazione ONNX se non hai bisogno delle ottimizzazioni in fase di addestramento di SpongeTorch (vedi Esportazione senza SpongeTorch).

Prerequisiti#

Installazione#

Installa questo fork di Ultralytics, quindi installa le wheel della toolchain Ambarella dalla distribuzione dell'SDK:

!!! Tip "Installazione"

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

# Install Ambarella toolchain wheels from the SDK
pip install /path/to/spongetorch-*.whl
pip install /path/to/cvflowbackend-*.whl

Il backend di inferenza AmbaPB individua cvflowbackend tramite il comando tv2 della toolchain CVflow (tv2 -libpath cvflowbackend), pertanto la toolchain deve essere installata e presente nel tuo PATH prima di eseguire l'inferenza o la validazione con i modelli compilati.

File di configurazione SpongeKit#

SpongeTorch è guidato da un file di configurazione SpongeKit (formato protobuf-text, .prototxt) che definisce i passaggi di compressione da applicare: obiettivi di sparsità del pruning, impostazioni di quantizzazione e programmazione della compressione. Ottieni configurazioni di esempio e la documentazione dello schema corrispondente dalla tua release dell'SDK Ambarella. Usa la configurazione di addestramento ogni volta che la validazione deve preparare un modello non preparato 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 di esportazione:

Addestramento consapevole della compressione#

Addestra (o perfeziona) il tuo 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 amba_config è impostato, il trainer racchiude il modello e l'ottimizzatore con spongetorch.prepare() durante la configurazione. La compressione viene applicata progressivamente secondo una pianificazione a step, in modo che la rete impari a rimanere accurata pur diventando sparsa e favorevole alla quantizzazione. Il checkpoint addestrato memorizza lo stato sparso di SpongeTorch (tensor _orig/_mask), richiesto successivamente dalla fase di esportazione. Il file di configurazione viene copiato nella directory di esecuzione come amba_config.prototxt per garantire la riproducibilità.

Validazione del checkpoint compresso#

Valida 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

Il validatore riapplica spongetorch.prepare() quando necessario e disabilita la fusione Conv+BN in modo da preservare la struttura di compressione. Confronta l'mAP rispetto alla tua baseline non compressa; se il calo di accuratezza è eccessivo, regola la configurazione SpongeKit ed esegui nuovamente l'addestramento.

Esportazione in ONNX#

Esporta il checkpoint compresso con lo stesso amba_config utilizzato 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 ricostruisce il modello, riapplica spongetorch.prepare() con la tua configurazione, ricarica i pesi del checkpoint sparso nella struttura preparata ed esegue il tracing in ONNX con la fusione Conv+BN disabilitata, producendo un grafo nella forma esatta attesa dal compilatore CVflow.

Preservazione dei metadati del modello#

L'esportazione ONNX incorpora il task del modello, i nomi delle classi, lo stride e la dimensione di input nel file ONNX, mentre il backend AmbaPB legge queste informazioni da un file sidecar metadata.yaml accanto al modello compilato. A meno che il tuo compilatore CVflow non crei questo 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.

Compilazione con la toolchain CVflow#

Compila il modello ONNX esportato per il tuo chipset di destinazione utilizzando il compilatore CVflow dall'SDK, seguendo la guida alla compilazione dell'SDK. Il compilatore mappa il grafo sul motore AI CVflow (quantizzazione, pianificazione, pianificazione della memoria) e produce l'artefatto distribuibile AmbaPB.

Esecuzione dell'inferenza con il modello compilato#

Il modello AmbaPB compilato si carica direttamente tramite l'API di Ultralytics: AutoBackend rileva il suffisso .ambapb e instrada l'inferenza attraverso cvflowbackend, eseguendo il modello con precisione bit-exact esattamente come girerà sul motore di IA:

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 di accuratezza prima della distribuzione sull'hardware, inclusi tutti gli effetti di quantizzazione del compilatore. Se un file metadata.yaml si trova accanto al modello compilato, il backend legge da esso i nomi delle classi, lo stride e le informazioni sul task. Per impostazione predefinita, il backend utilizza la modalità di inferenza CVflow acinf; imposta la variabile d'ambiente ULTRALYTICS_AMBAPB_DEBUG=1 per registrare i dettagli di input/output a fini di debug.

Distribuzione sulla scheda#

Carica il modello compilato sul tuo dispositivo Ambarella utilizzando il runtime dell'SDK Ambarella. La pre-elaborazione e la post-elaborazione devono corrispondere a quelle per cui il modello di rilevamento è stato compilato: input RGB letterboxed nell'intervallo 0–255 (il backend Ultralytics AmbaPB fornisce al modello compilato RGB 0–255) e decodifica di rilevamento YOLO standard sugli output. Fai riferimento alla documentazione di deployment dell'SDK per le API di runtime.

Esportazione senza SpongeTorch#

Se non hai bisogno delle ottimizzazioni di potatura e quantizzazione in fase di addestramento di SpongeTorch, la pipeline standard di Ultralytics produce anche un modello compilabile da CVflow:

yolo export model=yolo26n.pt format=onnx

Compila il file ONNX risultante con la toolchain CVflow, che esegue autonomamente la quantizzazione post-addestramento. Questo percorso sacrifica alcune prestazioni della NPU e l'accuratezza quantizzata in cambio di un flusso di lavoro più semplice senza alcuna dipendenza da spongetorch in fase di addestramento.

Applicazioni nel mondo reale#

I modelli Ultralytics YOLO su SoC Ambarella CVflow alimentano la visione sempre attiva all'edge:

• Telecamere di sicurezza AI: rilevamento di persone e veicoli in tempo reale su telecamere IP 4K entro un budget energetico inferiore a 3 W.
• Droni e robotica: rilevamento e tracciamento di oggetti a bordo per navigazione, ispezione e consegna su chip di classe CV5.
• Automobilistico: carichi di lavoro di percezione ADAS come il rilevamento di pedoni e veicoli su controller di dominio CV3-AD.
• Analisi industriale e al dettaglio: conteggio persone multi-flusso, rilevamento DPI e monitoraggio degli scaffali su apparecchiature edge.

Riepilogo#

Questa guida preliminare ha illustrato il flusso di lavoro attuale per distribuire i modelli Ultralytics YOLO sui SoC Ambarella CVflow: addestramento consapevole della compressione con SpongeTorch (amba_config/amba_chipset), esportazione ONNX del checkpoint compresso, compilazione offline in AmbaPB con la toolchain CVflow e validazione bit-exact del modello compilato tramite Ultralytics prima della distribuzione sulla scheda.

Per altri target di IA edge, consulta le guide correlate su Hailo, Rockchip RKNN, Sony IMX500, Qualcomm QNN, DEEPX e Axelera. Per l'elenco completo dei formati di esportazione, visita la documentazione della modalità di esportazione e la pagina delle integrazioni.

FAQ#