Link to this sectionAmbarella CVflow-Export für Ultralytics YOLO-Modelle#

Die Bereitstellung von Ultralytics YOLO-Modellen auf Ambarella SoCs erfordert ein Modellformat, das für die CVflow® AI-Engine optimiert ist. Dieser Fork von Ultralytics integriert Ambarellas SpongeTorch-Komprimierungs-Toolkit direkt in den Trainings-, Validierungs- und Export-Workflow, damit du beschnittene (pruned) und quantisierungsoptimierte Modelle erstellen kannst, die effizient auf Ambarella-Hardware laufen. Diese Anleitung beschreibt den aktuellen Workflow für die Objekterkennung: komprimierungsbewusstes Training, ONNX-Export, Kompilierung mit der CVflow-Toolchain und Inferenz mit dem kompilierten AmbaPB-Modell.

Link to this sectionWas ist Ambarella CVflow?#

Ambarella ist ein Halbleiterunternehmen mit Sitz in Santa Clara, das für seine stromsparenden AI-Vision-SoCs bekannt ist, die häufig in IP-Überwachungskameras, Dashcams, Drohnen, Robotik und Automobilsystemen eingesetzt werden. Die Chips basieren auf CVflow®, einer dedizierten neuronalen Vektorverarbeitungsarchitektur (der On-Chip-KI-Beschleuniger bzw. 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 CVflow-Format kompiliert.

Aktuelle CVflow-SoC-Familien und ihre typischen Anwendungen:

Link to this sectionWarum YOLO auf Ambarella einsetzen?#

• Leistung pro Watt: CVflow-SoCs sind für Always-On Edge-KI konzipiert und führen Echtzeit-Objekterkennung innerhalb von Leistungsbudgets für Kameras aus.
• Komprimierungsbewusstes 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.
• Bit-exakte Host-Validierung: Das kompilierte AmbaPB-Modell durchläuft Ultralytics predict/val auf deiner Workstation genau so, wie es auf dem Chip ausgeführt wird, sodass du die quantisierte mAP messen kannst, bevor du die 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.

Link to this sectionWorkflow-Übersicht#

Die Pipeline besteht aus vier Phasen:

1. Komprimierungsbewusstes Training — Trainiere mit einer SpongeKit-Konfiguration (amba_config), damit SpongeTorch während des Trainings schrittweise Pruning/Quantisierung anwendet.
2. ONNX-Export — Exportiere den komprimierten Checkpoint mit derselben amba_config, wobei die Komprimierungsstruktur 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 Ultralytics predict/val via das AmbaPB-Backend aus und stelle es dann auf dem Board bereit.

Das SpongeTorch-Training und der SpongeTorch-bewusste Export können durch einen einfachen ONNX-Export ersetzt werden, falls du die Optimierungen von SpongeTorch während des Trainings nicht benötigst (siehe Exportieren ohne SpongeTorch).

Link to this sectionVoraussetzungen#

Link to this sectionInstallation#

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 findet cvflowbackend über den tv2-Befehl der CVflow-Toolchain (tv2 -libpath cvflowbackend), daher muss die Toolchain installiert sein und sich in deinem PATH befinden, bevor du Inferenz oder Validierung mit kompilierten Modellen ausführst.

Link to this sectionSpongeKit-Konfigurationsdatei#

SpongeTorch wird durch eine SpongeKit-Konfigurationsdatei (Protobuf-Text-Format, .prototxt) gesteuert, die die anzuwendenden Komprimierungspässe definiert: Sparsity-Ziele für das Pruning, Quantisierungseinstellungen und den Komprimierungszeitplan. Erhalte Beispielkonfigurationen und die passende Schema-Dokumentation aus deinem Ambarella-SDK-Release. Verwende die Trainingskonfiguration immer dann, wenn die Validierung ein unvorbereitetes Modell vorbereiten muss, und verwende dieselbe Konfiguration immer beim Exportieren eines komprimierten Checkpoints.

Link to this sectionAmba-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:

Link to this sectionKomprimierungsbewusstes 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 gesetzt ist, umhüllt der Trainer das Modell und den Optimierer beim Setup mit spongetorch.prepare(). Die Komprimierung wird schrittweise nach einem Zeitplan angewendet, sodass das Netzwerk lernt, präzise zu bleiben, während es spärlich und quantisierungsfreundlich wird. Der trainierte Checkpoint speichert den spärlichen Zustand von SpongeTorch (_orig/_mask-Tensoren), was der Exportschritt später erfordert. Die Konfigurationsdatei wird zur Reproduzierbarkeit als amba_config.prototxt in das Run-Verzeichnis kopiert.

Link to this sectionValidierung 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, damit die Komprimierungsstruktur erhalten bleibt. Vergleiche die mAP mit deiner unkomprimierten Baseline; wenn der Abfall der Genauigkeit zu groß ist, passe die SpongeKit-Konfiguration an und trainiere erneut.

Link to this sectionExport nach ONNX#

Exportiere den komprimierten Checkpoint mit derselben amba_config, die 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 Exporteur baut das Modell neu auf, wendet spongetorch.prepare() erneut mit deiner Konfiguration an, lädt die spärlichen Checkpoint-Gewichte in die vorbereitete Struktur und erstellt einen Trace zu ONNX bei deaktivierter Conv+BN-Fusion – was einen Graphen in der exakten Form erzeugt, die der CVflow-Compiler erwartet.

Link to this sectionModell-Metadaten beibehalten#

Der ONNX-Export bettet die Modellaufgabe, Klassennamen, Stride und Eingabegröße in die ONNX-Datei ein, während das AmbaPB-Backend diese Informationen aus einer metadata.yaml-Sidecar-Datei neben dem kompilierten Modell liest. Sofern dein CVflow-Compiler dieses Sidecar nicht erstellt, extrahiere es vor der Kompilierung aus dem ONNX-Modell:

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.

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

Link to this sectionInferenz mit dem kompilierten Modell ausführen#

Das kompilierte AmbaPB-Modell lädt direkt über die Ultralytics API – AutoBackend erkennt das .ambapb-Suffix und leitet die Inferenz durch cvflowbackend, wobei das Modell bit-exakt so ausgeführt wird, wie es auf der KI-Engine laufen wird:

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 abschließende Genauigkeitsprüfung vor der Bereitstellung auf der Hardware, einschließlich aller Quantisierungseffekte des Compilers. Wenn neben dem kompilierten Modell eine metadata.yaml-Datei liegt, liest das Backend Klassennamen, Stride und Aufgabeninformationen daraus. Das Backend verwendet standardmäßig den CVflow-Inferenzmodus acinf; setze die Umgebungsvariable ULTRALYTICS_AMBAPB_DEBUG=1, um Ein-/Ausgabedetails für das Debugging zu protokollieren.

Link to this sectionAuf dem Board bereitstellen#

Lade das kompilierte Modell mit der Ambarella SDK-Runtime auf dein Ambarella-Gerät. Vorverarbeitung und Nachverarbeitung müssen mit dem übereinstimmen, wofür das Erkennungsmodell kompiliert wurde: Letterboxed RGB-Eingabe im Bereich 0–255 (das Ultralytics AmbaPB-Backend füttert das kompilierte Modell mit 0–255 RGB) und Standard-YOLO-Erkennungsdecodierung auf den Ausgaben. Siehe die SDK-Bereitstellungsdokumentation für Runtime-APIs.

Link to this sectionExportieren 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 Post-Training-Quantisierung durchführt. Dieser Pfad opfert etwas NPU-Leistung und quantisierte Genauigkeit für einen einfacheren Workflow ohne spongetorch-Abhängigkeit zum Trainingszeitpunkt.

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

Link to this sectionZusammenfassung#

Diese Vorschau-Anleitung beschrieb den aktuellen Workflow zur Bereitstellung von Ultralytics YOLO-Modellen auf Ambarella CVflow-SoCs: komprimierungsbewusstes Training mit SpongeTorch (amba_config/amba_chipset), ONNX-Export des komprimierten Checkpoints, Offline-Kompilierung zu AmbaPB mit der CVflow-Toolchain und bit-exakte Validierung des kompilierten Modells durch Ultralytics vor der Bereitstellung auf dem Board.

Für andere Edge-KI-Ziele siehe die zugehörigen Hailo-, Rockchip RKNN-, Sony IMX500-, Qualcomm QNN-, DEEPX- und Axelera-Anleitungen. Für die vollständige Liste der Exportformate besuche die Dokumentation zum Export-Modus und die Integrationsseite.

Link to this sectionFAQ#

Link to this sectionKann ich ein YOLO-Modell mit model.export() direkt in das Ambarella-Format exportieren?#

Nein. Es gibt kein format="ambarella"-Ziel. Exportiere in ONNX (optional mit SpongeTorch-Komprimierung via amba_config), dann kompiliere das ONNX-Modell offline mit der Ambarella CVflow-Toolchain aus dem SDK in AmbaPB.

Link to this sectionWelche Ambarella-Chips können Ultralytics YOLO-Modelle ausführen?#

Jedes auf CVflow basierende SoC, das von deiner CVflow-Toolchain unterstützt wird, kann als Ziel dienen, einschließlich der CV72/CV75-Familien für KI-Kameras, CV5/CV52 für Drohnen und Robotik sowie CV3-AD für Automotive. Das amba_chipset-Argument konfiguriert das Optimierungsziel von SpongeTorch; wähle beim Kompilieren separat das passende Ziel aus. Akzeptierte Chipsatz-Strings und Verfügbarkeit hängen vom installierten SDK-Release ab.

Link to this sectionWas ist SpongeTorch und brauche ich es?#

SpongeTorch ist Ambarellas Modellkomprimierungs-Toolkit, das in den Ambarella-Fork von Ultralytics für Pruning und quantisierungsbewusstes Training integriert ist. Es ist optional: Ein einfacher Ultralytics ONNX-Export kann auch mit der CVflow-Toolchain unter Verwendung von Post-Training-Quantisierung kompiliert werden, was jedoch mit Einbußen bei der NPU-Leistung und quantisierten Genauigkeit verbunden ist.

Link to this sectionWo bekomme ich das Ambarella-SDK, SpongeTorch und die CVflow-Toolchain?#

Sie sind proprietär und nicht über PyPI verfügbar. Registriere dich in der Ambarella Developer Zone, um SDK-Zugriff anzufordern; die spongetorch- und cvflowbackend-Wheels sowie der CVflow-Compiler werden mit der SDK-Distribution ausgeliefert.

Link to this sectionWie überprüfe ich die Genauigkeit des kompilierten Modells vor der Bereitstellung?#

Führe yolo val model=model.ambapb.ckpt.onnx data=your_data.yaml mit installiertem Ambarella-Fork aus. Das AmbaPB-Backend führt das kompilierte Modell bit-exakt so aus, wie es auf der CVflow-KI-Engine läuft, sodass die gemeldete mAP alle Quantisierungseffekte des Compilers enthält.