GPU de Intel

Las GPU de Intel ejecutan PyTorch a través del backend XPU, con la cadena de dispositivo xpu. La compilación de XPU de PyTorch proviene de un índice de paquetes separado, por lo que el comando de instalación siguiente lo añade como un índice adicional.

Instalación

Instale los controladores de GPU de Intel para PyTorch y, a continuación, ejecute xpu-smi para comprobar que su sistema detecta la GPU.

Instale PyTorch desde el índice XPU junto con Transformers.

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

Comprueba que PyTorch puede ver las GPU.

import torch

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

Imprime True y el número de GPUs, por ejemplo True 2.

Seleccionar y ordenar XPUs

Use la variable de entorno ZE_AFFINITY_MASK para seleccionar XPUs. Establézcala en la misma línea de comandos que la ejecución, ya que una variable exportada que se olvida puede enviar silenciosamente una ejecución posterior a las XPUs incorrectas.

Por ejemplo, para seleccionar las XPUs 0 y 2 de un total de cuatro:

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

PyTorch solo ve las XPUs 0 y 2. El orden de los valores en ZE_AFFINITY_MASK no cambia el orden en que PyTorch los enumera. Para obtener un orden consistente entre ejecuciones, también establezca ZE_ENABLE_PCI_ID_DEVICE_ORDER=1, que informa los dispositivos de menor a mayor ID de bus PCI.

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

Consulte la especificación de Level Zero para obtener más información sobre la enumeración de dispositivos.

Elegir un backend de atención

Configura el backend de atención con attn_implementation al cargar un modelo, y se aplica tanto a la inferencia como al entrenamiento. Los modelos usan SDPA de forma predeterminada. Con PyTorch 2.8 o posterior, SDPA en XPU maneja la atención de consulta agrupada directamente, sin repetir primero las cabeceras de clave y valor.

attn_implementation="flash_attention_2" carga kernels-community/flash-attn2 desde el Hub, que incluye compilaciones para XPU. Instala el extra kernels para usarlo. FlashAttention-3 y FlashAttention-4 solo se ejecutan en GPUs de 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",
)

Ejecutar inferencia

Pasa device_map="auto" a from_pretrained() para dividir un modelo que no cabe en un solo XPU entre los XPUs disponibles, o device_map="xpu" para cargarlo en un solo XPU. pipeline() elige un XPU automáticamente si no pasas 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 admite gráficos XPU y lotes asíncronos en GPUs de Intel, y decide automáticamente si usarlos.

Usar kernels de Hub

Establezca use_kernels=True en from_pretrained() para reemplazar las capas compatibles con kernels optimizados del Hub. Las GPU de Intel cubren la mayoría de las mismas capas que las GPU de NVIDIA, como activaciones, RMSNorm y embeddings rotatorios. Instale el extra kernels para usarlos.

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

Los kernels de Hub también se aplican al entrenamiento. Al llamar a model.train() o model.eval(), se intercambian los kernels para ese modo. Para elegir un kernel manualmente, pase un KernelConfig y use "xpu" como clave de dispositivo para las mapeos específicos de XPU. Consulte Carga de kernels para el mapeo completo.

Cuantizar modelos

La cuantización permite que un modelo más grande quepa en la memoria de la GPU. Consulte la columna de GPU de Intel en el resumen de cuantización para ver los métodos que se ejecutan en XPU.

Para ajustar un modelo que no cabe en la memoria de la GPU, cárgalo en 4 bits con bitsandbytes y entrena adaptadores LoRA con PEFT.

Entrenar con Trainer

TrainingArguments detecta las GPU de Intel y establece el dispositivo en xpu, de modo que Trainer entrena en ellas sin ninguna configuración de dispositivo. TrainingArguments comprueba el soporte de bf16 con torch.xpu.is_bf16_supported() y lanza un ValueError si la GPU no lo admite.

from transformers import TrainingArguments

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

Imprime xpu:0 cuando Trainer entrenará en un solo XPU.

Entrenamiento distribuido

El entrenamiento distribuido utiliza el backend colectivo xccl. Inicie un proceso por XPU con torchrun o accelerate launch.

torchrun --nproc_per_node=2 train.py

Consulte DDP, FSDP2, DeepSpeed ZeRO y Tensor parallelism para elegir una estrategia de paralelismo.

Próximos pasos

• Lea la guía de introducción a PyTorch en GPU de Intel para conocer el hardware y las plataformas compatibles.
• Lee Backends de atención para aprender cómo attn_implementation selecciona una función de atención.