GPU de AMD

Las GPU AMD Instinct (series MI200, MI300, MI350) y Radeon ejecutan PyTorch a través de ROCm, el stack de software de GPU de AMD. La compilación de PyTorch para ROCm utiliza HIP, la interfaz de programación similar a CUDA de AMD, para exponer las GPU de AMD a través de la API torch.cuda. La cadena de dispositivo es cuda, por lo que el código escrito para GPU de NVIDIA se ejecuta sin cambios. Transformers comprueba torch.version.hip en tiempo de ejecución para distinguir entre ambas y dirige los kernels de atención y Hub a compilaciones específicas de AMD.

Instalación

Instale ROCm desde la imagen Docker huggingface/transformers-pytorch-amd-gpu. Incluye la compilación de PyTorch para ROCm, una compilación de flash-attn para las GPU MI300 y MI350 (gfx942 y gfx950) y Transformers instalado desde el código fuente.

docker run -it --device=/dev/kfd --device=/dev/dri --group-add video \
    --ipc=host --shm-size 16G \
    huggingface/transformers-pytorch-amd-gpu

--device=/dev/kfd y --device=/dev/dri exponen las GPU de AMD al contenedor. Instala kernels dentro del contenedor para usar kernels del Hub.

pip install "transformers[kernels]"

Para instalarlo en su propio sistema, seleccione ROCm en el selector de instalación de PyTorch y asegúrese de que la versión de ROCm de la rueda sea compatible con su controlador.

Comprueba que PyTorch detecta las GPU de AMD.

import torch

print(torch.version.hip, torch.cuda.is_available(), torch.cuda.device_count())
print(torch.cuda.get_device_properties(0).gcnArchName)

7.2.53211 True 2
gfx942:sramecc+:xnack-

torch.version.hip es None en una compilación de PyTorch para CUDA. gcnArchName informa la arquitectura de la GPU, por ejemplo gfx942 para MI300, gfx950 para MI350 y gfx1151 para Ryzen AI Max (Strix Halo).

Seleccionar y ordenar GPUs

Use HIP_VISIBLE_DEVICES para seleccionar las GPU y establecer su orden. Establézcalo en la misma línea de comandos que la ejecución.

HIP_VISIBLE_DEVICES=0,2 torchrun trainer-program.py ...

PyTorch solo ve las GPU 0 y 2, que se mapean a cuda:0 y cuda:1. ROCR_VISIBLE_DEVICES filtra las GPU en un nivel inferior de la pila y suele establecerse por los programadores de clúster. Si se establecen ambos, HIP_VISIBLE_DEVICES indexa las GPU que quedan visibles tras ROCR_VISIBLE_DEVICES.

Use rocm-smi o amd-smi para listar las GPU y sus índices.

Ejecutar inferencia

Pipeline y device_map="auto" detectan las GPU de AMD y colocan el modelo en cuda automáticamente. También puedes pasar explícitamente device_map="cuda" o device_map="cuda:1".

from transformers import AutoModelForCausalLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")
model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B", dtype="bfloat16", device_map="auto"
)

inputs = tokenizer("The French Bread Law states", return_tensors="pt").to(model.device)
output = model.generate(**inputs, do_sample=False, max_new_tokens=50)
print(tokenizer.decode(output[0], skip_special_tokens=True))

The French Bread Law states that the French government must provide a certain amount of bread for the citizens of the country. The law is passed by the French parliament. The French parliament is a body of the French government. The French government is a body of the French state. The

Elegir un backend de atención

Establece el backend de atención con attn_implementation al cargar un modelo, y se aplica tanto a la inferencia como al entrenamiento. SDPA es el predeterminado y funciona en todas las GPU de AMD compatibles con PyTorch. También están disponibles dos opciones de FlashAttention.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    dtype="bfloat16",
    device_map="auto",
    attn_implementation="flash_attention_3",
)

En ROCm, flash_attention_3 se resuelve al kernel AITER y registra lo siguiente. Transformers actualmente usa el alias kernels-community/aiter-flash-attn, que redirige a amd/aiter-flash-attn. El mensaje se refiere al paquete FlashAttention-3, por lo que aparece incluso cuando está instalado flash_attention_2.

You do not have `flash_attn` installed, using `kernels-community/aiter-flash-attn` from the `kernels` library instead!

También puede pasar el repositorio del kernel directamente con attn_implementation="kernels-community/aiter-flash-attn". Consulte Backends de atención para ver cómo se seleccionan los backends.

Usar kernels de Hub

Establezca use_kernels=True en from_pretrained() para reemplazar las capas compatibles con kernels optimizados del Hub. Transformers detecta ROCm y selecciona la compilación de AMD para cada capa, como amd/aiter-rope para los embeddings rotatorios y kernels-community/liger-kernels para RMSNorm. Al escribir una KernelConfig personalizada, utilice "rocm" como clave de dispositivo para los mapeos específicos de AMD.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B", dtype="bfloat16", device_map="auto", use_kernels=True
)

Los kernels de Hub aceleran principalmente el prefill y los lotes grandes. Realice un benchmark de su propia carga de trabajo antes de habilitarlos para la decodificación con lotes pequeños. Consulte Carga de kernels para la correspondencia completa.

Cuantizar modelos

Los métodos compatibles con ROCm incluyen AWQ, GPT-QModel, compressed-tensors y Quark de AMD. bitsandbytes tiene soporte parcial. Las GPU MI300 y más nuevas admiten FP8 de forma nativa. Consulte la tabla de compatibilidad para obtener la lista completa.

Entrenar con Trainer

TrainingArguments detecta las GPU de AMD y establece el dispositivo en cuda automáticamente.

from transformers import TrainingArguments

training_args = TrainingArguments(
    output_dir="./outputs",
    bf16=True,
)

Entrenamiento distribuido

La compilación de PyTorch para ROCM incluye RCCL, la implementación de la API de NCCL de AMD, por lo que el backend nccl, torchrun, FSDP, DeepSpeed y la API distribuida de Transformers funcionan sin cambios.

import torch
from transformers import AutoModelForCausalLM, DistributedConfig

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-1.7B",
    dtype=torch.bfloat16,
    distributed_config=DistributedConfig(tp_size=2, fsdp_size=4),
)

torchrun --nproc_per_node=8 train.py

Consulte Tensor parallelism, Expert parallelism y FSDP para conocer las opciones disponibles.

Limitaciones

• CodeCarbonCallback no es compatible con ROCm. Establezca report_to en TrainingArguments para excluir codecarbon.
• Los métodos de cuantización marcados con 🔴 para ROCm en la tabla de compatibilidad dependen de kernels exclusivos de CUDA y no se pueden cargar en GPUs de AMD.

Próximos pasos

• Lea la documentación de ROCm para la configuración del controlador y de PyTorch.
• Explora las compilaciones de ROCm en las organizaciones AMD y kernels-community.
• Lea Carga de kernels para personalizar qué kernels reemplazan qué capas.