# Intel GPU

Intel GPU'ler, PyTorch'u `xpu` cihaz dizgesiyle XPU arka ucu üzerinden çalıştırır. PyTorch'un XPU derlemesi ayrı bir paket dizininden gelir; bu nedenle aşağıdaki kurulum komutu, bu dizini ek bir dizin olarak ekler.

## Kurulum

[PyTorch için Intel GPU sürücülerini](https://www.intel.com/content/www/us/en/developer/articles/tool/pytorch-prerequisites-for-intel-gpu/2-15.html) yükleyin, ardından [sisteminizin GPU'yu algıladığını kontrol etmek](https://dgpu-docs.intel.com/driver/verification.html) için `xpu-smi` komutunu çalıştırın.

Transformers ile birlikte PyTorch'u XPU dizininden yükleyin.

```bash
pip install "transformers[torch]" --extra-index-url https://download.pytorch.org/whl/xpu
```

PyTorch'un GPU'ları görebildiğinden emin olun.

```py
import torch

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

`True` ve GPU sayısını, örneğin `True 2` gibi, yazdırır.

## XP'leri seçin ve sıralayın

XPUI seçmek için `ZE_AFFINITY_MASK` ortam değişkenini kullanın. Dışa aktarıp unuttuğunuz bir değişken, sonraki bir çalıştırmayı sessizce yanlış XPUI yönlendirebileceğinden, bu değişkeni çalıştırma komutunun aynı satırında ayarlayın.

Örneğin, dört XPU'dan 0 ve 2 numaralı XP'ları seçmek için:

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

PyTorch yalnızca 0 ve 2 numaralı XPUI'ları görür. `ZE_AFFINITY_MASK` içindeki değerlerin sırası, PyTorch'un bu cihazları listelediği sırayı değiştirmez. Çalışmalar arasında tutarlı bir sıra elde etmek için, cihazları en düşükten en yüksek PCI bus kimliğine göre raporlayan `ZE_ENABLE_PCI_ID_DEVICE_ORDER=1` değerini de ayarlayın.

```cli
ZE_ENABLE_PCI_ID_DEVICE_ORDER=1 ZE_AFFINITY_MASK=0,2 torchrun trainer-program.py ...
```

Cihaz numaralandırma hakkında daha fazla bilgi için [Level Zero spesifikasyonuna](https://oneapi-src.github.io/level-zero-spec/level-zero/latest/core/PROG.html) bakın.

## Bir dikkat arka ucunu seçin

Modeli yüklerken `attn_implementation` ile dikkat (attention) arka ucunu (backend) ayarlar ve bu ayar hem çıkarım (inference) hem de eğitim için geçerlidir. Modeller varsayılan olarak [SDPA](./attention_interface) kullanır. PyTorch 2.8 veya daha yeni sürümlerde, XPU üzerindeki SDPA, anahtar (key) ve değer (value) başlıklarını önce tekrarlamadan gruplu sorgu dikkatini (grouped-query attention) doğrudan işler.

`attn_implementation="flash_attention_2"`, Hub'dan [kernels-community/flash-attn2](https://huggingface.co/kernels-community/flash-attn2) paketini yükler; bu paket XPU derlemelerini içerir. Kullanmak için `kernels` ekini kurun. FlashAttention-3 ve FlashAttention-4 yalnızca NVIDIA GPU'larda çalışır.

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

```py
from transformers import AutoModelForCausalLM

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

## Çıkarım çalıştır

`device_map="auto"` parametresini [from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) fonksiyonuna ileterek, tek bir XPU'ya sığmayan bir modeli kullanılabilir XPU'lar arasında dağıtabilir veya tek bir XPU'ya yüklemek için `device_map="xpu"` kullanabilirsiniz. `device` parametresini iletmediğinizde [pipeline()](/docs/transformers/main/tr/main_classes/pipelines#transformers.pipeline) bir XPU'yu otomatik olarak seçer.

```py
from transformers import AutoModelForCausalLM, AutoTokenizer

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

inputs = tokenizer("Intel 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), Intel GPU'lerde XPU grafiklerini ve asenkron toplu işlemleri destekler ve bunların kullanılıp kullanılmayacağını otomatik olarak belirler.

## Hub çekirdeklerini kullanın

[from_pretrained()](/docs/transformers/main/tr/main_classes/model#transformers.PreTrainedModel.from_pretrained) içinde `use_kernels=True` değerini ayarlayarak desteklenen katmanları Hub’daki optimize edilmiş çekirdeklerle değiştirin. Intel GPU’lar, aktivasyonlar, RMSNorm ve döner gömme (rotary embeddings) gibi NVIDIA GPU’larla büyük ölçüde aynı katmanları kapsar. Bunları kullanmak için `kernels` ekini yükleyin.

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

Hub çekirdekleri eğitim için de geçerlidir. `model.train()` veya `model.eval()` çağrıldığında, ilgili moda ait çekirdekler devreye alınır. Çekirdeği kendiniz seçmek için bir [KernelConfig](/docs/transformers/main/tr/main_classes/kernels#transformers.KernelConfig) iletin ve XPU'ya özgü eşlemeler için cihaz anahtarı olarak `"xpu"` kullanın. Tam eşleme için [Çekirdekleri yükleme](./kernel_doc/loading_kernels) bölümüne bakın.

## Modelleri kuantize et

Quantization, daha büyük bir modelin GPU belleğine sığmasını sağlar. XPU üzerinde çalışan yöntemler için [quantization genel bakış](./quantization/overview) sayfasındaki Intel GPU sütununu kontrol edin.

GPU belleğine sığmayan bir modeli ince ayar yapmak için, modeli [bitsandbytes](./quantization/bitsandbytes) ile 4-bit olarak yükleyin ve [PEFT](./peft) ile LoRA adaptörlerini eğitin.

## Trainer ile Eğitim

[TrainingArguments](/docs/transformers/main/tr/main_classes/trainer#transformers.TrainingArguments), Intel GPU'ları algılar ve cihazı `xpu` olarak ayarlar; bu sayede [Trainer](/docs/transformers/main/tr/main_classes/trainer#transformers.Trainer), herhangi bir cihaz ayarı gerektirmeden bu GPU'lar üzerinde eğitim yapar. `TrainingArguments`, `torch.xpu.is_bf16_supported()` ile bf16 desteğini kontrol eder ve GPU bu özelliği desteklemiyorsa bir `ValueError` fırlatır.

```py
from transformers import TrainingArguments

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

`Trainer` tek bir XPU üzerinde eğitim yapacaksa `xpu:0` yazdırır.

### Dağıtık eğitim

Dağıtık eğitim, `xccl` kolektif arka ucunu kullanır. Her XPU için bir süreç başlatmak için `torchrun` veya `accelerate launch` kullanın.

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

Bir paralelleştirme stratejisi seçmek için [DDP](./ddp), [FSDP2](./fsdp), [DeepSpeed ZeRO](./deepspeed) ve [Tensor parallelism](./tensor_parallelism) seçeneklerine göz atın.

## Sonraki adımlar

- Desteklenen donanımlar ve platformlar için PyTorch [Intel GPU ile başlangıç](https://docs.pytorch.org/docs/stable/notes/get_start_xpu.html) kılavuzunu okuyun.
- `attn_implementation`'in bir dikkat fonksiyonunu nasıl seçtiğini öğrenmek için [Dikkat arka uçları](./attention_interface) bölümünü okuyun.