# GPU da Intel

GPUs da Intel executam o PyTorch por meio do backend XPU, com a string de dispositivo `xpu`. A build XPU do PyTorch vem de um índice de pacotes separado, portanto o comando de instalação abaixo o adiciona como um índice extra.

## Instalação

Instale os [drivers de GPU Intel para PyTorch](https://www.intel.com/content/www/us/en/developer/articles/tool/pytorch-prerequisites-for-intel-gpu/2-15.html) e, em seguida, execute `xpu-smi` para [verificar se o sistema detecta a GPU](https://dgpu-docs.intel.com/driver/verification.html).

Instale o PyTorch a partir do índice XPU junto com o Transformers.

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

Verifique se o PyTorch consegue visualizar as GPUs.

```py
import torch

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

Ele imprime `True` e o número de GPUs, por exemplo `True 2`.

## Selecionar e ordenar XPUs

Use a variável de ambiente `ZE_AFFINITY_MASK` para selecionar XPUs. Defina-a na mesma linha de comando da execução, pois uma variável exportada que você esquece pode, silenciosamente, direcionar uma execução posterior para as XPUs erradas.

Por exemplo, para selecionar as XPUs 0 e 2 de um total de quatro:

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

O PyTorch enxerga apenas os XPU 0 e 2. A ordem dos valores em `ZE_AFFINITY_MASK` não altera a ordem em que o PyTorch os enumera. Para obter uma ordem consistente entre execuções, defina também `ZE_ENABLE_PCI_ID_DEVICE_ORDER=1`, que relata os dispositivos do menor para o maior ID de barramento PCI.

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

Consulte a [especificação do Level Zero](https://oneapi-src.github.io/level-zero-spec/level-zero/latest/core/PROG.html) para mais informações sobre a enumeração de dispositivos.

## Escolha um backend de atenção

Você define o backend de atenção com `attn_implementation` ao carregar um modelo, e ele se aplica tanto à inferência quanto ao treinamento. Os modelos usam [SDPA](./attention_interface) por padrão. Com o PyTorch 2.8 ou posterior, o SDPA em XPU lida diretamente com a grouped-query attention, sem precisar repetir as cabeças de chave e valor antes.

`attn_implementation="flash_attention_2"` carrega [kernels-community/flash-attn2](https://huggingface.co/kernels-community/flash-attn2) do Hub, que inclui builds para XPU. Instale o extra `kernels` para usá-lo. FlashAttention-3 e FlashAttention-4 só rodam em GPUs 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",
)
```

## Executar inferência

Passe `device_map="auto"` para [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para dividir um modelo que não cabe em um único XPU entre os XPUs disponíveis, ou `device_map="xpu"` para carregá-lo em um único XPU. [pipeline()](/docs/transformers/main/pt/main_classes/pipelines#transformers.pipeline) seleciona um XPU automaticamente quando você não passa `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) suporta gráficos XPU e loteamento assíncrono em GPUs Intel e decide automaticamente se deve usá-los.

## Use kernels do Hub

Defina `use_kernels=True` em [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para substituir as camadas compatíveis por kernels otimizados do Hub. As GPUs da Intel cobrem a maioria das mesmas camadas que as GPUs da NVIDIA, como ativações, RMSNorm e embeddings rotativos. Instale o extra `kernels` para usá-los.

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

Os kernels do Hub também se aplicam ao treinamento. Ao chamar `model.train()` ou `model.eval()`, os kernels para o modo correspondente são ativados. Para escolher um kernel manualmente, passe um [KernelConfig](/docs/transformers/main/pt/main_classes/kernels#transformers.KernelConfig) e use `"xpu"` como a chave de dispositivo para mapeamentos específicos de XPU. Consulte [Carregando kernels](./kernel_doc/loading_kernels) para o mapeamento completo.

## Quantizar modelos

A quantização permite que um modelo maior caiba na memória da GPU. Consulte a coluna de GPU Intel na [visão geral da quantização](./quantization/overview) para ver os métodos que rodam em XPU.

Para ajustar um modelo que não cabe na memória da GPU, carregue-o em 4 bits com [bitsandbytes](./quantization/bitsandbytes) e treine adaptadores LoRA com [PEFT](./peft).

## Treinar com o Trainer

[TrainingArguments](/docs/transformers/main/pt/main_classes/trainer#transformers.TrainingArguments) detecta GPUs da Intel e define o dispositivo como `xpu`, de modo que o [Trainer](/docs/transformers/main/pt/main_classes/trainer#transformers.Trainer) treina neles sem nenhuma configuração de dispositivo. O `TrainingArguments` verifica o suporte a bf16 com `torch.xpu.is_bf16_supported()` e levanta um `ValueError` se a GPU não tiver suporte a ele.

```py
from transformers import TrainingArguments

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

Ele imprime `xpu:0` quando o `Trainer` vai treinar em um único XPU.

### Treinamento distribuído

O treinamento distribuído usa o backend coletivo `xccl`. Inicie um processo por XPU com `torchrun` ou `accelerate launch`.

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

Veja [DDP](./ddp), [FSDP2](./fsdp), [DeepSpeed ZeRO](./deepspeed) e [Tensor parallelism](./tensor_parallelism) para escolher uma estratégia de paralelismo.

## Próximas etapas

- Leia o guia [introdução ao PyTorch em GPU Intel](https://docs.pytorch.org/docs/stable/notes/get_start_xpu.html) para obter informações sobre o hardware e as plataformas compatíveis.
- Leia [Backends de atenção](./attention_interface) para saber como `attn_implementation` seleciona uma função de atenção.