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. Modelle, die für die CVflow-Architektur optimiert sind, erzielen zur Laufzeit bessere Ergebnisse. Dieser Fork von Ultralytics integriert Ambarellas Komprimierungswerkzeug SpongeTorch direkt in die Trainings-, Validierungs- und Exportpipeline. So können Entwickler optimierte Modelle für eine effiziente Bereitstellung auf Ambarella-Hardware erstellen.

Dieser Leitfaden 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-Checkpoint-Format 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 Host-Artefakt, mit dem die Genauigkeit des kompilierten Modells vor der Bereitstellung überprüft wird. Die separate Cavalry-Binärdatei für das Zielgerät wird auf dem Gerät ausgeführt.

Was ist Ambarella?#

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

Was ist CVflow?#

CVflow ist Ambarellas Architektur für die Bildverarbeitung. Sie verwendet eine dedizierte Bildverarbeitungseinheit, die von CPU und GPU getrennt ist, um Computer-Vision- und neuronale Netzwerk-Workloads auszuführen. Modelle, die mit Frameworks wie PyTorch trainiert wurden, werden vor ihrer Ausführung auf der Einheit mit dem 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 ständig aktive Edge-KI ausgelegt und führen die Objekterkennung in Echtzeit innerhalb des für Kameras typischen Energieverbrauchs aus.
• Komprimierungsbewusstes Training: SpongeTorch wendet während des Trainings Pruning an, damit das Modell seine Genauigkeit beibehält und zugleich dünn besetzt und effizienter für die Bereitstellung auf CVflow wird.
• Integrierte Kamerapipeline: Ambarella-SoCs vereinen einen Bildsignalprozessor (ISP), Ultra-HD-Videokodierung und CVflow. So lassen sich verschiedene Kamerasysteme mit geringem Stromverbrauch realisieren, und ein einzelner Ambarella-SoC übernimmt 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 anwendet. 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 zukünftige Version geplant.
2. ONNX-Export — Exportiere den komprimierten Checkpoint mit derselben amba_config, damit die Komprimierungsstruktur im ONNX-Graphen erhalten bleibt.
3. Kompilierung — Kompiliere das ONNX-Modell mit den SDK-Kompilierungswerkzeugen zu einem AmbaPB-Checkpoint. Dabei wird PTQ für die CVflow-Einheit angewendet.
4. Validierung auf dem Host — Führe das kompilierte Modell *.ambapb.ckpt.onnx über das AmbaPB-Backend mit Ultralytics predict/val aus, um die Genauigkeit vor der Bereitstellung zu überprüfen.
5. Cavalry-Konvertierung — Wandle den validierten AmbaPB-Checkpoint mit den SDK-Werkzeugen in eine Cavalry-Binärdatei um.
6. Auf dem Gerät ausführen — Führe die Cavalry-Binärdatei auf dem Gerät mit der Ambarella-SDK-Laufzeitbibliothek aus.

Der SpongeTorch-Trainings- und Exportworkflow 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 — es enthält die Kompilierungswerkzeuge und die 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

Das AutoBackend findet cvflowbackend über den Befehl tv2 der SDK-Kompilierungswerkzeuge (tv2 -libpath cvflowbackend). Daher müssen die SDK-Kompilierungswerkzeuge installiert und in deinem PATH verfügbar sein, bevor du mit kompilierten Modellen Inferenz oder Validierung ausführst.

SpongeKit-Konfigurationsdatei#

SpongeTorch wird über eine SpongeKit-Konfigurationsdatei im protobuf-Textformat (.prototxt) gesteuert. Sie legt die Pruning-Schritte fest, einschließlich der Ziele für die Sparsität und des Komprimierungsplans. Beispielkonfigurationen und die dazugehörige Schemadokumentation erhältst du mit deiner Ambarella-SDK-Version. Damit Training, Validierung und Bereitstellung aufeinander abgestimmt sind, verwende die Trainingskonfiguration immer dann, wenn das Modell für die Validierung erneut vorbereitet werden muss, und nutze beim Export eines komprimierten Checkpoints stets dieselbe Konfiguration.

Amba-Argumente#

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

Der Fork ergänzt außerdem ein allgemeines Exportargument:

Komprimierungsbewusstes Training#

Trainiere dein Modell mit aktivierter SpongeTorch-Komprimierung oder passe es damit weiter an:

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, bindet der Trainer das Modell und den Optimierer bei der Einrichtung mit spongetorch.prepare() ein. Die Komprimierung wird schrittweise nach einem Zeitplan angewendet, sodass das Netzwerk lernt, seine Genauigkeit beizubehalten und zugleich dünn besetzt zu werden. Der trainierte Checkpoint speichert den Sparse-Zustand von SpongeTorch (_orig/_mask-Tensoren), den der Exportschritt später benötigt. Zur Reproduzierbarkeit wird die Konfigurationsdatei als amba_config.prototxt in das Ausführungsverzeichnis kopiert.

Komprimierten Checkpoint validieren#

Validiere die Genauigkeit vor der Kompilierung mit 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 mAP mit deinem unkomprimierten Ausgangswert. Ist der Rückgang der Genauigkeit zu groß, passe die SpongeKit-Konfiguration an und trainiere erneut.

Ins ONNX-Format exportieren#

Exportiere den komprimierten Checkpoint mit derselben amba_config, die du beim 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 erstellt das Modell neu, wendet spongetorch.prepare() mit deiner Konfiguration erneut an, lädt die Sparse-Checkpoint-Gewichte in die vorbereitete Struktur und zeichnet den ONNX-Graphen bei deaktivierter Conv+BN-Fusion auf. Dadurch entsteht ein Graph im exakten Format, das die SDK-Kompilierungswerkzeuge erwarten.

Modellmetadaten erhalten#

Beim ONNX-Export werden die Modellaufgabe, Klassennamen, Schrittweite und Eingabegröße in die ONNX-Datei eingebettet. Das AmbaPB-Backend liest diese Informationen dagegen aus einer metadata.yaml-Begleitdatei neben dem kompilierten Modell. Falls deine 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-Werkzeugen kompilieren#

Kompiliere das exportierte ONNX-Modell mit den SDK-Kompilierungswerkzeugen für deinen Zielchip und folge dabei dem Kompilierungsleitfaden des SDK. Die Werkzeuge übertragen den Graphen auf die CVflow-KI-Einheit, wenden PTQ an, planen die Ausführung und den Speicher und erstellen den AmbaPB-Checkpoint für die Validierung auf dem Host.

PTQ wendet anhand von Kalibrierungsbildern eine INT8-Quantisierung an (die Vorbereitung wird im Kompilierungsleitfaden des SDK beschrieben). Die Kompilierungswerkzeuge wägen Genauigkeit und Laufzeit ab: Werden mehr Operationen auf INT8 abgebildet, sinkt die Latenz, aber die Genauigkeit kann abnehmen. Werden mehr Operationen in FP16 belassen, bleibt die Genauigkeit erhalten, die Latenz steigt jedoch. Wenn PTQ dein Genauigkeitsziel bei dem für dein Latenzbudget erforderlichen INT8-Anteil nicht erreicht, ist QAT mit SpongeTorch die vorgesehene Lösung. Dabei wird das Modell so trainiert, dass es eine aggressivere INT8-Quantisierung toleriert und dadurch bei einer niedrigeren Latenz die Genauigkeit wiedererlangt. 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 lässt sich direkt über die Ultralytics-API laden — das AutoBackend erkennt das Suffix .ambapb und leitet die Inferenz über cvflowbackend, sodass das Modell wie auf der KI-Einheit ausgeführt 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 alle Quantisierungseffekte des Compilers. Befindet sich neben dem kompilierten Modell eine Datei metadata.yaml, liest das Backend daraus Klassennamen, Schrittweite und Aufgabeninformationen. Standardmäßig verwendet das Backend den CVflow-Inferenzmodus acinf. Lege die Umgebungsvariable ULTRALYTICS_AMBAPB_DEBUG=1 fest, 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-Kompilierungswerkzeugen gemäß dem Kompilierungsleitfaden des SDK in eine Cavalry-Binärdatei für dein Zielgerät umwandeln. Die Cavalry-Binärdatei wird auf dem Gerät von der SDK-Laufzeitbibliothek ausgeführt.

Auf dem Gerät bereitstellen#

Lade die Cavalry-Binärdatei mit der Ambarella-SDK-Laufzeit auf dein Ambarella-Gerät. Vor- und Nachverarbeitung müssen dem entsprechen, wofür das Erkennungsmodell kompiliert wurde: letterboxed RGB-Eingaben im Wertebereich 0–255 und die standardmäßige YOLO-Dekodierung der Erkennungsausgaben. Informationen zu den Laufzeit-APIs findest du in der Bereitstellungsdokumentation des SDK.

Export ohne SpongeTorch#

Wenn du kein Pruning während des Trainings mit SpongeTorch benötigst, erzeugt auch die standardmäßige Ultralytics-Pipeline ein Modell, das sich mit den SDK-Werkzeugen kompilieren lässt:

yolo export model=yolo26n.pt format=onnx

Kompiliere das resultierende ONNX-Modell mit den SDK-Kompilierungswerkzeugen, die selbst eine Quantisierung nach dem Training durchführen. Dieser Ablauf ist einfacher und erfordert zur Trainingszeit keine Abhängigkeit von spongetorch, geht aber mit Abstrichen bei Laufzeitleistung und Quantisierungsgenauigkeit einher.

Anwendungen in der Praxis#

Ultralytics-YOLO-Modelle auf Ambarella-CVflow-SoCs ermöglichen ständig aktive Bildverarbeitung am Rand des Netzwerks:

• 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 Lieferung auf Chips der CV5-Klasse.
• Industrie- und Einzelhandelsanalysen: Zählung von Personen über mehrere Streams, Erkennung persönlicher Schutzausrüstung (PSA) und Überwachung von Regalen auf Edge-Geräten.

Zusammenfassung#

Dieser Leitfaden beschreibt 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 einem AmbaPB-Checkpoint mit den SDK-Werkzeugen, Validierung auf dem Host über Ultralytics und Umwandlung in eine Cavalry-Binärdatei für die Bereitstellung auf dem Gerät mit dem Ambarella-SDK.

Weitere Ziele für Edge-KI findest du in den entsprechenden Leitfäden 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#