AMD-Xilinx-Export für Ultralytics YOLO mit Vitis AI#

Beim Export von Ultralytics YOLO26-Modellen mit format="xilinx" werden diese mit AMD Quark für die NPUs in adaptiven SoCs der AMD Versal AI Edge Series Gen 2 quantisiert. Anschließend kann der Vitis-AI-Compiler von AMD daraus ein .rai-Modell erstellen. Derselbe Export prüft die INT8-Genauigkeit auf jedem Host, bevor du das Modell bereitstellst.

AMD-Xilinx-Geräte sind in vielen Industriekameras, Bildverarbeitungssystemen für Fahrzeuge, Robotern, Drohnen und Produkten für die medizinische Bildgebung weltweit im Einsatz. Sie verbinden Arm-Prozessoren mit programmierbarer Logik und verfügen bei neueren Geräten zusätzlich über dedizierte AI Engines. Dadurch kann ein einzelner Chip Video erfassen und vorverarbeiten, Objekte erkennen und mit niedriger, vorhersehbarer Inferenzlatenz auf die Ergebnisse reagieren.

Dieser Leitfaden behandelt den AMD-Xilinx-Export, das Kompilieren und Ausführen auf einem Versal-Board, die verschiedenen AMD-Xilinx-Gerätefamilien, die Ausführung von KI auf diesen Geräten sowie die von den einzelnen Beschleunigern unterstützten Ultralytics-YOLO-Operatoren.

Was ist AMD Xilinx?#

Xilinx erfand in den 1980er-Jahren das feldprogrammierbare Gate-Array (FPGA) und wurde zu einem führenden Anbieter von adaptiven SoCs und FPGAs. AMD schloss die Übernahme von Xilinx im Februar 2022 ab. Die Produktlinien werden nun unter der Marke AMD als AMD Zynq, AMD Kria, AMD Versal und AMD Vitis verkauft.

Wichtige Begriffe und Konzepte#

Bei der Bereitstellung auf AMD Xilinx kommt eine eigene Terminologie zum Einsatz. Die folgende Tabelle erläutert alle in dieser Anleitung verwendeten Begriffe.

AMD-Xilinx-Gerätefamilien für Edge AI#

AMD-Xilinx-Geräte für Edge AI gehören zu drei Familien. Zynq und Kria nutzen die DPU in der programmierbaren Logik, während die hier behandelten Versal-AI-Edge-Geräte die NPU auf ihren AI Engines einsetzen.

Zynq UltraScale+ MPSoC#

Jeder Zynq UltraScale+-Chip verbindet ein Arm-Verarbeitungssystem mit FPGA-Logik. Das Verarbeitungssystem verfügt je nach Variante über Cortex-A53-Kerne mit zwei Kernen (CG) oder vier Kernen (EG und EV) sowie Cortex-R5F-Echtzeitkerne. EV-Geräte bieten zusätzlich einen fest integrierten H.264/H.265-Videocodec. Für neuronale Netze integrieren Entwicklerinnen und Entwickler eine DPU in die Logik neben den Kamera- und Videopipelines. Bei kleinen Geräten beansprucht die DPU Platz, der dann für andere Teile des Designs fehlt.

Kria-System-on-Modules#

Das Kria-K26-Modul vereint einen Zynq UltraScale+ MPSoC, Speicher und Stromversorgung auf einem produktionsreifen Modul. So musst du Prozessor, Speicher und Stromversorgung nicht selbst entwerfen. Das Modul wird auf eine Trägerplatine gesteckt, entweder auf eine Platine aus einem Starter Kit oder auf eine eigene Platine. Es bildet die Grundlage für das KV260 Vision AI Starter Kit für intelligente Kameras und das KR260 Robotics Starter Kit für Robotik. Da das K26 auf Zynq UltraScale+ basiert, nutzt es denselben DPU-Arbeitsablauf. Zum Kria-Portfolio gehören auch weitere Module. Prüfe daher vor der Wahl eines Arbeitsablaufs, welchen Prozessor dein Modul verwendet.

Adaptive Versal-SoCs#

Versal ist AMDs Familie adaptiver SoCs. Die AI-Edge- und AI-Core-Serien verfügen neben den Arm-Kernen und der programmierbaren Logik über fest integrierte AI Engines, während einige andere Versal-Serien keine AI Engines bieten. AMDs NPU-IP wird gemeinsam auf AI Engines und programmierbarer Logik ausgeführt. Vitis AI unterstützt die AIE-ML-Bauteile der AI-Edge-Serie, zum Beispiel VE2302 und VE2802. Die Versal AI Edge Series (VEK280-Evaluierungskit) und die Versal AI Edge Series Gen 2 (VEK385-Evaluierungskit) sind AMDs aktuelle Zielplattformen für Edge AI und stehen im Mittelpunkt der aktuellen Vitis-AI-Versionen.

So läuft AI auf AMD-Xilinx-Geräten: DPU und NPU im Vergleich#

Die meisten AI-Bereitstellungen auf AMD-Xilinx-Geräten folgen demselben Muster. Der Beschleuniger verarbeitet die von ihm unterstützten Schichten. Die Arm-CPU übernimmt die Vorverarbeitung, die Nachverarbeitung und alle Schichten, die der Beschleuniger nicht ausführen kann. Eine Laufzeitumgebung auf der Platine koordiniert beide.

AMD hat zwei Beschleunigergenerationen auf den Markt gebracht, jeweils mit eigener Toolchain und eigener Modelldatei. Diese Anleitung behandelt Vitis AI 3.5 für die DPU und Vitis AI 6.3 für die NPU. Informationen zu späteren Versionen findest du in der aktuellen AMD-Dokumentation.

Welchen Vitis AI-Ablauf brauche ich?#

Wähle anhand des Geräts auf deiner Platine den passenden Ablauf aus:

Export nach AMD Xilinx: YOLO-Modell konvertieren#

Unterstützte Aufgaben#

Der AMD-Xilinx-Export unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, da nur diese Modellfamilie entsprechende Köpfe enthält.

Installation#

Der AMD-Xilinx-Export läuft unter Linux (x86-64 oder ARM64) mit Python 3.11 bis 3.13, den von AMD Quark unterstützten Versionen. Beim ersten Export werden außerdem die benutzerdefinierten Operatoren von Quark kompiliert. Dafür ist ein C++-Compiler wie g++ erforderlich.

# Install the required package for YOLO
pip install ultralytics

AMD Quark wird beim ersten Export automatisch von PyPI installiert. So kannst du die Exportabhängigkeiten vorab installieren:

pip install "ultralytics[export-xilinx]"

Für eine bearbeitbare Installation aus dem Repository ersetze "ultralytics[export-xilinx]" durch -e ".[export-base,export-xilinx]". Um die Python-3.12-Umgebung und den von CI verwendeten Exporttest nachzustellen, führe den vorhandenen Umgebungs-Builder im Stammverzeichnis des Repositorys aus:

ULTRALYTICS_ISOLATED_VENVS="$PWD/.venvs" python .github/scripts/create-export-env.py --env isolated-xilinx

Verwendung#

Das AMD-Xilinx-Format unterstützt die Modi Export, Vorhersage und Validierung. Ist der Vitis AI Execution Provider von AMD nicht verfügbar, führen Vorhersage und Validierung das quantisierte Modell mit ONNX Runtime auf der CPU aus, um seine INT8-Genauigkeit auf jedem Host zu messen. Wenn ONNX Runtime den VitisAIExecutionProvider bereitstellt, wie auf einem Board der Versal AI Edge Series Gen 2, wählt Ultralytics ihn automatisch aus.

from ultralytics import YOLO

# Ein YOLO26-Modell laden
model = YOLO("yolo26n.pt")

# In das AMD-Xilinx-Format für das VEK385 exportieren (quantize=8 wird automatisch erzwungen)
model.export(format="xilinx")  # creates 'yolo26n_xilinx_model/'

from ultralytics import YOLO

# Das exportierte AMD-Xilinx-Modell laden
model = YOLO("yolo26n_xilinx_model")

# Inferenz ausführen
results = model("https://ultralytics.com/images/bus.jpg")

from ultralytics import YOLO

# Das exportierte AMD-Xilinx-Modell laden
model = YOLO("yolo26n_xilinx_model")

# Die INT8-Genauigkeit anhand des COCO8-Datensatzes validieren
metrics = model.val(data="coco8.yaml")

Die Formatnamen vitis, vitisai und versal sind Aliase für xilinx.

Exportargumente#

Setze nms=False, um den NMS-freien Kopf von YOLO26 zu exportieren. Eingebettetes NMS (nms=True) wird nicht unterstützt, da AMD NonMaxSuppression als einen der Operatoren aufführt, die dazu führen können, dass das gesamte Modell auf der CPU ausgeführt wird.

Weitere Informationen zum Exportvorgang findest du auf der Ultralytics-Dokumentationsseite zum Export.

Ausgabestruktur#

Nach einem erfolgreichen Export wird ein Modellverzeichnis mit folgender Struktur erstellt:

yolo26n_xilinx_model/
├── yolo26n.onnx          # AMD Quark VINT8 model with the Ultralytics metadata
└── vitisai_config.json   # Vitis AI compiler configuration for the target device

Beim Kompilieren des Modells, wie weiter unten beschrieben, wird im selben Verzeichnis ein Compiler-Cache yolo26n/ angelegt, der das NPU-Modell yolo26n.rai und AMD-Kompilierungsberichte wie final-vaiml-pass-summary.txt enthält.

Ablauf des Exports#

Der Export folgt dem von AMD dokumentierten Vitis-AI-Workflow für die Versal AI Edge Series Gen 2:

1. ONNX-Export mit Operatorensatz 17 und statischer Batchgröße 1.
2. Quantisierung mit AMD Quark und der Konfiguration VINT8 (symmetrisches INT8 mit Zweierpotenz-Skalierungen) sowie den von AMD für die NPU-Kompilierung vorgeschriebenen Optionen: Int32Bias=False, enable_npu_cnn=True, DedicatedQDQPair=True und QuantizeAllOpTypes=True. Für die Kalibrierung wird der standardmäßige Ultralytics-INT8-Kalibrierungslader verwendet, der dieselbe Vorverarbeitung mit Letterboxing, RGB und Werten von 0–1 wie bei der Inferenz nutzt.
3. Gemischte Präzision: Der Modellkopf bleibt im Gleitkommaformat, und der Vitis-AI-Compiler führt ihn auf der NPU in BF16 aus. Die Quantisierung des Kopfes auf INT8 verursacht den größten Teil des Genauigkeitsverlusts. Aus demselben Grund belässt AMDs YOLOv8m-Tutorial den Nachverarbeitungsabschnitt außerhalb von INT8.
4. Compilerkonfiguration: vitisai_config.json legt das Ziel VAIML sowie das Gerät aus name fest.

Genauigkeit#

Die Tabelle vergleicht das exportierte INT8-Modell mit dem FP32-ONNX-Modell auf dem COCO-Val2017-Datensatz (5.000 Bilder) bei 640. Beide Modelle werden mit ONNX Runtime auf der Host-CPU ausgeführt. Die INT8-Modelle wurden mit dem Standarddatensatz coco128.yaml kalibriert; mit eigenen Einsatzbildern lässt sich der Abstand normalerweise verringern.

Bei diesen Host-Ergebnissen wird das quantisierte Modell mit ONNX Runtime auf der CPU ausgeführt. Dies ist die Vergleichsbasis für AMDs Genauigkeitsmethodik bei NPU-Ergebnissen. Die von AMD veröffentlichten YOLOv8m-Ergebnisse auf dem VEK385 verwenden auf der NPU denselben Ansatz mit gemischter Präzision:

Quelle: AMD-YOLOv8m-Tutorial für Versal AI Edge Gen 2, das bei dp_size=1 auch eine durchschnittliche Inferenzzeit von 10.69 ms für 100 VART-Läufe angibt.

Auf Versal AI Edge Gen 2 kompilieren und ausführen#

Das exportierte Verzeichnis ist für den Vitis-AI-Compiler von AMD vorbereitet, der das auf der NPU ausführbare Modell .rai erstellt.

1. Host und Board vorbereiten. Kompiliere auf einem x86-64-Linux-Host mit AMDs Vitis-AI-6.3-Docker-Image für Versal AI Edge Gen 2 und einer Lizenz für den AMD-AI-Engine-Compiler (siehe Lizenzierungsseite von AMD). Richte das VEK385 mithilfe von AMDs Board-Einrichtungsanleitung ein.

2. Kompilieren. Erstelle im Container eine ONNX-Runtime-Sitzung mit dem Vitis AI Execution Provider, wie in AMDs Kompilierungsanleitung beschrieben. Dabei wird der Cache yolo26n/ mit yolo26n.rai im Exportverzeichnis angelegt:

   import onnxruntime as ort
   
   d = "yolo26n_xilinx_model"
   options = {"config_file": f"{d}/vitisai_config.json", "cache_dir": d, "cache_key": "yolo26n", "target": "VAIML"}
   ort.InferenceSession(f"{d}/yolo26n.onnx", providers=["VitisAIExecutionProvider"], provider_options=[options])

   Prüfe yolo26n_xilinx_model/yolo26n/final-vaiml-pass-summary.txt, um zu sehen, welcher Anteil des Modells auf der NPU ausgeführt wird. Beim YOLO26n mit einer Größe von 640 platziert der Vitis-AI-6.3-Compiler von AMD 99,9 % der Operatoren und Rechenlast in einer einzigen Partition auf der VEK385-NPU.

3. Auf dem Board ausführen. Kopiere das Exportverzeichnis auf das VEK385. ONNX Runtime mit dem Vitis AI Execution Provider lädt das kompilierte yolo26n.rai und führt es auf der NPU aus. YOLO("yolo26n_xilinx_model") wählt diesen Provider automatisch aus, wenn er verfügbar ist.

Für die Kompilierung wird nur AMDs ONNX Runtime benötigt. Exportiere daher auf einem beliebigen Linux-Rechner und kopiere das Verzeichnis in den Container, statt Ultralytics dort zu installieren und dadurch möglicherweise die festgelegten Pakete des Containers zu ändern. Wenn Ultralytics zusammen mit AMDs Build onnxruntime-vitisai installiert ist, wie auf dem Board, bleibt dieser Build erhalten, statt durch das standardmäßige onnxruntime ersetzt zu werden.

YOLO-Modellkompatibilität und unterstützte Operatoren#

Ein Beschleuniger beschleunigt nur die Operatoren, die er in Hardware implementiert. Enthält ein Modell einen nicht unterstützten Operator, führt der Compiler diesen Teil des Netzwerks in der Regel auf der Arm-CPU aus. Jeder Wechsel zwischen Beschleuniger und CPU erhöht die Latenz. Manche Operatoren lassen sich nicht aufteilen: Für die Versal AI Edge Gen 2 NPU führt AMD Operatoren wie NonZero und NonMaxSuppression auf, die das gesamte Modell auf die CPU zwingen können. Die Operatorunterstützung ist der wichtigste Faktor dafür, wie gut ein YOLO-Modell auf AMD Xilinx-Hardware läuft.

Die Tabelle zeigt, wo jeder Operator in einem YOLO26-Modell ausgeführt wird. Ein unveränderter YOLO26n-ONNX-Export enthält 87 SiLU-Aktivierungen, die jeweils als Sigmoid und Mul exportiert werden, sowie 4 MatMul- und 2 Softmax-Operatoren aus den beiden Attention-Blöcken: dem C2PSA-Block am Ende des Backbones (Layer 10) und dem Attention-fähigen C3k2-Block, der die P5-Ausgabe erzeugt (Layer 22).

Quellen: AMD UG1414 – unterstützte Operatoren, PyTorch-Unterstützung für Operatoren sowie die Listen der von Versal AI Edge Gen 2 unterstützten, auf der CPU ausgeführten und nicht unterstützten Operatoren. Die Unterstützung hängt auch von deiner DPU-Konfiguration und den Graphmustern ab. Prüfe daher immer den Aufteilungsbericht des Compilers.

YOLO26 mit Hard-Swish für die DPU vorbereiten#

Die DPU integriert nur ReLU, ReLU6, LeakyReLU, Hard-Swish und Hard-Sigmoid in ihre Faltungen. Hard-Swish ist eine hardwarefreundliche Näherung von SiLU und daher der naheliegende Ersatz. In den YAML-Dateien für Ultralytics-Modelle kannst du mit dem Schlüssel activation die Standardaktivierung der Conv-Blöcke ändern (Anleitung zur Modell-YAML-Konfiguration).

Kopiere yolo26.yaml nach yolo26-hswish.yaml und füge unter den Parametern eine Zeile hinzu:

# Parameters
nc: 80 # number of classes
activation: nn.Hardswish() # default Conv activation, DPU-native
end2end: True # whether to use end-to-end mode

Erstelle anschließend das Modell, übertrage die vortrainierten YOLO26-Gewichte und führe auf deinem Datensatz eine Feinabstimmung durch:

from ultralytics import YOLO

# # YOLO26n mit Hard-Swish-Aktivierungen erstellen; das „n“ im Namen bezeichnet die Nano-Größenvariante
model = YOLO("yolo26n-hswish.yaml").load("yolo26n.pt")  # # vortrainierte Gewichte übertragen

# # Durch Feinabstimmung das Netzwerk an Hard-Swish anpassen
model.train(data="coco8.yaml", epochs=100, imgsz=640)

Aktivierungen haben keine Gewichte, daher werden alle vortrainierten Gewichte übernommen. Der exportierte ONNX-Graph enthält dann 87 HardSwish-Operatoren und keine SiLU-Operatoren. Ersetze coco8.yaml durch deinen eigenen Datensatz und vergleiche vor der Bereitstellung mit dem SiLU-Modell die Genauigkeit im Validierungsmodus.

Attention-Blöcke auf der DPU verarbeiten#

YOLO26 wendet Attention an der niedrigsten Auflösung (ein 20×20-Raster bei einer Eingabegröße von 640) an zwei Stellen an: im C2PSA-Block auf Layer 10 und im Attention-fähigen C3k2-Block auf Layer 22. YOLO11 hat einen C2PSA-Block. Auf einer DPU werden dessen MatMul- und Softmax-Operatoren auf der CPU ausgeführt. Dadurch wird das Modell in abwechselnde DPU- und CPU-Untergraphen aufgeteilt. Du hast drei Möglichkeiten:

1. Die CPU-Blöcke akzeptieren. Das kompilierte .xmodel enthält dann CPU-Untergraphen. Führe es daher mit AMDs Graph Runner aus, der DPU- und CPU-Untergraphen gemeinsam ausführt, sofern für jeden Operator eine CPU-Implementierung vorhanden ist. Andernfalls musst du die fehlenden Operatoren implementieren und registrieren. Bei 20×20 ist die Attention-Berechnung klein, aber jede zusätzliche Übertragung zwischen DPU und CPU erhöht die Latenz. Miss daher die Leistung auf deiner Platine.

2. Eine YAML-Datei ohne Attention verwenden. Ersetze in deiner Hard-Swish-YAML-Datei den C2PSA-Layer durch nn.Identity, damit die von Concat und Detect verwendeten Layer-Indizes gültig bleiben, und deaktiviere Attention in Layer 22:

   backbone:
       # ... layers 0-9 unchanged
       - [-1, 1, nn.Identity, []] # 10 C2PSA removed; keeps later layer indices valid
   
   head:
       # ... layers 11-21 unchanged
       - [-1, 1, C3k2, [1024, True, 0.5, False]] # 22 (P5/32-large), attention disabled
       - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

   Der exportierte ONNX-Graph enthält dann keine MatMul- oder Softmax-Operatoren. Die Attention-Gewichte sind nicht mehr anwendbar (624 von 666 YOLO26n-Gewichten werden übernommen). Führe daher eine längere Feinabstimmung durch und vergleiche die Genauigkeit im Validierungsmodus.

3. Ein Modell ohne Attention verwenden, zum Beispiel YOLOv8, das AMD in eigenen DPU-Beispielen verwendet hat.

Auf Versal AI Edge Gen 2 werden Attention-Operatoren als von der NPU unterstützt aufgeführt, daher sind diese Änderungen normalerweise nicht nötig. Prüfe im Compilerbericht, wo die Operatoren ausgeführt werden, denn laut AMD können auch unterstützte Operatoren aufgrund von Konfigurations- oder Speicherbeschränkungen auf die CPU ausweichen.

Modellkompatibilität auf einen Blick#

Bereitstellung auf anderen AMD-Xilinx-Zielen#

Zynq UltraScale+- und Kria-DPUs sowie die Versal-AI-Edge-NPU der ersten Generation verwenden Vitis-AI-Workflows, die format="xilinx" nicht erzeugt. Trainiere mit Ultralytics und erstelle anschließend das Artefakt für dein Zielgerät mit den AMD-Tools in deren x86-64-Linux-Docker-Images. Wähle den Tab für dein Gerät:

Richte das Board mit einem Hardwaredesign und einem Linux-Image ein, die die Konfiguration des Beschleunigers enthalten, für die du kompiliert hast, und installiere die passende Vitis-AI-Laufzeitumgebung. Siehe die Einrichtungsanleitungen von AMD für Zynq-UltraScale+- und Kria-DPU-Ziele und Versal AI Edge (VEK280). Kopiere anschließend die von deiner Laufzeitumgebung benötigten Artefakte:

In der DPU speichern VART-Puffer Festkommawerte im INT8-Format: Ermittle für jeden Tensor die Form und die fix_point-Skalierung und quantisiere die Eingaben beziehungsweise dequantisiere die Ausgaben vor der Nachverarbeitung. Der Graph Runner gibt die Ausgaben des gesamten Graphen zurück, während ein reiner DPU-Runner die Ausgaben von Zwischen-Untergraphen der DPU zurückgibt, deren Berechnung dein Code abschließen muss. VART-ML auf dem VEK280 verwendet standardmäßig Hardware-Tensoransichten, deren Form, Datentyp und Speicherlayout von den ONNX-Layouts abweichen können. Konfiguriere daher die Eingabe- und Ausgabe-Tensortypen des Runners als CPU-Ansichten oder wandle das Hardwareformat selbst um (siehe AMDs Übersicht zur VART-ML-Architektur).

Anwendungen in der Praxis#

AMD-Xilinx-Geräte sind überall verbreitet, wo Vision-KI in Echtzeit, mit geringem Stromverbrauch und in Sensornähe ausgeführt werden muss:

• Sicherheit in Industrie und Bauwesen: Erkenne Personen und Maschinen in der Nähe schwerer Geräte und überwache Arbeitsbereiche mit Objekterkennung und Objektzählung.
• Bildverarbeitung für Straßenfahrzeuge und Geländefahrzeuge: Führe kamerabasierte Wahrnehmung auf qualifizierten Fahrzeugkomponenten aus und unterstütze autonome Fahrzeuge sowie Fahrerassistenz.
• Intelligente Kameras und Videoanalyse: Kombiniere Videoaufnahme, Kodierung und YOLO-Inferenz auf einem Chip für Sicherheitssysteme und Videoanalyse.
• Industrielle Bildverarbeitung und Qualitätsprüfung: Kombiniere FPGA-basierte Hochgeschwindigkeits-Bildaufnahme mit YOLO-Instanzsegmentierung oder Klassifizierung, um Fehler direkt in der Produktionslinie zu erkennen.
• Robotik und Drohnen: Nutze Kria KR260 oder Versal-Module für Posenschätzung, Erkennung gedrehter Objekte und Navigation mit deterministischer Latenz.

Zusammenfassung#

Beim Export mit format="xilinx" werden Ultralytics-YOLO-Modelle mit AMD Quark für NPUs der Versal AI Edge Series Gen 2 quantisiert. Der Kopf bleibt in BF16, und die Vitis-AI-Compilerkonfiguration wird neben dem Modell gespeichert. Validiere die INT8-Genauigkeit auf einem beliebigen Host, kompiliere das Modell .rai im Vitis-AI-Docker-Image von AMD und führe es auf dem Board mit ONNX Runtime und dem Vitis AI Execution Provider aus.

Ältere AMD-Xilinx-Geräte verwenden andere Workflows. Die DPU auf Zynq UltraScale+ und Kria nutzt die eingefrorene Vitis-AI-3.5-Toolchain und .xmodel-Dateien, benötigt DPU-eigene Aktivierungsfunktionen wie Hard-Swish und führt die Attention auf der CPU aus. Die Versal-AI-Edge-NPU der ersten Generation verwendet den Snapshot-Workflow; die Operatorabdeckung hängt von der Vitis-AI-Version und der Präzision ab.

Weitere Bereitstellungsziele findest du im Leitfaden zu Modellbereitstellungsoptionen, in den bewährten Vorgehensweisen zur Bereitstellung und in Integrationen für Beschleuniger wie Hailo, Rockchip RKNN und Axelera.

Häufig gestellte Fragen#