AMD GPU Training and Inference with Ultralytics YOLO, ROCm and MIGraphX#

Ultralytics YOLO runs on AMD Instinct and supported Radeon GPUs through ROCm, AMD's open GPU compute stack. With a ROCm build of PyTorch, you train, validate, and predict with .pt models using the same device=0 argument as on any other GPU, with no code changes.

For deployment, export the trained model to ONNX and run it through MIGraphX, AMD's graph-optimization and inference engine. The Ultralytics ONNX backend detects ROCm and selects the ONNX Runtime MIGraphXExecutionProvider automatically, so the same predict call that runs on NVIDIA GPUs runs on AMD GPUs. Scheduled Ultralytics continuous integration runs ONNX export and MIGraphX inference for every task on AMD GPU hardware.

Installation#

The Python stack installs entirely through pip from AMD's ROCm wheel indexes, so no apt packages or root access are needed for PyTorch, the plugin, or the ROCm runtime libraries, provided the host already has the AMD GPU kernel driver (amdgpu / /dev/kfd) in place.

# 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 installs onnx automatically on the first ONNX export. On the first ONNX inference on a ROCm system, it also installs the MIGraphX execution provider plugin (onnxruntime-ep-migraphx) and the MIGraphX runtime libraries it loads (migraphx-libs), pinned to versions tested together. The plugin is published for Python 3.11 or newer on Linux x86_64 only; on other Python versions or architectures, or with YOLO_AUTOINSTALL=false and no plugin installed, ONNX inference falls back to the CPU with a warning. For detailed instructions and best practices, check our YOLO26 Installation guide; if you encounter any difficulties, consult our Common Issues guide.

Verify that PyTorch sees the AMD GPU before training or exporting:

import torch

print(torch.cuda.is_available())  # True on a working ROCm install
print(torch.cuda.get_device_name(0))  # AMD GPU name, e.g. AMD Radeon 8060S
print(torch.version.hip)  # HIP version of the ROCm PyTorch build, None on CUDA or CPU builds

Train on AMD GPUs with PyTorch ROCm#

Native training, validation, and prediction on .pt models run on AMD GPUs through PyTorch ROCm, independent of the MIGraphX inference path below. Install a ROCm build of PyTorch as shown in Installation and use the same device arguments as any other Ultralytics Train run:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Train on the first AMD GPU exposed by PyTorch ROCm
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=0)

# Train across two AMD GPUs
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=[0, 1])

Validation and prediction of .pt models use the same device selection:

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 and Inference with MIGraphX#

ONNX Runtime is a cross-platform inference engine that runs a single ONNX model on many hardware backends through pluggable execution providers (EPs). Each EP maps the ONNX graph onto a specific accelerator: CUDA for NVIDIA GPUs, CoreML for Apple silicon, and MIGraphX for AMD GPUs on ROCm, which ships as the onnxruntime-ep-migraphx plugin and compiles the graph into a tuned program for your GPU.

MIGraphX inference uses the standard ONNX export. Export the model to ONNX (format="onnx") and Ultralytics inference will automatically use the MIGraphXExecutionProvider backend to run the ONNX model on your AMD GPU.

Key Features of MIGraphX Inference#

• Automatic provider selection: On a ROCm host the ONNX backend registers the plugin and selects MIGraphXExecutionProvider with no code changes. If the plugin is missing or fails to load, inference falls back to the CPU with a warning.
• Graph optimization: MIGraphX applies operator fusion, memory planning, and kernel selection tuned for AMD GPU architectures.
• Zero-copy IO binding: Inputs and outputs are bound directly to GPU tensors through the DLPack protocol, avoiding host round-trips during inference.
• Precision options: Run FP32 or export an FP16 ONNX model for reduced-precision inference.
• Portable artifact: A single .onnx file runs on CPUs, NVIDIA GPUs, and AMD GPUs, letting you target multiple platforms from one export.
• Reproducible deployment: The full stack (ROCm PyTorch, the MIGraphX plugin, and its libraries) installs through pip from AMD's ROCm wheel indexes.

Supported Tasks#

MIGraphX inference supports all seven Ultralytics tasks. Semantic segmentation and depth estimation are available only with YOLO26, the only family that ships those heads.

Usage#

Before diving into the usage instructions, be sure to check out the range of YOLO26 models offered by Ultralytics. This will help you choose the most appropriate model for your project requirements.

The ONNX format supports the Export, Predict, and Validate modes. Inference and validation on an AMD GPU require a ROCm system with the MIGraphX plugin installed. Export your model, then load the exported model to run inference or validate its accuracy on device=0.

from ultralytics import YOLO

# Load a YOLO26 model
model = YOLO("yolo26n.pt")

# Export the model to ONNX format
model.export(format="onnx")  # creates 'yolo26n.onnx'

from ultralytics import YOLO

# Load the exported ONNX model and run inference on an AMD GPU
model = YOLO("yolo26n.onnx")

# The MIGraphX execution provider is selected automatically on ROCm
results = model.predict("https://ultralytics.com/images/bus.jpg", device=0)

from ultralytics import YOLO

# Load the exported ONNX model
model = YOLO("yolo26n.onnx")

# Validate accuracy on the COCO8 dataset on an AMD GPU
metrics = model.val(data="coco8.yaml", device=0)

Export Arguments#

MIGraphX inference reuses the ONNX export arguments. The most relevant options for AMD GPU deployment are:

For the full list of export arguments, see the ONNX integration and the Ultralytics documentation page on exporting.

Deploying on AMD GPUs with MIGraphX#

For a ready-to-run environment, Dockerfile-amd builds the ultralytics/ultralytics:latest-amd image with ROCm PyTorch and the MIGraphX EP preinstalled. See Using GPUs in the Docker Quickstart for the docker run flags that expose AMD GPUs to the container.

Benchmarks#

YOLO26 benchmarks below were run by the Ultralytics team on an AMD Radeon 8060S GPU (Ryzen AI Max+ PRO 395), comparing speed and accuracy between PyTorch and ONNX on the MIGraphX execution provider. Both formats run at FP32 precision on the GPU, PyTorch through ROCm and ONNX through MIGraphX.

Support at a Glance#

Support for one AMD product or runtime does not imply support for every AMD accelerator. This table summarizes the current status in the Ultralytics Python package.

Summary#

In this guide, you learned how to train Ultralytics YOLO26 models on AMD GPUs with PyTorch ROCm using the standard device=0 argument, then export them to ONNX for accelerated inference through the ONNX Runtime MIGraphX execution provider. The ONNX backend selects MIGraphXExecutionProvider automatically, caches the compiled program for fast subsequent loads, and supports all YOLO26 tasks with no code changes.

For other deployment targets, browse the integration guide page, and compare export formats with Benchmark mode.

FAQ#