# AMD GPU

[AMD Instinct](https://www.amd.com/en/products/accelerators/instinct.html) (seri MI200, MI300, MI350) dan GPU [Radeon](https://www.amd.com/en/products/graphics/desktops/radeon.html) menjalankan PyTorch melalui [ROCm](https://rocm.docs.amd.com/), tumpukan perangkat lunak GPU dari AMD. Build ROCm dari PyTorch menggunakan [HIP](https://rocm.docs.amd.com/projects/HIP/en/latest/what_is_hip.html), antarmuka pemrograman mirip CUDA dari AMD, untuk mengekspos GPU AMD melalui API `torch.cuda`. String perangkatnya adalah `cuda`, sehingga kode yang ditulis untuk GPU NVIDIA dapat berjalan tanpa perubahan. Transformers memeriksa `torch.version.hip` saat runtime untuk membedakan keduanya dan mengarahkan kernel attention dan Hub ke build yang spesifik untuk AMD.

## Instalasi

Install ROCm dari image Docker [huggingface/transformers-pytorch-amd-gpu](https://hub.docker.com/r/huggingface/transformers-pytorch-amd-gpu). Image ini menyertakan build PyTorch untuk ROCm, build `flash-attn` untuk GPU MI300 dan MI350 (`gfx942` dan `gfx950`), serta Transformers yang diinstal dari source.

```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` dan `--device=/dev/dri` mengekspos GPU AMD ke dalam container. Instal [kernels](https://github.com/huggingface/kernels) di dalam container untuk [menggunakan Hub kernels](#use-hub-kernels).

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

Untuk menginstal di sistem Anda sendiri, pilih ROCm di [PyTorch install selector](https://pytorch.org/get-started/locally/) dan pastikan versi wheel ROCm didukung oleh driver Anda.

Periksa bahwa PyTorch mendeteksi 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` bernilai `None` pada build PyTorch CUDA. `gcnArchName` melaporkan arsitektur GPU, misalnya `gfx942` untuk MI300, `gfx950` untuk MI350, dan `gfx1151` untuk Ryzen AI Max (Strix Halo).

## Pilih dan urutkan GPU

Gunakan `HIP_VISIBLE_DEVICES` untuk memilih GPU dan mengatur urutannya. Atur ini pada baris perintah yang sama dengan eksekusi.

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

PyTorch hanya melihat GPU 0 dan 2, yang dipetakan ke `cuda:0` dan `cuda:1`. `ROCR_VISIBLE_DEVICES` memfilter GPU pada tingkat yang lebih rendah dalam stack dan umumnya diset oleh penjadwal cluster. Jika keduanya diset, `HIP_VISIBLE_DEVICES` mengindeks GPU yang masih terlihat oleh `ROCR_VISIBLE_DEVICES`.

Gunakan `rocm-smi` atau `amd-smi` untuk menampilkan daftar GPU dan indeksnya.

## Jalankan inferensi

[Pipeline](/docs/transformers/main/id/main_classes/pipelines#transformers.Pipeline) dan `device_map="auto"` mendeteksi GPU AMD dan menempatkan model di `cuda` secara otomatis. Anda juga dapat meneruskan `device_map="cuda"` atau `device_map="cuda:1"` secara eksplisit.

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

## Pilih backend perhatian

Atur backend perhatian dengan `attn_implementation` saat Anda memuat model, dan ini berlaku untuk inferensi maupun pelatihan. SDPA adalah default dan berfungsi di setiap GPU AMD yang didukung oleh PyTorch. Dua opsi FlashAttention juga tersedia.

| `attn_implementation` | Diperlukan | Catatan |
|---|---|---|
| `"sdpa"` | – | Default. |
| `"flash_attention_2"` | [flash-attn](https://github.com/Dao-AILab/flash-attention#amd-rocm-support) yang dibangun untuk ROCm, atau [kernels](https://github.com/huggingface/kernels) | Menggunakan paket `flash-attn` saat terinstal. Backend Composable Kernel (CK) bawaannya mendukung GPU MI200, MI300, MI355, dan RDNA 3/4, dan [image Docker](#installation) menyertakannya pada MI300 atau MI350. Jika tidak, memuat [amd/aiter-flash-attn](https://huggingface.co/kernels/amd/aiter-flash-attn) dari Hub. |
| `"flash_attention_3"` | [kernels](https://github.com/huggingface/kernels) | Memuat [amd/aiter-flash-attn](https://huggingface.co/kernels/amd/aiter-flash-attn), kernel FlashAttention yang sudah dibangun sebelumnya dari pustaka [AITER](https://github.com/ROCm/aiter) AMD. Tidak memerlukan kompilasi. |

```py
from transformers import AutoModelForCausalLM

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

Pada ROCm, `flash_attention_3` dipecahkan ke kernel AITER dan mencatat log berikut. Transformers saat ini menggunakan alias `kernels-community/aiter-flash-attn`, yang mengarahkan ulang ke `amd/aiter-flash-attn`. Pesan tersebut merujuk ke paket FlashAttention-3, sehingga muncul bahkan ketika `flash_attention_2` terpasang.

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

Anda juga dapat melewatkan repositori kernel secara langsung dengan `attn_implementation="kernels-community/aiter-flash-attn"`. Lihat [Attention backends](./attention_interface) untuk cara backend dipilih.

## Gunakan kernel Hub

Set `use_kernels=True` di [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk mengganti lapisan yang didukung dengan kernel yang dioptimalkan dari Hub. Transformers mendeteksi ROCm dan memilih build AMD untuk setiap lapisan, seperti [amd/aiter-rope](https://huggingface.co/kernels/amd/aiter-rope) untuk rotary embeddings dan [kernels-community/liger-kernels](https://huggingface.co/kernels/kernels-community/liger-kernels) untuk RMSNorm. Saat Anda menulis [KernelConfig](/docs/transformers/main/id/main_classes/kernels#transformers.KernelConfig) kustom, gunakan `"rocm"` sebagai kunci perangkat untuk pemetaan yang spesifik AMD.

```py
from transformers import AutoModelForCausalLM

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

Kernel hub terutama mempercepat prefill dan batch besar. Benchmark workload Anda sendiri sebelum mengaktifkannya untuk decoding batch kecil. Lihat [Memuat kernel](./kernel_doc/loading_kernels) untuk pemetaan lengkap.

## Kuantisasi model

Metode yang didukung pada ROCm meliputi [AWQ](./quantization/awq), [GPT-QModel](./quantization/gptq), [compressed-tensors](./quantization/compressed_tensors), dan [Quark](./quantization/quark) dari AMD. [bitsandbytes](./quantization/bitsandbytes) memiliki dukungan parsial. GPU MI300 dan yang lebih baru mendukung FP8 secara native. Lihat [tabel kompatibilitas](./quantization/overview) untuk daftar lengkap.

## Latih dengan Trainer

[TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) mendeteksi GPU AMD dan mengatur perangkat ke `cuda` secara otomatis.

```py
from transformers import TrainingArguments

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

### Pelatihan terdistribusi

Build ROCm dari PyTorch menyertakan RCCL, implementasi API NCCL dari AMD, sehingga backend `nccl`, `torchrun`, [FSDP](./fsdp), [DeepSpeed](./main_classes/deepspeed), dan API distributed Transformers berfungsi tanpa perubahan.

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

Lihat [Paralelisme tensor](./tensor_parallelism), [Paralelisme pakar](./expert_parallelism), dan [FSDP](./fsdp) untuk opsi yang tersedia.

## Keterbatasan

- `CodeCarbonCallback` tidak kompatibel dengan ROCm. Atur `report_to` di [TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) untuk mengecualikan `codecarbon`.
- Metode kuantisasi yang ditandai 🔴 untuk ROCm dalam [tabel kompatibilitas](./quantization/overview) bergantung pada kernel khusus CUDA dan gagal dimuat pada GPU AMD.

## Langkah selanjutnya

- Baca [dokumentasi ROCm](https://rocm.docs.amd.com/) untuk pengaturan driver dan PyTorch.
- Jelajahi build ROCm di organisasi [AMD](https://huggingface.co/amd) dan [kernels-community](https://huggingface.co/kernels-community).
- Baca [Memuat kernel](./kernel_doc/loading_kernels) untuk menyesuaikan kernel mana yang menggantikan lapisan mana.