# AMD GPU

[AMD Instinct](https://www.amd.com/en/products/accelerators/instinct.html) (серии MI200, MI300, MI350) и [Radeon](https://www.amd.com/en/products/graphics/desktops/radeon.html) работают с PyTorch через [ROCm](https://rocm.docs.amd.com/) — программный стек AMD для GPU. Сборка PyTorch для ROCm использует [HIP](https://rocm.docs.amd.com/projects/HIP/en/latest/what_is_hip.html) — аналог CUDA от AMD — чтобы предоставлять доступ к GPU AMD через API `torch.cuda`. Строка устройства — `cuda`, поэтому код, написанный для GPU NVIDIA, работает без изменений. Transformers в рантайме проверяет `torch.version.hip`, чтобы различать платформы и направлять ядра attention и Hub в сборки, специфичные для AMD.

## Установка

Установите ROCm из Docker-образа [huggingface/transformers-pytorch-amd-gpu](https://hub.docker.com/r/huggingface/transformers-pytorch-amd-gpu). Он содержит сборку PyTorch для ROCm, сборку `flash-attn` для GPU MI300 и MI350 (`gfx942` и `gfx950`), а также Transformers, установленные из исходного кода.

```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` и `--device=/dev/dri` предоставляют доступ к GPU AMD внутри контейнера. Установите [kernels](https://github.com/huggingface/kernels) внутри контейнера, чтобы [использовать ядра из Hub](#use-hub-kernels).

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

Чтобы установить на собственную систему, выберите ROCm в [PyTorch install selector](https://pytorch.org/get-started/locally/) и убедитесь, что версия ROCm для wheel поддерживается вашим драйвером.

Убедитесь, что PyTorch видит GPU от 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` равно `None` в сборке PyTorch для CUDA. `gcnArchName` сообщает архитектуру GPU, например `gfx942` для MI300, `gfx950` для MI350 и `gfx1151` для Ryzen AI Max (Strix Halo).

## Выбор и порядок GPU

Используйте `HIP_VISIBLE_DEVICES` для выбора GPU и задания их порядка. Установите его в той же командной строке, что и запуск.

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

PyTorch видит только GPU 0 и 2, которые отображаются на `cuda:0` и `cuda:1`. `ROCR_VISIBLE_DEVICES` фильтрует GPU на более низком уровне стека и обычно устанавливается планировщиками кластеров. Если заданы оба параметра, `HIP_VISIBLE_DEVICES` индексирует GPU, оставшиеся видимыми после применения `ROCR_VISIBLE_DEVICES`.

Используйте `rocm-smi` или `amd-smi`, чтобы получить список GPU и их индексов.

## Запуск вывода

[Pipeline](/docs/transformers/main/ru/main_classes/pipelines#transformers.Pipeline) и `device_map="auto"` автоматически обнаруживают GPU AMD и размещают модель на `cuda`. Также можно явно передать `device_map="cuda"` или `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
```

## Выберите бэкенд внимания

Установите бэкенд внимания с помощью `attn_implementation` при загрузке модели; он применяется как для инференса, так и для обучения. По умолчанию используется SDPA, который работает на всех поддерживаемых PyTorch GPU от AMD. Также доступны два варианта FlashAttention.

| `attn_implementation` | Требуется | Примечания |
|---|---|---|
| `"sdpa"` | – | По умолчанию. |
| `"flash_attention_2"` | [flash-attn](https://github.com/Dao-AILab/flash-attention#amd-rocm-support), собранный для ROCm, или [kernels](https://github.com/huggingface/kernels) | Использует пакет `flash-attn`, если он установлен. Его стандартный бэкенд Composable Kernel (CK) поддерживает GPU MI200, MI300, MI355 и RDNA 3/4, а [образ Docker](#installation) включает его для MI300 или MI350. В противном случае загружает [amd/aiter-flash-attn](https://huggingface.co/kernels/amd/aiter-flash-attn) с Hub. |
| `"flash_attention_3"` | [ядра](https://github.com/huggingface/kernels) | Загружает [amd/aiter-flash-attn](https://huggingface.co/kernels/amd/aiter-flash-attn), готовое ядро FlashAttention из библиотеки [AITER](https://github.com/ROCm/aiter) от AMD. Компиляция не требуется. |

```py
from transformers import AutoModelForCausalLM

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

В ROCm `flash_attention_3` разрешается в ядро AITER и выводит следующее сообщение. Transformers в настоящее время использует псевдоним `kernels-community/aiter-flash-attn`, который перенаправляет на `amd/aiter-flash-attn`. Сообщение относится к пакету FlashAttention-3, поэтому оно появляется даже при установленном `flash_attention_2`.

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

Вы также можете передать репозиторий ядра напрямую с помощью `attn_implementation="kernels-community/aiter-flash-attn"`. См. [Бэкенды внимания](./attention_interface), чтобы узнать, как выбираются бэкенды.

## Использование ядер Hub

Установите `use_kernels=True` в [from_pretrained()](/docs/transformers/main/ru/main_classes/model#transformers.PreTrainedModel.from_pretrained), чтобы заменить поддерживаемые слои на оптимизированные ядра из Hub. Transformers определяет ROCm и выбирает сборку AMD для каждого слоя, например [amd/aiter-rope](https://huggingface.co/kernels/amd/aiter-rope) для вращательных эмбеддингов и [kernels-community/liger-kernels](https://huggingface.co/kernels/kernels-community/liger-kernels) для RMSNorm. При создании собственного [KernelConfig](/docs/transformers/main/ru/main_classes/kernels#transformers.KernelConfig) используйте `"rocm"` в качестве ключа устройства для специфичных для AMD отображений.

```py
from transformers import AutoModelForCausalLM

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

Ядра Hub в основном ускоряют prefill и работу с большими батчами. Перед включением их для декодирования малых батчей проведите бенчмаркинг собственной нагрузки. Полное соответствие описано в разделе [Загрузка ядер](./kernel_doc/loading_kernels).

## Квантование моделей

Среди методов, поддерживаемых на ROCm, — [AWQ](./quantization/awq), [GPT-QModel](./quantization/gptq), [compressed-tensors](./quantization/compressed_tensors) и [Quark](./quantization/quark) от AMD. Поддержка [bitsandbytes](./quantization/bitsandbytes) частичная. GPU MI300 и новее поддерживают FP8 на уровне аппаратного обеспечения. Полный список приведён в [таблице совместимости](./quantization/overview).

## Обучение с помощью Trainer

[TrainingArguments](/docs/transformers/main/ru/main_classes/trainer#transformers.TrainingArguments) определяет GPU AMD и автоматически устанавливает устройство в `cuda`.

```py
from transformers import TrainingArguments

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

### Распределённое обучение

ROCc-сборка PyTorch поставляется с RCCL — реализацией API NCCL от AMD, поэтому бэкенд `nccl`, `torchrun`, [FSDP](./fsdp), [DeepSpeed](./main_classes/deepspeed) и распределённый API Transformers работают без изменений.

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

См. [Tensor parallelism](./tensor_parallelism), [Expert parallelism](./expert_parallelism) и [FSDP](./fsdp) для доступных вариантов.

## Ограничения

- `CodeCarbonCallback` несовместим с ROCm. Укажите в [TrainingArguments](/docs/transformers/main/ru/main_classes/trainer#transformers.TrainingArguments) параметр `report_to` так, чтобы исключить `codecarbon`.
- Методы квантования, отмеченные 🔴 для ROCm в [таблице совместимости](./quantization/overview), используют ядра, доступные только в CUDA, и не могут быть загружены на GPU AMD.

## Дальнейшие шаги

- Ознакомьтесь с [документацией ROCm](https://rocm.docs.amd.com/) для настройки драйвера и PyTorch.
- Просмотрите сборки ROCm в организациях [AMD](https://huggingface.co/amd) и [kernels-community](https://huggingface.co/kernels-community).
- Ознакомьтесь с разделом [Загрузка ядер](./kernel_doc/loading_kernels), чтобы настроить, какие ядра заменяют какие слои.