Ambarella CVflow-Export für Ultralytics YOLO-Modelle#

Das Bereitstellen von Ultralytics YOLO-Modellen auf Ambarella-SoCs erfordert ein Modellformat, das für die CVflow®-KI-Engine optimiert ist. Dieser Fork von Ultralytics integriert das SpongeTorch-Kompressionstoolkit direkt in die Pipeline für Training, Validierung und Export, sodass du bereinigte (pruned) und quantisierungsoptimierte Modelle erstellen kannst, die effizient auf Ambarella-Hardware laufen. Diese Anleitung beschreibt den aktuellen Objekterkennungs-Workflow: kompressionsbewusstes Training, ONNX-Export, Kompilierung mit der CVflow-Toolchain und Inferenz mit dem kompilierten AmbaPB-Modell.

Was ist Ambarella CVflow?#

Ambarella ist ein in Santa Clara ansässiges Halbleiterunternehmen, das für seine energieeffizienten KI-Visions-SoCs bekannt ist, die häufig in IP-Sicherheitskameras, Dashcams, Drohnen, in der Robotik und in Automobilsystemen eingesetzt werden. Seine Chips basieren auf CVflow®, einer dedizierten neuronalen Vektorverarbeitungsarchitektur (dem On-Chip-KI-Beschleuniger oder NPU), die einen hohen Inferenzdurchsatz bei sehr geringem Stromverbrauch liefert – der CV72S führt 4K-Sicherheitskamera-KI-Workloads unter 3 W aus. Modelle, die in Standard-Frameworks wie PyTorch trainiert wurden, werden vor der Bereitstellung mit der Offline-Toolchain von Ambarella in das native Format von CVflow kompiliert.

Aktuelle CVflow-SoC-Familien und ihre typischen Anwendungen:

Warum YOLO auf Ambarella einsetzen?#

• Leistung pro Watt: CVflow-SoCs sind für immer eingeschaltete Edge-KI konzipiert und führen Echtzeit-Objekterkennung innerhalb von Leistungsbudgets auf Kameraniveau aus.
• Kompressionsbewusstes Training: SpongeTorch wendet während des Trainings Pruning- und Quantisierungs-bewusste Optimierung an, sodass das Modell lernt, präzise zu bleiben und gleichzeitig NPU-freundlich zu werden.
• Bitexakte Host-Validierung: Das kompilierte AmbaPB-Modell läuft über Ultralytics predict/val auf deiner Workstation genauso wie auf dem Chip, sodass du die quantisierte mAP messen kannst, bevor du Hardware berührst.
• Integrierte Kamera-Pipeline: Ambarella-SoCs kombinieren die KI-Engine mit einem ISP und Video-Encodern, was sie zu einer Ein-Chip-Lösung für KI-Kameras macht.

Workflow-Übersicht#

Die Pipeline besteht aus vier Phasen:

1. Kompressionsbewusstes Training – trainiere mit einer SpongeKit-Konfiguration (amba_config), damit SpongeTorch Pruning/Quantisierung während des Trainings schrittweise anwendet.
2. ONNX-Export – exportiere den komprimierten Checkpoint mit demselben amba_config, wodurch die Kompressionsstruktur im ONNX-Graphen erhalten bleibt.
3. CVflow-Kompilierung — Kompiliere das ONNX-Modell mit der CVflow-Toolchain in ein AmbaPB-Artefakt.
4. Inferenz und Validierung – Führe das kompilierte *.ambapb.ckpt.onnx-Modell über das AmbaPB-Backend durch Ultralytics predict/val aus und stelle es dann auf dem Board bereit.

SpongeTorch-Training und SpongeTorch-bewusster Export können durch einen einfachen ONNX-Export ersetzt werden, wenn du die trainingsbezogenen Optimierungen von SpongeTorch nicht benötigst (siehe Exportieren ohne SpongeTorch).

Voraussetzungen#

Installation#

Installiere diesen Ultralytics-Fork und installiere dann die Ambarella-Toolchain-Wheels aus der SDK-Distribution:

!!! Tip "Installation"

# 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

Das AmbaPB-Inferenz-Backend lokalisiert cvflowbackend über den tv2-Befehl der CVflow-Toolchain (tv2 -libpath cvflowbackend), sodass die Toolchain installiert sein und sich in deinem PATH befinden muss, bevor Inferenz oder Validierung mit kompilierten Modellen ausgeführt wird.

SpongeKit-Konfigurationsdatei#

SpongeTorch wird von einer SpongeKit-Konfigurationsdatei (Protobuf-Textformat, .prototxt) gesteuert, die die anzuwendenden Kompressionsdurchläufe definiert: Pruning-Sparsity-Ziele, Quantisierungseinstellungen und den Kompressionszeitplan. Erhalte Beispielkonfigurationen und die dazugehörige Schema-Dokumentation aus deinem Ambarella-SDK-Release. Verwende die Trainingskonfiguration immer dann, wenn die Validierung ein unvorbereitetes Modell vorbereiten muss, und verwende beim Exportieren eines komprimierten Checkpoints immer dieselbe Konfiguration.

Amba-Argumente#

Zwei Argumente steuern die SpongeTorch-Integration in den Modi train, val und export:

Der Fork fügt außerdem ein allgemeines Export-Argument hinzu:

Komprimierungsbewusstes Training#

Trainiere (oder feintune) dein Modell mit aktivierter SpongeTorch-Komprimierung:

from ultralytics import YOLO

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

Wenn amba_config festgelegt ist, umschließt der Trainer das Modell und den Optimierer beim Setup mit spongetorch.prepare(). Die Kompression wird schrittweise nach einem Zeitplan angewendet, sodass das Netzwerk lernt, genau zu bleiben und gleichzeitig sparsam und quantisierungsfreundlich zu werden. Der trainierte Checkpoint speichert den sparsamen Zustand von SpongeTorch (_orig/_mask-Tensoren), den der Exportschritt später benötigt. Die Konfigurationsdatei wird zur Reproduzierbarkeit als amba_config.prototxt in das Ausführungsverzeichnis kopiert.

Validierung des komprimierten Checkpoints#

Validiere die Genauigkeit vor dem Kompilieren unter Verwendung derselben Konfiguration:

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

Der Validator wendet spongetorch.prepare() bei Bedarf erneut an und deaktiviert die Conv+BN-Fusion, sodass die Kompressionsstruktur erhalten bleibt. Vergleiche mAP mit deiner unkomprimierten Baseline; wenn der Genauigkeitsabfall zu groß ist, passe die SpongeKit-Konfiguration an und trainiere sie erneut.

Export nach ONNX#

Exportiere den komprimierten Checkpoint mit demselben amba_config, das auch beim Training verwendet wurde:

from ultralytics import YOLO

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

Der Exporter baut das Modell neu auf, wendet spongetorch.prepare() mit deiner Konfiguration erneut an, lädt die spärlichen Checkpoint-Gewichte in die vorbereitete Struktur neu und zeichnet sie mit deaktivierter Conv+BN-Fusion in ONNX auf – wodurch ein Graph in genau der Form entsteht, die der CVflow-Compiler erwartet.

Modell-Metadaten beibehalten#

Der ONNX-Export bettet die Modellaufgabe, Klassennamen, Schrittweite (stride) und Eingabegröße in die ONNX-Datei ein, während das AmbaPB-Backend diese Informationen aus einer metadata.yaml-Beigabedatei (sidecar) neben dem kompilierten Modell liest. Extrahiere sie vor der Kompilierung aus dem ONNX-Modell, es sei denn, dein CVflow-Compiler erstellt diese Beigabedatei:

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})

Behalte metadata.yaml im selben Verzeichnis wie die kompilierte *.ambapb.ckpt.onnx- oder *.ambapb.fastckpt.onnx-Datei.

Kompilierung mit der CVflow-Toolchain#

Kompiliere das exportierte ONNX-Modell für deinen Ziel-Chipsatz mit dem CVflow-Compiler aus dem SDK, indem du der Kompilierungsanleitung des SDKs folgst. Der Compiler bildet den Graphen auf die CVflow-KI-Engine ab (Quantisierung, Zeitplanung, Speicherplanung) und erstellt das bereitstellbare AmbaPB-Artefakt.

Inferenz mit dem kompilierten Modell ausführen#

Das kompilierte AmbaPB-Modell wird direkt über die Ultralytics-API geladen – AutoBackend erkennt das .ambapb-Suffix und leitet die Inferenz über cvflowbackend weiter, wodurch das Modell bitexakt so ausgeführt wird, wie es auf der KI-Engine läuft:

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")

Dies ist die finale Genauigkeitsprüfung vor der Hardware-Bereitstellung, einschließlich aller Compiler-Quantisierungseffekte. Wenn sich eine metadata.yaml-Datei neben dem kompilierten Modell befindet, liest das Backend Klassennamen, Schrittweite und Aufgabeninformationen daraus. Das Backend verwendet standardmäßig den CVflow-Inferenzmodus acinf; setze die Umgebungsvariable ULTRALYTICS_AMBAPB_DEBUG=1, um Eingabe-/Ausgabedetails für das Debugging zu protokollieren.

Auf dem Board bereitstellen#

Lade das kompilierte Modell auf deinem Ambarella-Gerät mit der Ambarella-SDK-Laufzeitumgebung. Vor- und Nachbereitung müssen zu dem passen, wofür das Erkennungsmodell kompiliert wurde: letterboxed RGB-Eingabe im Bereich 0–255 (das Ultralytics AmbaPB-Backend füttert dem kompilierten Modell 0–255 RGB) und standardmäßige YOLO-Erkennungsdekodierung für die Ausgaben. Siehe die SDK-Bereitstellungsdokumentation für Laufzeit-APIs.

Exportieren ohne SpongeTorch#

Wenn du die während des Trainings stattfindenden Pruning- und Quantisierungs-optimierungen von SpongeTorch nicht benötigst, erzeugt die Standard-Ultralytics-Pipeline auch ein CVflow-kompilierbares Modell:

yolo export model=yolo26n.pt format=onnx

Kompiliere das resultierende ONNX mit der CVflow-Toolchain, die selbst eine Quantisierung nach dem Training durchführt. Dieser Pfad tauscht etwas NPU-Leistung und quantisierte Genauigkeit gegen einen einfacheren Workflow ohne spongetorch-Abhängigkeit zum Trainingszeitpunkt ein.

Anwendungen in der Praxis#

Ultralytics YOLO-Modelle auf Ambarella CVflow-SoCs ermöglichen Always-On-Vision am Edge:

• KI-Sicherheitskameras: Echtzeit-Personen- und Fahrzeugerkennung auf 4K-IP-Kameras bei einem Leistungsbudget unter 3 W.
• Drohnen und Robotik: Onboard-Objekterkennung und Tracking für Navigation, Inspektion und Zustellung auf Chips der CV5-Klasse.
• Automotive: ADAS-Wahrnehmungs-Workloads wie Fußgänger- und Fahrzeugerkennung auf CV3-AD-Domänencontrollern.
• Industrie- und Einzelhandelsanalytik: Multi-Stream-Personenzählung, PSA-Erkennung und Regalüberwachung auf Edge-Appliances.

Zusammenfassung#

Diese Vorschaubeschreibung skizzierte den aktuellen Workflow zur Bereitstellung von Ultralytics YOLO-Modellen auf Ambarella CVflow-SoCs: kompressionsbewusstes Training mit SpongeTorch (amba_config/amba_chipset), ONNX-Export des komprimierten Checkpoints, Offline-Kompilierung nach AmbaPB mit der CVflow-Toolchain und bitexakte Validierung des kompilierten Modells durch Ultralytics vor der Bereitstellung auf dem Board.

Für andere Edge-KI-Ziele siehe die verwandten Anleitungen zu Hailo, Rockchip RKNN, Sony IMX500, Qualcomm QNN, DEEPX und Axelera. Die vollständige Liste der Exportformate findest du in der Dokumentation zum Exportmodus und auf der Integrationsseite.

FAQ#