Treino e inferência em GPU AMD com Ultralytics YOLO, ROCm e MIGraphX#

O Ultralytics YOLO funciona em GPUs AMD Instinct e Radeon compatíveis através do ROCm, a pilha aberta de computação para GPU da AMD. Com uma compilação PyTorch para ROCm, podes treinar, validar e fazer previsões com modelos .pt usando o mesmo argumento device=0 que em qualquer outra GPU, sem alterações ao código.

Para a implementação, exporta o modelo treinado para ONNX e executa-o através do MIGraphX, o motor de otimização de grafos e inferência da AMD. O backend ONNX do Ultralytics deteta o ROCm e seleciona automaticamente o MIGraphXExecutionProvider do ONNX Runtime, pelo que a mesma chamada predict que funciona em GPUs NVIDIA também funciona em GPUs AMD. A integração contínua agendada do Ultralytics executa a exportação ONNX e a inferência MIGraphX para cada tarefa em hardware de GPU AMD.

Instalação#

A pilha Python é instalada inteiramente através de pip a partir dos índices de pacotes wheel ROCm da AMD, pelo que não são necessários pacotes apt nem acesso root para o PyTorch, o plugin ou as bibliotecas de runtime ROCm, desde que o anfitrião já tenha instalado o controlador de kernel de GPU AMD (amdgpu / /dev/kfd).

# 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

O Ultralytics instala onnx automaticamente na primeira exportação ONNX. Na primeira inferência ONNX num sistema ROCm, também instala o plugin do fornecedor de execução MIGraphX (onnxruntime-ep-migraphx) e as bibliotecas de runtime MIGraphX que este carrega (migraphx-libs), com versões fixadas e testadas em conjunto. O plugin só é publicado para Python 3.11 ou posterior em Linux x86_64; noutras versões de Python ou arquiteturas, ou com YOLO_AUTOINSTALL=false e sem o plugin instalado, a inferência ONNX recorre à CPU e apresenta um aviso. Para instruções detalhadas e boas práticas, consulta o nosso guia de instalação do YOLO26; se tiveres dificuldades, consulta o nosso guia de problemas comuns.

Confirma que o PyTorch deteta a GPU AMD antes de treinar ou exportar:

import torch

print(torch.cuda.is_available())  # Verdadeiro numa instalação ROCm funcional
print(torch.cuda.get_device_name(0))  # Nome da GPU AMD, por exemplo, AMD Radeon 8060S
print(torch.version.hip)  # Versão HIP da compilação PyTorch para ROCm, None em compilações CUDA ou CPU

Treinar em GPUs AMD com PyTorch ROCm#

O treino, a validação e a previsão nativos em modelos .pt são executados em GPUs AMD através do PyTorch ROCm, independentemente do fluxo de inferência MIGraphX descrito abaixo. Instala uma compilação PyTorch para ROCm conforme indicado em Instalação e usa os mesmos argumentos de dispositivo que em qualquer outra execução de treino do Ultralytics:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

# Treinar na primeira GPU AMD disponibilizada pelo PyTorch ROCm
results = model.train(data="coco8.yaml", epochs=100, imgsz=640, device=0)

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

A validação e a previsão de modelos .pt usam a mesma seleção de dispositivo:

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

Exportação e inferência com MIGraphX#

O ONNX Runtime é um motor de inferência multiplataforma que executa um único modelo ONNX em muitos backends de hardware através de fornecedores de execução (EPs) conectáveis. Cada EP mapeia o grafo ONNX para um acelerador específico: CUDA para GPUs NVIDIA, CoreML para Apple silicon e MIGraphX para GPUs AMD com ROCm. O MIGraphX é fornecido como o plugin onnxruntime-ep-migraphx e compila o grafo num programa otimizado para a tua GPU.

A inferência MIGraphX usa a exportação ONNX padrão. Exporta o modelo para ONNX (format="onnx") e a inferência do Ultralytics usará automaticamente o backend MIGraphXExecutionProvider para executar o modelo ONNX na tua GPU AMD.

Principais funcionalidades da inferência MIGraphX#

• Seleção automática do fornecedor: num anfitrião ROCm, o backend ONNX regista o plugin e seleciona MIGraphXExecutionProvider sem alterações ao código. Se o plugin estiver em falta ou não for carregado, a inferência recorre à CPU e apresenta um aviso.
• Otimização do grafo: o MIGraphX aplica fusão de operadores, planeamento de memória e seleção de kernels otimizados para arquiteturas de GPU AMD.
• Vinculação de E/S sem cópia: as entradas e saídas são associadas diretamente a tensores da GPU através do protocolo DLPack, evitando transferências de e para o host durante a inferência.
• Opções de precisão: executa em FP32 ou exporta um modelo ONNX FP16 para inferência com precisão reduzida.
• Artefacto portátil: um único ficheiro .onnx funciona em CPUs, GPUs NVIDIA e GPUs AMD, permitindo-te usar várias plataformas a partir de uma única exportação.
• Implementação reproduzível: toda a pilha (PyTorch ROCm, o plugin MIGraphX e as respetivas bibliotecas) é instalada através de pip a partir dos índices de pacotes wheel ROCm da AMD.

Tarefas suportadas#

A inferência MIGraphX é compatível com as sete tarefas do Ultralytics. A segmentação semântica e a estimativa de profundidade só estão disponíveis com YOLO26, a única família que inclui esses cabeçalhos.

Uso#

Antes de consultares as instruções de utilização, não te esqueças de ver a variedade de modelos YOLO26 disponibilizados pelo Ultralytics. Isto vai ajudar-te a escolher o modelo mais adequado aos requisitos do teu projeto.

O formato ONNX é compatível com os modos Export, Predict e Validate. A inferência e a validação numa GPU AMD requerem um sistema ROCm com o plugin MIGraphX instalado. Exporta o teu modelo e, em seguida, carrega o modelo exportado para executar inferências ou validar a sua precisão em device=0.

from ultralytics import YOLO

# Carrega um modelo YOLO26
model = YOLO("yolo26n.pt")

# Exporta o modelo para o formato ONNX
model.export(format="onnx")  # cria 'yolo26n.onnx'

from ultralytics import YOLO

# Carrega o modelo ONNX exportado e executa a inferência numa GPU AMD
model = YOLO("yolo26n.onnx")

# O provedor de execução MIGraphX é selecionado automaticamente no ROCm
results = model.predict("https://ultralytics.com/images/bus.jpg", device=0)

from ultralytics import YOLO

# Carrega o modelo ONNX exportado
model = YOLO("yolo26n.onnx")

# Valida a precisão no conjunto de dados COCO8 numa GPU AMD
metrics = model.val(data="coco8.yaml", device=0)

Argumentos de exportação#

A inferência MIGraphX reutiliza os argumentos de exportação ONNX. As opções mais relevantes para a implementação em GPU AMD são:

Para consultar a lista completa de argumentos de exportação, vê a integração ONNX e a página da documentação do Ultralytics sobre exportação.

Implementação em GPUs AMD com MIGraphX#

Para obter um ambiente pronto a executar, Dockerfile-amd cria a imagem ultralytics/ultralytics:latest-amd com PyTorch ROCm e o MIGraphX EP pré-instalados. Consulta Utilizar GPUs no Guia de início rápido do Docker para ver as flags docker run que disponibilizam GPUs AMD ao contentor.

Benchmarks#

As avaliações comparativas do YOLO26 abaixo foram realizadas pela equipa do Ultralytics numa GPU AMD Radeon 8060S (Ryzen AI Max+ PRO 395), comparando a velocidade e a precisão entre PyTorch e ONNX com o provedor de execução MIGraphX. Ambos os formatos são executados na GPU com precisão FP32: PyTorch através do ROCm e ONNX através do MIGraphX.

Resumo da compatibilidade#

A compatibilidade com um produto ou runtime AMD não implica compatibilidade com todos os aceleradores AMD. Esta tabela resume o estado atual no pacote Python do Ultralytics.

Resumo#

Neste guia, aprendeste a treinar modelos Ultralytics YOLO26 em GPUs AMD com PyTorch ROCm usando o argumento padrão device=0 e, em seguida, a exportá-los para ONNX para acelerar a inferência através do provedor de execução MIGraphX do ONNX Runtime. O backend ONNX seleciona automaticamente MIGraphXExecutionProvider, armazena em cache o programa compilado para acelerar carregamentos posteriores e é compatível com todas as tarefas do YOLO26 sem exigir alterações ao código.

Para outros destinos de implementação, consulta a página do guia de integrações e compara os formatos de exportação com o modo de avaliação comparativa.

Perguntas frequentes#