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

Für die Bereitstellung von Ultralytics YOLO-Modellen auf Ambarella-SoCs müssen die Modelle mit den Kompilierungswerkzeugen von Ambarella kompiliert werden. Für die CVflow-Architektur optimierte Modelle liefern bei der Inferenz bessere Ergebnisse. Dieser Ultralytics-Fork integriert das Komprimierungswerkzeug SpongeTorch von Ambarella direkt in den Ablauf für Training, Validierung und Export. So können Entwickler optimierte Modelle für eine effiziente Bereitstellung auf Ambarella-Hardware erzeugen.

Diese Anleitung behandelt den aktuellen Bereitstellungsablauf für die Objekterkennung, vom komprimierungsbewussten Training bis zur Inferenz auf dem Gerät (den vollständigen Ablauf findest du in der Workflow-Übersicht).

Das AmbaPB-Prüfpunkteformat ist eine Ambarella-spezifische Erweiterung der ONNX-IR-Spezifikation. Es unterstützt CVflow-Rechenprimitiven und bündelt die von den SDK-Werkzeugen erzeugten Artefakte. Es handelt sich um das hostseitige Artefakt, mit dem sich die Genauigkeit des kompilierten Modells vor der Bereitstellung überprüfen lässt. Die separate Cavalry-Binärdatei für das Zielgerät wird auf der Hardware ausgeführt.

Was ist Ambarella?#

Ambarella hat seinen Hauptsitz in Santa Clara, Kalifornien, und ist ein Halbleiterunternehmen, das Edge-AI-SoCs entwickelt. Die Prozessoren des Unternehmens vereinen Bildsignalverarbeitung, Videokodierung und KI-Berechnungen auf dem Chip und kommen in Sicherheits-, Automobil-, Robotik-, Industrie- und Verbrauchergeräten zum Einsatz.

Was ist CVflow?#

CVflow ist die Bildverarbeitungsarchitektur von Ambarella. Sie verwendet eine dedizierte Bildverarbeitungseinheit, die von CPU und GPU getrennt ist, um Computer-Vision- und neuronale Netzwerkaufgaben auszuführen. Mit Frameworks wie PyTorch trainierte Modelle werden vor der Ausführung auf der Einheit mithilfe des Ambarella SDK in das native CVflow-Format kompiliert.

Aktuelle CVflow-SoC-Familien und ihre typischen Anwendungsbereiche:

Warum YOLO auf Ambarella bereitstellen?#

• Leistung pro Watt: CVflow-SoCs sind für den kontinuierlichen Betrieb mit Edge-KI ausgelegt und führen Echtzeit-Objekterkennung innerhalb des für Kameras typischen Energieverbrauchs aus.
• Komprimierungsbewusstes Training: SpongeTorch führt während des Trainings eine Pruning-Reduktion durch. Dadurch kann das Modell seine Genauigkeit beibehalten und wird zugleich dünnbesetzter und effizienter für die Bereitstellung auf CVflow.
• Integrierte Kamerapipeline: Ambarella-SoCs vereinen einen Bildsignalprozessor (ISP), Ultra-HD-Videokodierung und CVflow. Dadurch unterstützen sie eine Vielzahl von Kamerasystemen bei geringem Energieverbrauch, und ein einzelner Ambarella-SoC verarbeitet die gesamte KI-Kamerapipeline.

Workflow-Übersicht#

Die Pipeline umfasst sechs Phasen:

1. Komprimierungsbewusstes Training — Trainiere mit einer SpongeKit-Konfiguration (amba_config), damit SpongeTorch während des Trainings schrittweise unstrukturiertes Pruning durchführt. Wenn die Genauigkeit nach der Quantisierung nach dem Training (PTQ) nicht ausreicht, unterstützt SpongeTorch auch quantisierungsbewusstes Training (QAT). Dieser Ablauf ist jedoch noch nicht in diese Ultralytics-Integration eingebunden und für eine künftige Version geplant.
2. ONNX-Export — Exportiere den komprimierten Prüfpunkt mit derselben amba_config und erhalte dabei die Komprimierungsstruktur im ONNX-Graphen.
3. Kompilierung — Kompiliere das ONNX-Modell mit den SDK-Kompilierungswerkzeugen zu einem AmbaPB-Prüfpunkt. Dabei wird PTQ für die CVflow-Einheit angewendet.
4. Validierung auf dem Host — Führe das kompilierte Modell *.ambapb.ckpt.onnx mithilfe des AmbaPB-Backends über Ultralytics predict/val aus, um die Genauigkeit vor der Bereitstellung zu überprüfen.
5. Cavalry-Konvertierung — Konvertiere den validierten AmbaPB-Prüfpunkt mit den SDK-Werkzeugen in eine Cavalry-Binärdatei.
6. Auf dem Gerät ausführen — Führe die Cavalry-Binärdatei auf dem Gerät mit der SDK-Laufzeitbibliothek von Ambarella aus.

Der SpongeTorch-Trainings- und Exportablauf ist optional und kann durch einen einfachen ONNX-Export ersetzt werden (siehe Export ohne SpongeTorch).

Voraussetzungen#

Installation#

Installiere diesen Ultralytics-Fork, richte anschließend das Ambarella-CVflow-SDK ein – einschließlich der Kompilierungswerkzeuge und der Bibliothek cvflowbackend – und installiere das zusammen mit dem SDK bereitgestellte spongetorch-Wheel:

# 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 findet cvflowbackend über den Befehl tv2 (tv2 -libpath cvflowbackend) der SDK-Kompilierungswerkzeuge. Daher müssen die SDK-Kompilierungswerkzeuge installiert und in deinem PATH verfügbar sein, bevor du mit kompilierten Modellen Inferenzen oder Validierungen ausführst.

SpongeKit-Konfigurationsdatei#

SpongeTorch wird über eine SpongeKit-Konfigurationsdatei im protobuf-Textformat (.prototxt) gesteuert. Sie definiert die Pruning-Durchläufe, einschließlich der Ziele für die Dünnbesetzung und des Komprimierungsplans. Beispielkonfigurationen und die passende Schemadokumentation erhältst du mit deiner Ambarella-SDK-Version. Damit Training, Validierung und Bereitstellung übereinstimmen, verwende die Trainingskonfiguration immer dann, wenn das Modell für die Validierung erneut vorbereitet werden muss. Verwende außerdem beim Export eines komprimierten Prüfpunkts stets dieselbe Konfiguration.

Amba-Argumente#

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

Der Fork bietet außerdem ein allgemeines Exportargument:

Komprimierungsbewusstes Training#

Trainiere dein Modell mit aktivierter SpongeTorch-Komprimierung oder führe ein Feintraining durch:

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, versieht der Trainer das Modell und den Optimierer beim Einrichten mit spongetorch.prepare(). Die Komprimierung wird schrittweise nach einem festgelegten Ablauf angewendet, sodass das Netzwerk lernt, seine Genauigkeit beizubehalten und dabei dünnbesetzter zu werden. Der trainierte Prüfpunkt speichert den dünnbesetzten Zustand von SpongeTorch (_orig/_mask-Tensoren), der später für den Export benötigt wird. Zur Reproduzierbarkeit wird die Konfigurationsdatei als amba_config.prototxt in das Ausführungsverzeichnis kopiert.

Komprimierten Prüfpunkt validieren#

Validiere die Genauigkeit vor der Kompilierung und verwende dabei dieselbe 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 Fusion von Conv+BN, damit die Komprimierungsstruktur erhalten bleibt. Vergleiche mAP mit deinem unkomprimierten Ausgangsmodell. Ist der Rückgang der Genauigkeit zu groß, passe die SpongeKit-Konfiguration an und trainiere erneut.

Nach ONNX exportieren#

Exportiere den komprimierten Prüfpunkt mit derselben amba_config, die du für das Training verwendet hast:

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 Gewichte des dünnbesetzten Prüfpunkts in die vorbereitete Struktur und erstellt bei deaktivierter Conv+BN-Fusion einen ONNX-Trace. Dadurch entsteht ein Graph in genau dem Format, das die SDK-Kompilierungswerkzeuge erwarten.

Modellmetadaten erhalten#

Beim ONNX-Export werden die Modellaufgabe, die Klassennamen, der Stride und die Eingabegröße in die ONNX-Datei eingebettet. Das AmbaPB-Backend liest diese Informationen aus einer metadata.yaml-Begleitdatei neben dem kompilierten Modell. Falls die SDK-Kompilierungswerkzeuge diese Begleitdatei nicht erstellen, extrahiere sie 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})

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

Mit den SDK-Tools kompilieren#

Kompiliere das exportierte ONNX-Modell mit den SDK-Kompilierungstools für deinen Ziel-Chipsatz und befolge dabei die Kompilierungsanleitung des SDK. Die Tools ordnen den Graphen der CVflow-KI-Engine zu – einschließlich PTQ, Ablaufplanung und Speicherplanung – und erstellen den AmbaPB-Checkpoint für die Validierung auf dem Host.

PTQ wendet mithilfe von Kalibrierungsbildern (wie in der Kompilierungsanleitung des SDK beschrieben vorbereitet) eine INT8-Quantisierung an. Die Kompilierungstools stimmen Genauigkeit und Laufzeitlatenz aufeinander ab: Wenn mehr Operationen auf INT8 abgebildet werden, sinkt die Latenz, die Genauigkeit kann jedoch abnehmen. Werden mehr Operationen in FP16 belassen, bleibt die Genauigkeit erhalten, allerdings steigt die Latenz. Wenn PTQ dein Genauigkeitsziel bei dem für dein Latenzbudget erforderlichen INT8-Niveau nicht erreicht, ist QAT mit SpongeTorch die vorgesehene Lösung. Dabei wird das Modell darauf trainiert, eine aggressivere INT8-Quantisierung zu tolerieren und so bei geringerer Latenz die Genauigkeit wiederherzustellen. QAT ist in dieser Integration noch nicht verfügbar und für eine zukünftige Version geplant.

Inferenz mit dem kompilierten Modell ausführen#

Das kompilierte AmbaPB-Modell wird direkt über die Ultralytics-API geladen – AutoBackend erkennt das Suffix .ambapb und leitet die Inferenz über cvflowbackend, sodass das Modell 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 und berücksichtigt sämtliche Quantisierungseffekte des Compilers. Liegt neben dem kompilierten Modell eine metadata.yaml-Datei, liest das Backend daraus die Klassennamen, den Stride und die Aufgabeninformationen aus. Standardmäßig verwendet das Backend den CVflow-Inferenzmodus acinf. Setze die Umgebungsvariable ULTRALYTICS_AMBAPB_DEBUG=1, um Eingabe- und Ausgabedetails zur Fehlersuche zu protokollieren.

In eine Cavalry-Binärdatei umwandeln#

Nachdem der AmbaPB-Checkpoint die Validierung auf dem Host bestanden hat, kannst du ihn mit den SDK-Kompilierungstools gemäß der Kompilierungsanleitung des SDK in eine Cavalry-Binärdatei für dein Zielgerät umwandeln. Die Cavalry-Binärdatei ist das Format, das die SDK-Laufzeitbibliothek auf dem Board ausführt.

Auf dem Board bereitstellen#

Lade die Cavalry-Binärdatei mit der Ambarella-SDK-Laufzeit auf dein Ambarella-Gerät. Vor- und Nachverarbeitung müssen der Kompilierung des Erkennungsmodells entsprechen: letterboxed RGB-Eingaben im Wertebereich 0–255 und die standardmäßige YOLO-Erkennungsdekodierung der Ausgaben. Informationen zu den Laufzeit-APIs findest du in der Bereitstellungsdokumentation des SDK.

Ohne SpongeTorch exportieren#

Wenn du das Pruning zur Trainingszeit mit SpongeTorch nicht benötigst, kannst du mit der standardmäßigen Ultralytics-Pipeline ebenfalls ein Modell erstellen, das sich mit den SDK-Tools kompilieren lässt:

yolo export model=yolo26n.pt format=onnx

Kompiliere das resultierende ONNX-Modell mit den SDK-Kompilierungstools, die die Quantisierung nach dem Training selbst durchführen. Dieser Weg bietet einen einfacheren Ablauf ohne Abhängigkeit von spongetorch während des Trainings, geht jedoch mit Einbußen bei Laufzeitleistung und quantisierter Genauigkeit einher.

Anwendungen in der Praxis#

Ultralytics-YOLO-Modelle auf Ambarella-CVflow-SoCs ermöglichen kontinuierliche Bilderkennung am Netzwerkrand:

• KI-Sicherheitskameras: Echtzeit-Erkennung von Personen und Fahrzeugen auf 4K-IP-Kameras bei einem Leistungsbudget von unter 3 W.
• Drohnen und Robotik: Objekterkennung und -verfolgung an Bord für Navigation, Inspektion und Auslieferung mit Chips der CV5-Klasse.
• Industrie- und Einzelhandelsanalysen: Zählung von Personen über mehrere Videostreams, PSA-Erkennung und Regalüberwachung auf Edge-Geräten.

Zusammenfassung#

Diese Anleitung beschreibt den aktuellen Ablauf 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 einem AmbaPB-Checkpoint mit den SDK-Tools, Validierung auf dem Host mit Ultralytics und Umwandlung in eine Cavalry-Binärdatei zur Bereitstellung auf dem Gerät mit dem Ambarella SDK.

Weitere Ziele für Edge-KI findest du in den Anleitungen zu Hailo, Rockchip RKNN, Sony IMX500, Qualcomm QNN, DEEPX und Axelera. Eine vollständige Liste der Exportformate findest du in der Dokumentation zum Exportmodus und auf der Integrationsseite.

Häufig gestellte Fragen#