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

Das Bereitstellen von Ultralytics YOLO-Modellen auf Ambarella-SoCs erfordert eine Modellkompilierung mit den Kompilierungstools von Ambarella, und Modelle, die für die CVflow-Architektur optimiert sind, erzielen zum Inferenzzeitpunkt eine bessere Leistung. Dieser Fork von Ultralytics integriert das Komprimierungs-Toolkit SpongeTorch von Ambarella direkt in die Trainings-, Validierungs- und Export-Pipeline, wodurch Entwickler optimierte Modelle für eine effiziente Bereitstellung auf Ambarella-Hardware generieren können.

Diese Anleitung behandelt den aktuellen Objekterkennung-Bereitstellungs-Workflow, vom komprimierungsbewussten Training bis hin zur Inferenz auf dem Gerät (siehe die Workflow-Übersicht für die gesamte Pipeline).

Das AmbaPB-Prüfpunktformat ist eine Ambarella-spezifische Erweiterung der ONNX-IR-Spezifikation, die CVflow-Berechnungsprimitive unterstützt und die von den SDK-Tools generierten Artefakte bündelt. Es ist das Artefakt auf Host-Seite, das zur Validierung der Genauigkeit des kompilierten Modells vor der Bereitstellung verwendet wird; die separate Cavalry-Binärdatei, die für das Zielgerät erstellt wird, läuft auf der Platine.

Wer ist Ambarella?#

Ambarella mit Hauptsitz in Santa Clara, Kalifornien, ist ein Halbleiterunternehmen, das KI-SoCs für den Edge-Bereich entwickelt. Seine Prozessoren kombinieren Bildsignalverarbeitung, Videokodierung und KI-Berechnung auf dem Chip und werden in Sicherheits-, Automobil-, Robotik-, Industrie- und Verbrauchergeräten eingesetzt.

Was ist CVflow?#

CVflow ist die Bildverarbeitungsarchitektur von Ambarella. Sie verwendet eine dedizierte Vision-Engine, getrennt von der CPU und GPU, um Computer-Vision- und neuronale Netzwerkauslastungen auszuführen. In Frameworks wie PyTorch trainierte Modelle werden vor ihrer Ausführung auf der Engine mit dem Ambarella-SDK in das native Format von CVflow kompiliert.

Aktuelle CVflow-SoC-Familien und ihre typischen Anwendungen:

Warum YOLO auf Ambarella bereitstellen?#

• Leistung pro Watt: CVflow-SoCs sind für ständig aktive Edge-KI ausgelegt und führen Objekterkennung in Echtzeit innerhalb von für Kameras geeigneten Strombudgets aus.
• Komprimierungsbewusstes Training: SpongeTorch wendet während des Trainings ein Pruning an, damit das Modell seine Genauigkeit beibehält und gleichzeitig sparsamer und effizienter für die CVflow-Bereitstellung wird.
• Integrierte Kamera-Pipeline: Ambarella-SoCs kombinieren einen Bildsignalprozessor (ISP), Ultra-HD-Videokodierung und CVflow, um eine Vielzahl von Kamerasystemen bei geringem Stromverbrauch zu ermöglichen, sodass ein einzelner Ambarella-SoC die vollständige KI-Kamera-Pipeline verarbeitet.

Workflow-Übersicht#

Die Pipeline hat sechs Stufen:

1. Komprimierungsbewusstes Training — trainiere mit einer SpongeKit-Konfiguration (amba_config), sodass SpongeTorch während des Trainings schrittweise ein unstrukturiertes Pruning anwendet. Wenn die Genauigkeit der Quantisierung nach dem Training (PTQ) nicht akzeptabel ist, unterstützt SpongeTorch auch das quantisierungsbewusste Training (QAT), aber dieser Pfad ist noch nicht in diese Ultralytics-Integration verdrahtet und für eine zukünftige Version geplant.
2. ONNX-Export – Exportiere den komprimierten Prüfpunkt mit demselben amba_config und erhalte dabei die Komprimierungsstruktur im ONNX-Graphen.
3. Kompilierung — kompiliere das ONNX-Modell mit den SDK-Kompilierungstools, die PTQ für die CVflow-Engine anwenden, zu einem AmbaPB-Prüfpunkt.
4. Host-Validierung — führe das kompilierte *.ambapb.ckpt.onnx-Modell über Ultralytics predict/val mithilfe des AmbaPB-Backends aus, um die Genauigkeit vor der Bereitstellung zu überprüfen.
5. Cavalry-Konvertierung — konvertiere den validierten AmbaPB-Prüfpunkt mit den SDK-Tools in eine Cavalry-Binärdatei.
6. Ausführung auf dem Gerät — führe die Cavalry-Binärdatei auf dem Gerät mit der SDK-Laufzeitbibliothek von Ambarella aus.

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

Voraussetzungen#

Installation#

Installiere diesen Ultralytics-Fork, richte dann das Ambarella CVflow SDK ein – welches die Kompilierungstools und die cvflowbackend-Bibliothek enthält – und installiere das daneben vertriebene 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 tv2-Befehl (tv2 -libpath cvflowbackend) der SDK-Kompilierungstools, weshalb die SDK-Kompilierungstools installiert sein und sich auf deinem PATH befinden müssen, bevor du die Inferenz oder Validierung mit kompilierten Modellen ausführst.

SpongeKit-Konfigurationsdatei#

SpongeTorch wird über eine SpongeKit-Konfigurationsdatei (im Protobuf-Textformat, .prototxt) gesteuert, die die Pruning-Durchläufe definiert, einschließlich Sparsity-Zielen und des Komprimierungsplans. Hole dir Beispielkonfigurationen und die passende Schema-Dokumentation aus deinem Ambarella-SDK-Release. Um die Konsistenz zwischen Training, Validierung und Bereitstellung aufrechtzuerhalten, verwende die Trainingskonfiguration immer dann, wenn die Validierung das Modell neu vorbereiten muss, und verwende beim Exportieren eines komprimierten Prüfpunkts stets 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 Exportargument hinzu:

Komprimierungsbewusstes Training#

Trainiere dein Modell mit aktivierter SpongeTorch-Komprimierung oder führe eine Feinabstimmung 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, umschließt der Trainer das Modell und den Optimierer beim Setup mit spongetorch.prepare(). Die Komprimierung wird schrittweise nach einem Stufenplan angewendet, sodass das Netzwerk lernt, genau zu bleiben, während es sparsamer wird. Der trainierte Prüfpunkt speichert den spärlichen 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.

Komprimierten Prüfpunkt 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 die mAP mit deiner unkomprimierten Referenz. Wenn der Rückgang der Genauigkeit zu groß ist, passe die SpongeKit-Konfiguration an und trainiere erneut.

Nach ONNX exportieren#

Exportiere den komprimierten Prüfpunkt mit demselben amba_config, das 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 Gewichte des spärlichen Prüfpunkts in die vorbereitete Struktur und führt ein Tracing nach ONNX durch, wobei die Conv+BN-Fusion deaktiviert ist – wodurch ein Graph genau in der Form erzeugt wird, die die SDK-Kompilierungstools erwarten.

Modellmetadaten erhalten#

Der ONNX-Export bettet die Modellaufgabe, Klassennamen, den Schritt (Stride) und die Eingabegröße in die ONNX-Datei ein, während das AmbaPB-Backend diese Informationen aus einer metadata.yaml-Begleitdatei neben dem kompilierten Modell liest. Es sei denn, deine SDK-Kompilierungstools erstellen diese Begleitdatei, 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})

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

Mit den SDK-Tools kompilieren#

Kompiliere das exportierte ONNX-Modell für deinen Ziel-Chipsatz mit den SDK-Kompilierungstools gemäß der Kompilierungsanleitung des SDKs. Die Tools bilden den Graphen auf der CVflow-KI-Engine ab – indem sie PTQ, Zeitplanung und Speicherplanung anwenden – und erzeugen den AmbaPB-Prüfpunkt für die Host-Validierung.

PTQ wendet eine INT8-Quantisierung mithilfe von Kalibrierungsbildern an (vorbereitet wie in der Kompilierungsanleitung des SDKs beschrieben), und die Kompilierungstools gleichen die Genauigkeit mit der Laufzeitlatenz ab: Das Zuordnen von mehr Operationen zu INT8 senkt die Latenz, kann jedoch die Genauigkeit verringern, während das Belassen von mehr Operationen in FP16 die Genauigkeit bei höherer Latenz beibehält. Wenn PTQ dein Genauigkeitsziel auf der für dein Latenzbudget erforderlichen INT8-Stufe nicht erreichen kann, ist QAT mit SpongeTorch das vorgesehene Mittel – es trainiert das Modell darauf, eine aggressivere INT8-Quantisierung zu tolerieren, und stellt die Genauigkeit an einem Arbeitspunkt mit geringerer Latenz wieder her. 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 .ambapb-Suffix und leitet die Inferenz über cvflowbackend weiter, wodurch 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 alle Quantisierungseffekte des Compilers. Wenn neben dem kompilierten Modell eine Datei metadata.yaml liegt, liest das Backend daraus Klassennamen, Schrittweite und Aufgabeninformationen. Das Backend verwendet standardmäßig den CVflow-Inferenzmodus acinf; setze die Umgebungsvariable ULTRALYTICS_AMBAPB_DEBUG=1, um Eingabe-/Ausgabedetails zur Fehlersuche zu protokollieren.

In eine Cavalry-Binärdatei konvertieren#

Nachdem der AmbaPB-Prüfpunkt die Host-Validierung bestanden hat, verwende die SDK-Kompilierungstools, um ihn gemäß der Kompilierungsanleitung des SDKs in eine Cavalry-Binärdatei für dein Zielgerät zu konvertieren. Die Cavalry-Binärdatei ist die Form, die von der SDK-Laufzeitbibliothek auf der Platine ausgeführt wird.

Auf dem Board bereitstellen#

Lade die Cavalry-Binärdatei auf dein Ambarella-Gerät mithilfe der Ambarella-SDK-Laufzeit. Vor- und Nachbereitung müssen mit dem übereinstimmen, wofür das Erkennungsmodell kompiliert wurde: letterboxed RGB-Eingabe im 0–255-Bereich und standardmäßige YOLO-Erkennungsdekodierung für die Ausgaben. Siehe in der SDK-Bereitstellungsdokumentation nach Laufzeit-APIs.

Export ohne SpongeTorch#

Wenn du das trainingsseitige Pruning von SpongeTorch nicht benötigst, erzeugt die Standard-Ultralytics-Pipeline ebenfalls ein Modell, das die SDK-Tools kompilieren können:

yolo export model=yolo26n.pt format=onnx

Kompiliere das resultierende ONNX mit den SDK-Kompilierungstools, die die Quantisierung nach dem Training selbst durchführen. Dieser Pfad opfert etwas Laufzeitleistung und quantisierte Genauigkeit zugunsten eines einfacheren Workflows ohne spongetorch-Abhängigkeit zum Trainingszeitpunkt.

Anwendungen in der Praxis#

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

• KI-Sicherheitskameras: Echtzeit-Erkennung von Personen und Fahrzeugen auf 4K-IP-Kameras mit einem Stromverbrauch von weniger als 3 W.
• Drohnen und Robotik: Objekterkennung und -verfolgung an Bord für Navigation, Inspektion und Zustellung auf Chips der CV5-Klasse.
• Industrie- und Einzelhandelsanalyse: Zählen von Personen in mehreren Datenströmen, Erkennung persönlicher Schutzausrüstung und Überwachung von Regalen auf Edge-Appliances.

Zusammenfassung#

Diese Anleitung skizzierte 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 Prüfpunkts, Offline-Kompilierung in einen AmbaPB-Prüfpunkt mit den SDK-Tools, Host-Validierung über Ultralytics und Konvertierung in eine Cavalry-Binärdatei für die geräteseitige Bereitstellung mit dem Ambarella-SDK.

Weitere Edge-KI-Ziele findest du in den zugehörigen 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.

FAQ#