# GPU Intel

GPU Intel chạy PyTorch thông qua backend XPU, với chuỗi thiết bị là `xpu`. Bản build XPU của PyTorch đến từ một chỉ mục gói riêng biệt, do đó lệnh cài đặt bên dưới sẽ thêm nó như một chỉ mục bổ sung.

## Cài đặt

Cài đặt [trình điều khiển Intel GPU cho PyTorch](https://www.intel.com/content/www/us/en/developer/articles/tool/pytorch-prerequisites-for-intel-gpu/2-15.html), sau đó chạy `xpu-smi` để [kiểm tra xem hệ thống của bạn có phát hiện được GPU hay không](https://dgpu-docs.intel.com/driver/verification.html).

Cài đặt PyTorch từ chỉ mục XPU cùng với Transformers.

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

Kiểm tra xem PyTorch có nhìn thấy các GPU hay không.

```py
import torch

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

Nó in ra `True` và số lượng GPU, ví dụ `True 2`.

## Chọn và sắp xếp XPU

Sử dụng biến môi trường `ZE_AFFINITY_MASK` để chọn XPU. Hãy đặt nó trên cùng một dòng lệnh với lệnh chạy, vì một biến đã xuất mà bạn quên mất có thể âm thầm chuyển một lần chạy sau đó sang các XPU sai.

Ví dụ, để chọn XPU 0 và 2 trong số bốn XPU:

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

PyTorch chỉ nhìn thấy XPU 0 và 2. Thứ tự các giá trị trong `ZE_AFFINITY_MASK` không làm thay đổi thứ tự mà PyTorch liệt kê chúng. Để có thứ tự nhất quán giữa các lần chạy, hãy đặt thêm `ZE_ENABLE_PCI_ID_DEVICE_ORDER=1`, điều này sẽ báo cáo các thiết bị từ PCI bus ID thấp nhất đến cao nhất.

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

Xem [quy định Level Zero](https://oneapi-src.github.io/level-zero-spec/level-zero/latest/core/PROG.html) để biết thêm về việc liệt kê thiết bị.

## Chọn một backend chú ý

Bạn đặt backend chú ý bằng `attn_implementation` khi tải một model, và nó áp dụng cho cả suy luận và huấn luyện. Các model sử dụng [SDPA](./attention_interface) theo mặc định. Với PyTorch 2.8 trở lên, SDPA trên XPU xử lý grouped-query attention trực tiếp, mà không cần lặp lại các đầu key và value trước.

`attn_implementation="flash_attention_2"` sẽ tải [kernels-community/flash-attn2](https://huggingface.co/kernels-community/flash-attn2) từ Hub, nơi có sẵn các bản build cho XPU. Hãy cài đặt phần mở rộng `kernels` để sử dụng. FlashAttention-3 và FlashAttention-4 chỉ chạy trên GPU NVIDIA.

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

## Chạy suy luận

Truyền `device_map="auto"` vào [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để chia một model không vừa trên một XPU duy nhất ra các XPU khả dụng, hoặc `device_map="xpu"` để nạp nó lên một XPU duy nhất. [pipeline()](/docs/transformers/v5.23.0/vi/main_classes/pipelines#transformers.pipeline) sẽ tự động chọn một XPU khi bạn không truyền `device`.

```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) hỗ trợ XPU graphs và asynchronous batching trên GPU Intel, và tự động quyết định việc sử dụng chúng.

## Sử dụng kernel của Hub

Đặt `use_kernels=True` trong [from_pretrained()](/docs/transformers/v5.23.0/vi/main_classes/model#transformers.PreTrainedModel.from_pretrained) để thay thế các lớp được hỗ trợ bằng các kernel tối ưu từ Hub. GPU Intel bao phủ phần lớn các lớp tương tự như GPU NVIDIA, chẳng hạn như activations, RMSNorm và rotary embeddings. Cài đặt extra `kernels` để sử dụng chúng.

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

Hub kernels cũng áp dụng cho quá trình huấn luyện. Việc gọi `model.train()` hoặc `model.eval()` sẽ thay thế các kernel tương ứng với chế độ đó. Để tự chọn một kernel, hãy truyền một [KernelConfig](/docs/transformers/v5.23.0/vi/main_classes/kernels#transformers.KernelConfig) và sử dụng `"xpu"` làm khóa thiết bị cho các ánh xạ cụ thể của XPU. Xem [Tải kernel](./kernel_doc/loading_kernels) để biết ánh xạ đầy đủ.

## Lượng tử hóa mô hình

Quantization cho phép một mô hình lớn hơn vừa với bộ nhớ GPU. Kiểm tra cột Intel GPU trong [tổng quan về quantization](./quantization/overview) để biết các phương pháp chạy trên XPU.

Để tinh chỉnh một mô hình không vừa trong bộ nhớ GPU, hãy tải nó ở 4-bit bằng [bitsandbytes](./quantization/bitsandbytes) và huấn luyện các adapter LoRA bằng [PEFT](./peft).

## Huấn luyện với Trainer

[TrainingArguments](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.TrainingArguments) phát hiện GPU Intel và đặt thiết bị thành `xpu`, nhờ đó [Trainer](/docs/transformers/v5.23.0/vi/main_classes/trainer#transformers.Trainer) huấn luyện trên chúng mà không cần cấu hình thiết bị. `TrainingArguments` kiểm tra hỗ trợ bf16 bằng `torch.xpu.is_bf16_supported()` và ném `ValueError` nếu GPU không hỗ trợ.

```py
from transformers import TrainingArguments

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

Nó in ra `xpu:0` khi `Trainer` sẽ huấn luyện trên một XPU đơn lẻ.

### Huấn luyện phân tán

Huấn luyện phân tán sử dụng backend tập thể `xccl`. Khởi chạy một tiến trình cho mỗi XPU bằng `torchrun` hoặc `accelerate launch`.

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

Xem [DDP](./ddp), [FSDP2](./fsdp), [DeepSpeed ZeRO](./deepspeed) và [Tensor parallelism](./tensor_parallelism) để chọn chiến lược song song.

## Các bước tiếp theo

- Đọc hướng dẫn [khởi động với Intel GPU](https://docs.pytorch.org/docs/stable/notes/get_start_xpu.html) của PyTorch để biết các phần cứng và nền tảng được hỗ trợ.
- Đọc [Các backend Attention](./attention_interface) để tìm hiểu cách `attn_implementation` chọn một hàm attention.

