# NVIDIA GPU

GPU NVIDIA menjalankan PyTorch melalui CUDA, dengan string perangkat `cuda`. Sebagian besar kernel attention dan optimasi serving di Transformers mendukung CUDA, dan beberapa di antaranya, seperti FlashAttention-3 dan FlashAttention-4, hanya berjalan di CUDA.

## Instalasi

Install driver CUDA untuk GPU Anda, lalu install PyTorch dan Transformers. Lihat [panduan instalasi](./installation) untuk perangkat NVIDIA Spark (ARM64), yang memerlukan PyTorch dari indeks paket NVIDIA.

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

Periksa bahwa PyTorch dapat melihat GPU.

```py
import torch

print(torch.cuda.is_available(), torch.cuda.device_count())
```

Ia mencetak `True` dan jumlah GPU, misalnya `True 4`.

## Pilih dan urutkan GPU

Gunakan variabel lingkungan `CUDA_VISIBLE_DEVICES` untuk memilih GPU dan mengatur urutannya. Tetapkan variabel ini pada baris perintah yang sama dengan eksekusi, karena variabel yang diekspor namun terlupakan dapat secara diam-diam mengarahkan eksekusi berikutnya ke GPU yang salah.

Sebagai contoh, untuk memilih GPU 0 dan 2 dari empat GPU:

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

PyTorch hanya melihat GPU 0 dan 2, yang dipetakan ke `cuda:0` dan `cuda:1`. Untuk membalik urutannya (gunakan GPU 2 sebagai `cuda:0` dan GPU 0 sebagai `cuda:1`):

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

Untuk menjalankan tanpa GPU:

```cli
CUDA_VISIBLE_DEVICES= python trainer-program.py ...
```

CUDA secara default menomori GPU dari yang tercepat, yang mungkin tidak sesuai dengan `nvidia-smi`. Atur `CUDA_DEVICE_ORDER=PCI_BUS_ID` agar indeks di `CUDA_VISIBLE_DEVICES` sesuai dengan `nvidia-smi`.

```cli
CUDA_DEVICE_ORDER=PCI_BUS_ID CUDA_VISIBLE_DEVICES=0,2 torchrun trainer-program.py ...
```

## Pilih backend perhatian

Anda mengatur backend perhatian dengan `attn_implementation` saat memuat model, dan ini berlaku untuk inferensi maupun pelatihan. Model menggunakan [SDPA](./attention_interface) secara default. GPU NVIDIA juga mendukung tiga versi FlashAttention. Ketika paket FlashAttention tidak terpasang, Transformers memuat kernel yang sudah dibangun sebelumnya dari Hub, yang memerlukan ekstra `kernels` (`pip install "transformers[kernels]"`).

| `attn_implementation` | GPU | Hub kernel saat paket tidak terinstal |
|---|---|---|
| `"flash_attention_2"` | Ampere atau lebih baru | `kernels-community/flash-attn2` |
| `"flash_attention_3"` | Ampere atau lebih baru | `kernels-community/vllm-flash-attn3` |
| `"flash_attention_4"` | Hopper atau lebih baru | `kernels-community/flash-attn4` |

```py
from transformers import AutoModelForCausalLM

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

## Jalankan inferensi

Lewati `device_map="auto"` ke [from_pretrained()](/docs/transformers/main/id/main_classes/model#transformers.PreTrainedModel.from_pretrained) untuk membagi model yang tidak muat di satu GPU ke seluruh GPU yang tersedia, atau `device_map="cuda"` untuk memuatnya di satu GPU. [pipeline()](/docs/transformers/main/id/main_classes/pipelines#transformers.pipeline) memilih GPU secara otomatis ketika Anda tidak melewatkan `device`.

```py
from transformers import AutoModelForCausalLM, AutoTokenizer

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

inputs = tokenizer("NVIDIA GPUs are", return_tensors="pt").to(model.device)
output = model.generate(**inputs, max_new_tokens=50, do_sample=False)
print(tokenizer.decode(output[0], skip_special_tokens=True))
```

[Continuous batching](./continuous_batching) mendukung CUDA graphs dan asynchronous batching pada GPU NVIDIA, serta secara otomatis menentukan apakah fitur tersebut akan digunakan.

## Gunakan kernel Hub

Setel `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. GPU NVIDIA memiliki cakupan paling luas, termasuk activations, RMSNorm, rotary embeddings, lapisan mixture-of-experts MegaBlocks, dan operasi state-space Mamba. Instal extra `kernels` untuk menggunakannya.

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

Hub kernels juga berlaku untuk pelatihan. Memanggil `model.train()` atau `model.eval()` akan mengganti kernel untuk mode tersebut. Untuk memilih kernel secara manual, berikan [KernelConfig](/docs/transformers/main/id/main_classes/kernels#transformers.KernelConfig) dan gunakan `"cuda"` sebagai kunci perangkat untuk pemetaan khusus NVIDIA. Lihat [Memuat kernel](./kernel_doc/loading_kernels) untuk pemetaan lengkapnya.

## Kuantisasi model

Quantization memungkinkan model yang lebih besar muat di memori GPU. Sebagian besar metode quantization di Transformers mendukung CUDA. Periksa kolom CUDA di [ringkasan quantization](./quantization/overview) untuk membandingkannya.

Untuk melakukan fine-tuning pada model yang tidak muat di memori GPU, muat model tersebut dalam 4-bit menggunakan [bitsandbytes](./quantization/bitsandbytes) dan latih adapter LoRA dengan [PEFT](./peft).

## Latih dengan Trainer

[TrainingArguments](/docs/transformers/main/id/main_classes/trainer#transformers.TrainingArguments) mendeteksi GPU NVIDIA dan mengatur perangkat ke `cuda`, sehingga [Trainer](/docs/transformers/main/id/main_classes/trainer#transformers.Trainer) dapat melatih pada GPU tersebut tanpa perlu pengaturan perangkat apa pun. Gunakan presisi campuran bf16 pada GPU Ampere atau yang lebih baru, dan fp16 pada GPU yang lebih lama.

```py
from transformers import TrainingArguments

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

Ia mencetak `cuda:0` ketika `Trainer` akan melatih pada satu GPU.

### Pelatihan terdistribusi

Pelatihan multi-GPU menggunakan backend kolektif [NCCL](https://developer.nvidia.com/nccl). Jalankan satu proses per GPU dengan `torchrun` atau `accelerate launch`.

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

Lihat [DDP](./ddp), [FSDP2](./fsdp), [DeepSpeed ZeRO](./deepspeed), dan [Tensor parallelism](./tensor_parallelism) untuk memilih strategi paralelisme.

## Langkah selanjutnya

- Baca catatan [semantik CUDA](https://docs.pytorch.org/docs/stable/notes/cuda.html) PyTorch untuk memahami cara PyTorch mengelola perangkat, stream, dan memori.
- Baca [penggunaan memori GPU](./model_memory_anatomy) untuk memahami ke mana memori GPU digunakan selama pelatihan.
- Baca [Backend perhatian](./attention_interface) untuk mempelajari bagaimana `attn_implementation` memilih fungsi perhatian.