Esportazione CVflow di modelli Ultralytics YOLO#

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

Questa guida descrive il flusso di lavoro di distribuzione corrente per il rilevamento di oggetti, dall'addestramento consapevole della compressione fino all'inferenza sul dispositivo (vedi la Panoramica del flusso di lavoro per la pipeline completa).

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

Chi è Ambarella?#

Ambarella, con sede a Santa Clara, in California, è un'azienda di semiconduttori che progetta SoC di intelligenza artificiale edge. I suoi processori combinano l'elaborazione del segnale d'immagine, la codifica video e l'elaborazione AI on-chip, e sono utilizzati in dispositivi di sicurezza, automobilistici, robotici, industriali e di consumo.

Cos'è CVflow?#

CVflow è l'architettura di elaborazione visiva di Ambarella. Utilizza un motore visivo dedicato, separato dalla CPU e dalla GPU, per eseguire carichi di lavoro di visione artificiale e reti neurali. I modelli addestrati in framework come PyTorch vengono compilati nel formato nativo di CVflow con l'SDK di 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'AI edge sempre attiva ed eseguono il rilevamento degli oggetti in tempo reale entro i budget energetici tipici delle telecamere.
• Addestramento consapevole della compressione: SpongeTorch applica il potenziamento durante l'addestramento per aiutare il modello a mantenere l'accuratezza pur diventando più sparso e più efficiente per la distribuzione su CVflow.
• Pipeline di telecamera integrata: i SoC Ambarella combinano un processore del segnale d'immagine (ISP), la codifica video ultra-HD e CVflow per abilitare una varietà di sistemi di telecamere a basso consumo energetico, in modo che un singolo SoC Ambarella gestisca l'intera pipeline di telecamere AI.

Panoramica del flusso di lavoro#

La pipeline ha sei fasi:

1. Addestramento consapevole della compressione — addestra con una configurazione SpongeKit (amba_config) in modo che SpongeTorch applichi il potenziamento non strutturato progressivamente durante l'addestramento. Laddove l'accuratezza della quantizzazione post-addestramento (PTQ) non sia accettabile, SpongeTorch supporta anche l'addestramento consapevole della quantizzazione (QAT), ma quel percorso non è ancora integrato in questa integrazione di Ultralytics ed è pianificato per una versione futura.
2. Esportazione ONNX — esporta il checkpoint compresso con lo stesso amba_config, preservando 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 host — esegui il modello compilato *.ambapb.ckpt.onnx tramite Ultralytics predict/val tramite il backend AmbaPB per verificare l'accuratezza prima della distribuzione.
5. Conversione Cavalry — converte 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 di runtime dell'SDK di Ambarella.

Il flusso di lavoro di addestramento ed esportazione di SpongeTorch è facoltativo e può essere sostituito da una semplice esportazione ONNX (vedi 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 ad 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 (tv2 -libpath cvflowbackend) degli strumenti di compilazione dell'SDK, quindi gli strumenti di compilazione dell'SDK devono essere installati e presenti nel tuo PATH prima di eseguire l'inferenza o la convalida 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 potenziamento, inclusi gli obiettivi di sparsità e il programma di compressione. Ottieni configurazioni di esempio e la documentazione dello schema corrispondente dalla tua release dell'SDK Ambarella. Per mantenere la coerenza tra addestramento, convalida e distribuzione, usa la configurazione di addestramento ogni volta che la convalida 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 di esportazione generale:

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 passaggi, in modo che la rete impari a rimanere accurata pur diventando sparsa. 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 la riproducibilità.

Validazione del checkpoint compresso#

Valida la precisione 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, preservando la struttura di compressione. Confronta il mAP con la baseline non compressa; se il calo di precisione è troppo elevato, modifica la configurazione SpongeKit e ripeti l'addestramento.

Esporta 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 e traccia su ONNX con la fusione Conv+BN disabilitata, producendo un grafo nella forma esatta attesa dagli strumenti di compilazione dell'SDK.

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 di supporto metadata.yaml accanto al modello compilato. A meno che i tuoi strumenti di compilazione dell'SDK non creino questo file di supporto, 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.

Compilazione con gli strumenti dell'SDK#

Compila il modello ONNX esportato per il tuo chipset di destinazione utilizzando gli strumenti di compilazione dell'SDK, 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 convalida dell'host.

La PTQ applica la quantizzazione INT8 utilizzando immagini di calibrazione (preparate come descritto nella guida alla compilazione dell'SDK), e gli strumenti di compilazione bilanciano l'accuratezza rispetto alla Latenza di esecuzione: la mappatura di un maggior numero di operazioni su INT8 riduce la latenza ma può ridurre l'accuratezza, mentre il mantenimento di un maggior numero di operazioni in FP16 preserva l'accuratezza a una latenza superiore. Quando la PTQ non riesce a raggiungere il tuo obiettivo di accuratezza al livello INT8 richiesto per il tuo budget di latenza, la QAT con SpongeTorch è il rimedio previsto: addestra il modello a tollerare una quantizzazione INT8 più aggressiva, recuperando l'accuratezza a un punto operativo a minore latenza. La QAT non è ancora disponibile in questa integrazione ed è pianificata per una versione futura.

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 indirizza l'inferenza tramite cvflowbackend, eseguendo il modello così 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 e include tutti gli effetti della quantizzazione del compilatore. Se accanto al modello compilato è presente un file metadata.yaml, il backend legge da lì i nomi delle classi, lo stride e le informazioni sul task. Il backend utilizza per impostazione predefinita 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.

Conversione in un binario Cavalry#

Dopo che il checkpoint AmbaPB supera la convalida dell'host, utilizza gli strumenti di compilazione dell'SDK per convertirlo in un binario Cavalry per il tuo dispositivo di destinazione, seguendo la guida alla compilazione dell'SDK. Il binario Cavalry è la forma eseguita dalla libreria di runtime dell'SDK sulla scheda.

Distribuzione sulla scheda#

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

Esportazione senza SpongeTorch#

Se non hai bisogno del potenziamento in fase di addestramento di SpongeTorch, la pipeline Ultralytics standard produce anche un modello che gli strumenti dell'SDK possono compilare:

yolo export model=yolo26n.pt format=onnx

Compila l'ONNX risultante con gli strumenti di compilazione dell'SDK, che eseguono autonomamente la quantizzazione post-addestramento. Questo percorso scambia alcune prestazioni di esecuzione e accuratezza quantizzata con un flusso di lavoro più semplice senza alcuna dipendenza da spongetorch al momento dell'addestramento.

Applicazioni nel mondo reale#

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

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

Riepilogo#

Questa guida ha delineato il flusso di lavoro corrente 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 un checkpoint AmbaPB con gli strumenti dell'SDK, convalida dell'host tramite Ultralytics e conversione in un binario Cavalry per la distribuzione sul dispositivo con l'SDK Ambarella.

Per altri target 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, visita la documentazione della modalità di esportazione e la pagina delle integrazioni.

FAQ#