Link to this sectionEsportazione Ambarella CVflow per modelli Ultralytics YOLO#

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

Link to this sectionChe cos'è Ambarella CVflow?#

Ambarella è un'azienda di semiconduttori con sede a Santa Clara, nota per i suoi SoC di visione AI a basso consumo, ampiamente utilizzati in telecamere di sicurezza IP, dash cam, droni, robotica e sistemi automobilistici. I suoi chip sono costruiti attorno a CVflow®, un'architettura dedicata di elaborazione vettoriale neurale (l'acceleratore AI on-chip, o NPU) che offre un throughput di inferenza elevato a consumi molto bassi — il CV72S esegue carichi di lavoro AI per telecamere di sicurezza 4K sotto i 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:

Link to this sectionPerché distribuire YOLO su Ambarella?#

• Prestazioni per watt: i SoC CVflow sono progettati per l'AI edge sempre attiva, eseguendo rilevamento di oggetti in tempo reale entro i budget energetici tipici delle telecamere.
• Addestramento consapevole della compressione: SpongeTorch applica ottimizzazioni consapevoli della potatura e della quantizzazione durante l'addestramento, in modo che il modello impari a mantenere l'accuratezza diventando compatibile con la NPU.
• Validazione host bit-exact: il modello compilato AmbaPB viene eseguito tramite predict/val di Ultralytics sulla tua workstation esattamente come verrà eseguito sul chip, così puoi 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.

Link to this sectionPanoramica 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 potatura/quantizzazione progressivamente durante l'addestramento.
2. Esportazione ONNX — esporta il checkpoint compresso con la stessa 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 predict/val di Ultralytics tramite il backend AmbaPB, quindi distribuiscilo sulla scheda.

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

Link to this sectionPrerequisiti#

Link to this sectionInstallazione#

Installa questo fork di Ultralytics, quindi installa le wheel della toolchain Ambarella dalla distribuzione 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), quindi la toolchain deve essere installata e presente nel tuo PATH prima di eseguire l'inferenza o la validazione con i modelli compilati.

Link to this sectionFile 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à della potatura, impostazioni di quantizzazione e pianificazione della compressione. Ottieni esempi di configurazioni 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.

Link to this sectionArgomenti Amba#

Due argomenti controllano l'integrazione di SpongeTorch tra le modalità train, val ed export:

Il fork aggiunge anche un argomento generale di esportazione:

Link to this sectionAddestramento 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 avvolge il modello e l'ottimizzatore con spongetorch.prepare() durante la configurazione. La compressione viene applicata progressivamente secondo una pianificazione a fasi, in modo che la rete impari a rimanere accurata diventando sparsa e adatta alla quantizzazione. Il checkpoint addestrato memorizza lo stato sparso di SpongeTorch (tensori _orig/_mask), che il passaggio di esportazione richiede successivamente. Il file di configurazione viene copiato nella directory di esecuzione come amba_config.prototxt per scopi di riproducibilità.

Link to this sectionValidazione 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 che la struttura di compressione venga preservata. Confronta l'mAP con la tua baseline non compressa; se il calo di accuratezza è troppo elevato, regola la configurazione SpongeKit e riaddestra.

Link to this sectionEsportazione in ONNX#

Esporta il checkpoint compresso con la stessa amba_config usata nell'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 traccia verso ONNX con la fusione Conv+BN disabilitata — producendo un grafo nella forma esatta prevista dal compilatore CVflow.

Link to this sectionPreservazione 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 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 *.ambapb.ckpt.onnx o *.ambapb.fastckpt.onnx compilato.

Link to this sectionCompilazione 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.

Link to this sectionEsecuzione 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 tramite cvflowbackend, eseguendo il modello bit-exactly 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 hardware, inclusi tutti gli effetti di quantizzazione del compilatore. Se un file metadata.yaml si trova accanto al modello compilato, il backend legge i nomi delle classi, lo stride e le informazioni sul task da esso. Il backend utilizza la modalità di inferenza CVflow acinf per impostazione predefinita; imposta la variabile d'ambiente ULTRALYTICS_AMBAPB_DEBUG=1 per registrare i dettagli di input/output per il debug.

Link to this sectionDistribuzione sulla scheda#

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

Link to this sectionEsportazione 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 l'ONNX risultante con la toolchain CVflow, che esegue essa stessa la quantizzazione post-addestramento. Questo percorso scambia alcune prestazioni NPU e precisione quantizzata per un flusso di lavoro più semplice senza dipendenza da spongetorch in fase di addestramento.

Link to this sectionApplicazioni 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.

Link to this sectionRiepilogo#

Questa guida in anteprima ha delineato l'attuale flusso di lavoro per distribuire modelli Ultralytics YOLO su 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-exactly del modello compilato tramite Ultralytics prima della distribuzione sulla scheda.

Per altri target di edge AI, consulta le guide correlate 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.

Link to this sectionFAQ#

Link to this sectionPosso esportare un modello YOLO direttamente nel formato Ambarella con model.export()?#

No. Non esiste una destinazione format="ambarella". Esporta in ONNX (opzionalmente con compressione SpongeTorch tramite amba_config), quindi compila il modello ONNX in AmbaPB offline con la toolchain CVflow di Ambarella dall'SDK.

Link to this sectionQuali chip Ambarella possono eseguire i modelli Ultralytics YOLO?#

Può essere preso come target qualsiasi SoC basato su CVflow supportato dalla tua toolchain CVflow, incluse le famiglie CV72/CV75 per telecamere AI, CV5/CV52 per droni e robotica e CV3-AD per l'automobilistico. L'argomento amba_chipset configura l'obiettivo di ottimizzazione di SpongeTorch; seleziona il target corrispondente separatamente durante la compilazione. Le stringhe dei chipset accettate e la disponibilità dipendono dalla release dell'SDK installata.

Link to this sectionChe cos'è SpongeTorch e ne ho bisogno?#

SpongeTorch è il toolkit di compressione dei modelli di Ambarella, integrato nel fork Ambarella di Ultralytics per la potatura e l'addestramento consapevole della quantizzazione. È facoltativo: un'esportazione ONNX standard di Ultralytics può anche essere compilata con la toolchain CVflow utilizzando la quantizzazione post-addestramento, a un certo costo in termini di prestazioni NPU e precisione quantizzata.

Link to this sectionDove posso ottenere l'SDK Ambarella, SpongeTorch e la toolchain CVflow?#

Sono proprietari e non su PyPI. Registrati nella Ambarella Developer Zone per richiedere l'accesso all'SDK; le wheel spongetorch e cvflowbackend e il compilatore CVflow sono forniti con la distribuzione SDK.

Link to this sectionCome posso controllare l'accuratezza del modello compilato prima di distribuirlo?#

Esegui yolo val model=model.ambapb.ckpt.onnx data=your_data.yaml con il fork Ambarella installato. Il backend AmbaPB esegue il modello compilato bit-exactly come viene eseguito sul motore AI CVflow, quindi l'mAP riportato include tutti gli effetti di quantizzazione del compilatore.