# GPU de AMD

Las GPU [AMD Instinct](https://www.amd.com/en/products/accelerators/instinct.html) (series MI200, MI300, MI350) y [Radeon](https://www.amd.com/en/products/graphics/desktops/radeon.html) ejecutan PyTorch a través de [ROCm](https://rocm.docs.amd.com/), el stack de software de GPU de AMD. La compilación de PyTorch para ROCm utiliza [HIP](https://rocm.docs.amd.com/projects/HIP/en/latest/what_is_hip.html), la interfaz de programación de AMD similar a CUDA, 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 de Hub a compilaciones específicas de AMD.

## Instalación

Instale ROCm desde la imagen Docker [huggingface/transformers-pytorch-amd-gpu](https://hub.docker.com/r/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.

```bash
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](https://github.com/huggingface/kernels) dentro del contenedor para [usar kernels del Hub](#use-hub-kernels).

```bash
pip install "transformers[kernels]"
```

Para instalarlo en su propio sistema, seleccione ROCm en el [selector de instalación de PyTorch](https://pytorch.org/get-started/locally/) 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.

```py
import torch

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

```txt
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.

```cli
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](/docs/transformers/v5.23.0/es/main_classes/pipelines#transformers.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"`.

```py
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))
```

```txt
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.

| `attn_implementation` | Requisitos | Notas |
|---|---|---|
| `"sdpa"` | – | Por defecto. |
| `"flash_attention_2"` | [flash-attn](https://github.com/Dao-AILab/flash-attention#amd-rocm-support) creado para ROCm, o [kernels](https://github.com/huggingface/kernels) | Utiliza el paquete `flash-attn` cuando está instalado. Su backend Composable Kernel (CK) predeterminado es compatible con las GPU MI200, MI300, MI355 y RDNA 3/4, y la [imagen de Docker](#installation) lo incluye en MI300 o MI350. En caso contrario, carga [amd/aiter-flash-attn](https://huggingface.co/kernels/amd/aiter-flash-attn) desde el Hub. |
| `"flash_attention_3"` | [kernels](https://github.com/huggingface/kernels) | Carga [amd/aiter-flash-attn](https://huggingface.co/kernels/amd/aiter-flash-attn), un kernel de FlashAttention precompilado de la biblioteca [AITER](https://github.com/ROCm/aiter) de AMD. No requiere compilación. |

```py
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`.

```txt
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](./attention_interface) para ver cómo se seleccionan los backends.

## Usar kernels de Hub

Establezca `use_kernels=True` en [from_pretrained()](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel.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](https://huggingface.co/kernels/amd/aiter-rope) para los embeddings rotatorios y [kernels-community/liger-kernels](https://huggingface.co/kernels/kernels-community/liger-kernels) para RMSNorm. Al escribir una [KernelConfig](/docs/transformers/v5.23.0/es/main_classes/kernels#transformers.KernelConfig) personalizada, utilice `"rocm"` como clave de dispositivo para los mapeos específicos de AMD.

```py
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](./kernel_doc/loading_kernels) para la correspondencia completa.

## Cuantizar modelos

Los métodos compatibles con ROCm incluyen [AWQ](./quantization/awq), [GPT-QModel](./quantization/gptq), [compressed-tensors](./quantization/compressed_tensors) y [Quark](./quantization/quark) de AMD. [bitsandbytes](./quantization/bitsandbytes) tiene soporte parcial. Las GPU MI300 y más nuevas admiten FP8 de forma nativa. Consulte la [tabla de compatibilidad](./quantization/overview) para obtener la lista completa.

## Entrenar con Trainer

[TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments) detecta las GPU de AMD y establece el dispositivo en `cuda` automáticamente.

```py
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](./fsdp), [DeepSpeed](./main_classes/deepspeed) y la API distribuida de Transformers funcionan sin cambios.

```py
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),
)
```

```bash
torchrun --nproc_per_node=8 train.py
```

Consulte [Tensor parallelism](./tensor_parallelism), [Expert parallelism](./expert_parallelism) y [FSDP](./fsdp) para conocer las opciones disponibles.

## Limitaciones

- `CodeCarbonCallback` no es compatible con ROCm. Establezca `report_to` en [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments) para excluir `codecarbon`.
- Los métodos de cuantización marcados con 🔴 para ROCm en la [tabla de compatibilidad](./quantization/overview) dependen de kernels exclusivos de CUDA y no se pueden cargar en GPUs de AMD.

## Próximos pasos

- Lea la [documentación de ROCm](https://rocm.docs.amd.com/) para la configuración del controlador y de PyTorch.
- Explora las compilaciones de ROCm en las organizaciones [AMD](https://huggingface.co/amd) y [kernels-community](https://huggingface.co/kernels-community).
- Lea [Carga de kernels](./kernel_doc/loading_kernels) para personalizar qué kernels reemplazan qué capas.

