AMD-Xilinx-Bereitstellung von Ultralytics YOLO mit Vitis AI#

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.

Diese Anleitung erläutert die einzelnen AMD-Xilinx-Gerätefamilien, die Ausführung von AI auf diesen Geräten, die von den jeweiligen Beschleunigern unterstützten Ultralytics-YOLO-Operatoren und den schrittweisen Arbeitsablauf für die Bereitstellung von YOLO-Modellen auf Zynq UltraScale+-, Kria- und Versal-Hardware.

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.

graph LR
    A[Camera / video input]:::start --> B[Arm CPU<br>Linux, preprocessing,<br>post-processing]:::proc
    B <--> C[AI accelerator<br>DPU in programmable logic<br>or NPU on AI Engines + PL]:::out
    B --> D[Application<br>alerts, control, display]:::start

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff

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:

graph TD
    A[Start: which AMD device<br>is on your board?]:::start --> B{Device family?}:::decide
    B -->|Zynq UltraScale+ MPSoC<br>or Kria K26| C[DPU flow<br>Vitis AI 3.5]:::proc
    B -->|Versal AI Edge<br>VEK280| D[NPU snapshot flow<br>Vitis AI 6.3]:::proc
    B -->|Versal AI Edge Gen 2<br>VEK385| E[NPU Quark flow<br>Vitis AI 6.3]:::proc
    C --> F[Train YOLO with Hard-Swish<br>then compile to .xmodel]:::out
    D --> G[Run your model on calibration<br>images to capture a snapshot]:::out
    E --> H[Quantize ONNX with Quark<br>then compile to .rai]:::out

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff

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.

graph LR
    subgraph S1 [Stock YOLO26 on the DPU]
        A1[Conv]:::out --> A2[SiLU<br>CPU]:::error --> A3[Conv]:::out --> A4[SiLU<br>CPU]:::error --> A5[...]:::proc
    end
    subgraph S2 [Hard-Swish YOLO26 on the DPU]
        B1[Backbone<br>Conv + Hard-Swish<br>DPU]:::out --> B2[C2PSA attention<br>CPU]:::error --> B3[Neck<br>DPU]:::out --> B4[C3k2 attention<br>CPU]:::error --> B5[Detect head<br>DPU]:::out --> B6[Sigmoid and<br>post-processing<br>CPU]:::error
    end

    classDef proc fill:#2196F3,color:#fff
    classDef out fill:#9C27B0,color:#fff
    classDef error fill:#F44336,color:#fff

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#

YOLO26 noch heute auf AMD Xilinx bereitstellen#

Bis ein nativer Export verfügbar ist, umfasst die Bereitstellung vier Schritte:

graph LR
    A[1. Train or fine-tune<br>Ultralytics YOLO]:::start --> B{Target?}:::decide
    B -->|Versal NPU| C[2. Export to ONNX<br>model.export]:::proc
    B -->|Zynq or Kria DPU| D[2. Keep the trained<br>PyTorch checkpoint]:::proc
    C --> E[3. Quantize and compile<br>Vitis AI 6.3 Docker]:::proc
    D --> F[3. Quantize and compile<br>Vitis AI 3.5 Docker]:::proc
    E --> G[4. Run on the board<br>VART-ML or ONNX Runtime]:::out
    F --> H[4. Run on the board<br>VART]:::out
    G -.->|accuracy check| A
    H -.->|accuracy check| A

    classDef start fill:#4CAF50,color:#fff
    classDef proc fill:#2196F3,color:#fff
    classDef decide fill:#FF9800,color:#fff
    classDef out fill:#9C27B0,color:#fff

Schritt 1: Modell trainieren oder feinabstimmen#

Trainiere mit deinen eigenen Daten im Trainingsmodus oder auf der Ultralytics-Plattform. Beginne bei DPU-Zielgeräten mit der Hard-Swish-YAML-Datei. Erfasse mit dem Validierungsmodus einen Ausgangswert, damit du später die Auswirkungen der Quantisierung auf die Genauigkeit messen kannst.

Schritt 2: Für NPU-Zielgeräte nach ONNX exportieren#

ONNX ist die gemeinsame Eingabe für AMDs NPU-Abläufe. Beim DPU-Ablauf wird der trainierte PyTorch-Prüfpunkt direkt im Vitis AI 3.5-Docker-Image quantisiert; DPU-Nutzer können diesen Schritt also überspringen. Exportiere mit einer festen Batchgröße von 1 und einer von AMD unterstützten Opset-Version. AMDs YOLOv8m-Tutorial für Versal AI Edge Gen 2 verwendet Opset 17.

from ultralytics import YOLO

# # Das in Schritt 1 trainierte Modell laden
model = YOLO("runs/detect/train/weights/best.pt")

# # Für den AMD-Compiler mit statischer Form nach ONNX exportieren
model.export(format="onnx", opset=17, imgsz=640)  # # erstellt 'best.onnx' neben 'best.pt'

Alle Optionen findest du unter ONNX-Integration und Exportargumente. Wenn nms nicht gesetzt ist, führe NMS nach der Inferenz auf der CPU aus. Bei YOLO26 wählt nms=False stattdessen den NMS-freien Kopf aus. Bette NMS nicht mit nms=True ein, denn AMD führt NonMaxSuppression unter den Operatoren auf, die das gesamte Modell auf die CPU zwingen können.

Schritt 3: Mit Vitis AI quantisieren und kompilieren#

Für die folgenden Arbeitsabläufe werden AMD-Docker-Images auf einem x86-64-Linux-Host verwendet. Für diesen Schritt brauchst du die Platine nicht. Wähle den Tab für dein Gerät aus:

Schritt 4: Auf dem Board ausführen und validieren#

Bereite zuerst das Board vor. Darauf müssen ein Hardwaredesign und ein Linux-Image laufen, die die kompilierte Beschleunigerkonfiguration enthalten, sowie die dazu passende Vitis-AI-Laufzeitumgebung. Siehe die Einrichtungsanleitungen von AMD für Zynq UltraScale+- und Kria-DPU-Ziele, Versal AI Edge (VEK280) und Versal AI Edge Gen 2 (VEK385).

Kopiere anschließend die Artefakte, die deine Laufzeitumgebung benötigt:

Bei den NPU-Abläufen dekodiert der exportierte ONNX-Graph bereits die Boxen und wendet die Sigmoid-Funktion auf die Klassenwerte an, sodass der Host die Ausgabe nur noch interpretieren muss:

• nms nicht gesetzt: Erkennungsmodelle geben einen (1, 4 + nc, anchors)-Tensor mit xywh Boxen und Bewertungen pro Klasse aus. Wähle die beste Klasse für jeden Anker aus, wandle die Boxen in Eckkoordinaten um, filtere nach Konfidenz und führe NMS aus; die Ultralytics-Funktion non_max_suppression führt alle diese Schritte aus.
• nms=False (YOLO26): Das Modell gibt einen (1, max_det, 6)-Tensor mit [x1, y1, x2, y2, score, class] Zeilen aus, für den lediglich ein Konfidenzschwellenwert festgelegt werden muss.

In beiden Fällen musst du die Boxen von der Eingabe mit Letterboxing auf das ursprüngliche Bild zurückskalieren. Nur bei Graphen, die vor dem Dekodierungsschritt abgeschnitten werden, müssen die Boxen auf dem Host dekodiert werden. Auf der DPU enthalten VART-Puffer Festkommawerte im INT8-Format: Ermittle Form und fix_point-Skalierung jedes Tensors, quantisiere die Eingaben und dequantisiere die Ausgaben, bevor du die obigen Schritte ausführst. Der Graph Runner gibt die Ausgaben des vollständigen Graphen zurück, während ein reiner DPU-Runner Zwischenausgaben der DPU-Teilgraphen zurückgibt, deren Berechnung dein Code abschließen muss. Die obigen Layouts sind ONNX-Layouts (CPU-Ansicht): VART-ML verwendet standardmäßig Hardware-Tensoransichten, deren Form, Datentyp und Speicherlayout abweichen können. Konfiguriere daher die Eingabe- und Ausgabetensortypen des Runners als CPU-Ansichten oder wandle das Hardwareformat selbst um (siehe AMDs Übersicht zur VART-ML-Architektur).

Vergleiche die Genauigkeit auf dem Gerät mit der FP32-Baseline aus Schritt 1 anhand deines eigenen Validierungssatzes und derselben Leistungskennzahlen, beispielsweise mAP. Die von AMD veröffentlichten YOLOv8m-Ergebnisse auf dem VEK385 zeigen den Genauigkeitsverlust beim INT8-Einsatz:

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.

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#

AMD-Xilinx-Geräte führen YOLO-Modelle über zwei Beschleunigergenerationen aus. Die DPU in Zynq UltraScale+ und Kria verwendet den eingefrorenen Vitis-AI-3.5-Ablauf und erzeugt .xmodel-Dateien. Sie benötigt DPU-native Aktivierungsfunktionen wie Hard-Swish und führt Attention auf der CPU aus. Die NPU in Versal AI Edge und Versal AI Edge Gen 2 nutzt aktuelle Vitis-AI-Versionen. Die NPU der zweiten Generation unterstützt SiLU- und Attention-Operatoren und führt AMDs YOLOv8m-Beispiel auf dem VEK385 fast vollständig auf der NPU aus. Die Abdeckung der Operatoren durch die frühere VEK280-NPU hängt dagegen von der Vitis-AI-Version und der Präzision ab.

Der native Ultralytics-Export für AMD-Xilinx-Geräte ist in Kürze verfügbar. Bis dahin kannst du mit Ultralytics trainieren, für Versal-NPU-Ziele nach ONNX exportieren oder für DPU-Ziele den PyTorch-Prüfpunkt beibehalten und wie oben beschrieben mit Vitis AI kompilieren. Informationen zu weiteren Bereitstellungszielen findest du im Leitfaden zu Modellbereitstellungsoptionen, in den bewährten Methoden für die Bereitstellung und bei Beschleunigerintegrationen wie Hailo, Rockchip RKNN und Axelera.

Häufig gestellte Fragen#