AMD-GPU-Training und -Inferenz mit Ultralytics YOLO, ROCm und MIGraphX#

Ultralytics YOLO läuft auf AMD Instinct und unterstützten Radeon-GPUs über ROCm, den offenen GPU-Rechenstack von AMD. Mit einem ROCm-Build von PyTorch kannst du Modelle mit .pt genauso trainieren, validieren und Vorhersagen erstellen wie auf jeder anderen GPU. Dafür verwendest du dasselbe Argument device=0 und musst den Code nicht ändern.

Für die Bereitstellung exportierst du das trainierte Modell nach ONNX und führst es mit MIGraphX aus, der Engine von AMD zur Graphoptimierung und Inferenz. Das Ultralytics-ONNX-Backend erkennt ROCm und wählt automatisch MIGraphXExecutionProvider von ONNX Runtime aus. So läuft derselbe Aufruf predict sowohl auf NVIDIA- als auch auf AMD-GPUs. Bei geplanten Ultralytics-Läufen für kontinuierliche Integration werden ONNX-Export und MIGraphX-Inferenz für jede Aufgabe auf AMD-GPU-Hardware ausgeführt.

Installation#

Der Python-Stack wird vollständig über pip aus den ROCm-Wheel-Indizes von AMD installiert. Für PyTorch, das Plugin oder die ROCm-Laufzeitbibliotheken sind daher weder apt-Pakete noch Root-Zugriff erforderlich, sofern der AMD-GPU-Kerneltreiber (amdgpu / /dev/kfd) bereits auf dem Host installiert ist.

# Read the GPU architecture from the amdgpu driver, e.g. device-gfx1151
GPU_ARCH=$(grep -rhs '^gfx_target_version' /sys/class/kfd/kfd/topology/nodes | awk '$2 {printf "device-gfx%d%d%x\n", int($2/10000), int($2/100)%100, $2%100}' | sort -u | paste -sd, -)

# ROCm PyTorch + torchvision for the detected architecture
pip install "torch[${GPU_ARCH:?No AMD GPU found}]" "torchvision[$GPU_ARCH]" --index-url https://stable.repo.amd.com/rocm/whl-next/

# Ultralytics
pip install ultralytics

Ultralytics installiert onnx automatisch beim ersten ONNX-Export. Bei der ersten ONNX-Inferenz auf einem ROCm-System installiert es außerdem das MIGraphX-Ausführungsanbieter-Plugin (onnxruntime-ep-migraphx) und die MIGraphX-Laufzeitbibliotheken, die dieses lädt (migraphx-libs. Die Versionen sind aufeinander abgestimmt und getestet. Das Plugin wird ausschließlich für Python 3.11 oder neuer unter Linux x86_64 veröffentlicht. Bei anderen Python-Versionen oder Architekturen sowie bei YOLO_AUTOINSTALL=false, wenn kein Plugin installiert ist, weicht die ONNX-Inferenz mit einer Warnung auf die CPU aus. Ausführliche Anleitungen und bewährte Vorgehensweisen findest du in unserem YOLO26-Installationsleitfaden. Falls du auf Probleme stößt, hilft dir unser Leitfaden zu häufigen Problemen weiter.

Vergewissere dich vor dem Training oder Export, dass PyTorch die AMD-GPU erkennt:

import torch

print(torch.cuda.is_available())  # Bei einer funktionierenden ROCm-Installation True
print(torch.cuda.get_device_name(0))  # Name der AMD-GPU, z. B. AMD Radeon 8060S
print(torch.version.hip)  # HIP-Version des ROCm-PyTorch-Builds; bei CUDA- oder CPU-Builds None

Mit PyTorch ROCm auf AMD-GPUs trainieren#

Natives Training, Validierung und Vorhersagen mit .pt-Modellen laufen über PyTorch ROCm auf AMD-GPUs und sind unabhängig vom weiter unten beschriebenen MIGraphX-Inferenzpfad. Installiere einen ROCm-Build von PyTorch wie unter Installation beschrieben und verwende dieselben Geräteargumente wie bei jedem anderen Ultralytics-Training:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Auf der ersten AMD-GPU trainieren, die PyTorch ROCm erkennt
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=0)

# Auf zwei AMD-GPUs trainieren
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

Für Validierung und Vorhersagen mit .pt-Modellen wird dasselbe Gerät ausgewählt:

yolo detect val model=path/to/best.pt data=coco8.yaml device=0
yolo predict model=path/to/best.pt source=path/to/image.jpg device=0

yolo detect train data=coco8.yaml model=yolo26n.pt device=0 amp=False

Export und Inferenz mit MIGraphX#

ONNX Runtime ist eine plattformübergreifende Inferenz-Engine, die ein einzelnes ONNX-Modell über austauschbare Ausführungsanbieter (EPs) auf vielen Hardware-Backends ausführt. Jeder EP ordnet den ONNX-Graphen einem bestimmten Beschleuniger zu: CUDA für NVIDIA-GPUs, CoreML für Apple Silicon und MIGraphX für AMD-GPUs mit ROCm. MIGraphX wird als Plugin onnxruntime-ep-migraphx bereitgestellt und kompiliert den Graphen zu einem für deine GPU optimierten Programm.

Für die MIGraphX-Inferenz wird der standardmäßige ONNX-Export verwendet. Exportiere das Modell nach ONNX (format="onnx"), und Ultralytics wählt für die Inferenz automatisch das Backend MIGraphXExecutionProvider, um das ONNX-Modell auf deiner AMD-GPU auszuführen.

Wichtige Funktionen der MIGraphX-Inferenz#

• Automatische Anbieterauswahl: Auf einem ROCm-Host registriert das ONNX-Backend das Plugin und wählt MIGraphXExecutionProvider aus, ohne dass du den Code ändern musst. Fehlt das Plugin oder kann es nicht geladen werden, wird die Inferenz mit einer Warnung auf der CPU ausgeführt.
• Graphoptimierung: MIGraphX führt Operatorfusion, Speicherplanung und Kernel-Auswahl durch, abgestimmt auf AMD-GPU-Architekturen.
• Ein-/Ausgabebindung ohne Kopieren: Ein- und Ausgaben werden über das DLPack-Protokoll direkt an GPU-Tensoren gebunden. So entfallen während der Inferenz Umwege über den Host.
• Genauigkeitsoptionen: Führe das Modell mit FP32 aus oder exportiere ein FP16-ONNX-Modell für Inferenz mit geringerer Genauigkeit.
• Portables Artefakt: Eine einzelne .onnx-Datei läuft auf CPUs, NVIDIA-GPUs und AMD-GPUs. Damit kannst du mit einem Export mehrere Plattformen abdecken.
• Reproduzierbare Bereitstellung: Der gesamte Stack (ROCm PyTorch, das MIGraphX-Plugin und dessen Bibliotheken) wird über pip aus den ROCm-Wheel-Indizes von AMD installiert.

Unterstützte Aufgaben#

Die MIGraphX-Inferenz unterstützt alle sieben Ultralytics-Aufgaben. Semantische Segmentierung und Tiefenschätzung sind nur mit YOLO26 verfügbar, der einzigen Modellfamilie mit entsprechenden Ausgabeköpfen.

Verwendung#

Bevor du mit den Anwendungshinweisen beginnst, solltest du dir die verschiedenen YOLO26-Modelle von Ultralytics ansehen. So findest du das Modell, das am besten zu den Anforderungen deines Projekts passt.

Das ONNX-Format unterstützt die Modi Export, Vorhersage und Validierung. Für Inferenz und Validierung auf einer AMD-GPU benötigst du ein ROCm-System mit installiertem MIGraphX-Plugin. Exportiere dein Modell und lade es anschließend, um Inferenz auszuführen oder seine Genauigkeit auf device=0 zu validieren.

from ultralytics import YOLO

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

# Exportiere das Modell in das ONNX-Format
model.export(format="onnx")  # erstellt 'yolo26n.onnx'

from ultralytics import YOLO

# Das exportierte ONNX-Modell laden und Inferenz auf einer AMD GPU ausführen
model = YOLO("yolo26n.onnx")

# Der MIGraphX-Ausführungsanbieter wird unter ROCm automatisch ausgewählt
results = model.predict("https://ultralytics.com/images/bus.jpg", device=0)

from ultralytics import YOLO

# Das exportierte ONNX-Modell laden
model = YOLO("yolo26n.onnx")

# Die Genauigkeit auf dem COCO8-Datensatz auf einer AMD GPU validieren
metrics = model.val(data="coco8.yaml", device=0)

Exportargumente#

Die MIGraphX-Inferenz verwendet dieselben Exportargumente wie ONNX. Für die Bereitstellung auf einer AMD GPU sind diese Optionen besonders relevant:

Die vollständige Liste der Exportargumente findest du in der ONNX-Integration und auf der Ultralytics-Dokumentationsseite zum Export.

Bereitstellung auf AMD GPUs mit MIGraphX#

Für eine sofort einsatzbereite Umgebung erstellt Dockerfile-amd das Image ultralytics/ultralytics:latest-amd mit vorinstalliertem ROCm PyTorch und MIGraphX-EP. Im Docker-Schnellstart unter GPUs verwenden findest du die docker run-Flags, mit denen AMD GPUs für den Container verfügbar gemacht werden.

Benchmarks#

Die folgenden YOLO26-Benchmarks wurden vom Ultralytics-Team auf einer AMD Radeon 8060S GPU (Ryzen AI Max+ PRO 395) durchgeführt. Dabei wurden Geschwindigkeit und Genauigkeit von PyTorch und ONNX mit dem MIGraphX-Ausführungsanbieter verglichen. Beide Formate werden auf der GPU mit FP32-Genauigkeit ausgeführt: PyTorch über ROCm und ONNX über MIGraphX.

Unterstützung auf einen Blick#

Die Unterstützung eines AMD-Produkts oder einer Laufzeitumgebung bedeutet nicht, dass alle AMD-Beschleuniger unterstützt werden. Diese Tabelle fasst den aktuellen Stand im Ultralytics-Python-Paket zusammen.

Zusammenfassung#

In dieser Anleitung hast du erfahren, wie du Ultralytics-YOLO26-Modelle auf AMD GPUs mit PyTorch ROCm und dem standardmäßigen Argument device=0 trainierst und sie anschließend für eine beschleunigte Inferenz über den MIGraphX-Ausführungsanbieter von ONNX Runtime nach ONNX exportierst. Das ONNX-Backend wählt MIGraphXExecutionProvider automatisch aus, speichert das kompilierte Programm für schnellere nachfolgende Ladevorgänge zwischen und unterstützt alle YOLO26-Aufgaben ohne Codeänderungen.

Weitere Bereitstellungsziele findest du auf der Integrationsübersicht. Mit dem Benchmark-Modus kannst du Exportformate vergleichen.

Häufig gestellte Fragen#