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 e, em seguida, execute xpu-smi para verificar se o sistema detecta a GPU.

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

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

Verifique se o PyTorch consegue visualizar as GPUs.

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:

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.

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

Consulte a especificação do Level Zero 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 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 do Hub, que inclui builds para XPU. Instale o extra kernels para usá-lo. FlashAttention-3 e FlashAttention-4 só rodam em GPUs NVIDIA.

pip install "transformers[kernels]"

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() 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() seleciona um XPU automaticamente quando você não passa device.

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 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() 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.

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 e use "xpu" como a chave de dispositivo para mapeamentos específicos de XPU. Consulte Carregando 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 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 e treine adaptadores LoRA com PEFT.

Treinar com o Trainer

TrainingArguments detecta GPUs da Intel e define o dispositivo como xpu, de modo que o Trainer treina neles sem qualquer 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.

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.

torchrun --nproc_per_node=2 train.py

Veja DDP, FSDP2, DeepSpeed ZeRO e Tensor parallelism para escolher uma estratégia de paralelismo.

Próximas etapas

• Leia o guia introdução ao PyTorch em GPU Intel para obter informações sobre o hardware e as plataformas compatíveis.
• Leia Backends de atenção para saber como attn_implementation seleciona uma função de atenção.