GPU Intel

Les GPU Intel exécutent PyTorch via l’arrière-plan XPU, avec la chaîne de périphérique xpu. La compilation XPU de PyTorch provient d’un index de paquets distinct, la commande d’installation ci-dessous l’ajoute donc comme index supplémentaire.

Installation

Installez les Intel GPU drivers for PyTorch, puis exécutez xpu-smi pour vérifier que votre système détecte le GPU.

Installez PyTorch depuis l'index XPU ainsi que Transformers.

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

Vérifiez que PyTorch peut détecter les GPU.

import torch

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

Il affiche True et le nombre de GPU, par exemple True 2.

Sélectionner et ordonner les XPUs

Utilisez la variable d’environnement ZE_AFFINITY_MASK pour sélectionner les XPU. Définissez-la sur la même ligne de commande que l’exécution, car une variable exportée que vous oubliez peut envoyer silencieusement une exécution ultérieure vers les mauvais XPU.

Par exemple, pour sélectionner les XPUs 0 et 2 parmi quatre :

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

PyTorch ne détecte que les XPU 0 et 2. L’ordre des valeurs dans ZE_AFFINITY_MASK ne modifie pas l’ordre dans lequel PyTorch les énumère. Pour obtenir un ordre cohérent d’une exécution à l’autre, définissez également ZE_ENABLE_PCI_ID_DEVICE_ORDER=1, qui signale les appareils du plus petit au plus grand identifiant de bus PCI.

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

Consultez la spécification Level Zero pour en savoir plus sur l'énumération des appareils.

Choisir un backend d'attention

Vous définissez le backend d'attention avec attn_implementation lors du chargement d'un modèle, et il s'applique à la fois à l'inférence et à l'entraînement. Les modèles utilisent SDPA par défaut. Avec PyTorch 2.8 ou une version ultérieure, SDPA sur XPU gère directement l'attention à requêtes groupées, sans avoir à répéter d'abord les têtes de clé et de valeur.

attn_implementation="flash_attention_2" charge kernels-community/flash-attn2 depuis le Hub, qui fournit des builds XPU. Installez l’extra kernels pour l’utiliser. FlashAttention-3 et FlashAttention-4 ne s’exécutent que sur des GPU 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",
)

Exécuter l'inférence

Passez device_map="auto" à from_pretrained() pour répartir un modèle qui ne tient pas sur un seul XPU sur les XPUs disponibles, ou device_map="xpu" pour le charger sur un XPU unique. pipeline() sélectionne automatiquement un XPU si vous ne passez pas 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 prend en charge les graphiques XPU et le lotissement asynchrone sur les GPU Intel et décide automatiquement s'il doit les utiliser.

Utiliser les noyaux du Hub

Définissez use_kernels=True dans from_pretrained() pour remplacer les couches prises en charge par des noyaux optimisés du Hub. Les GPU Intel couvrent la plupart des mêmes couches que les GPU NVIDIA, tels que les activations, RMSNorm et les embeddings rotationnels. Installez l’extra kernels pour les utiliser.

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

Les noyaux du Hub s'appliquent également à l'entraînement. L'appel de model.train() ou de model.eval() bascule sur les noyaux correspondant à ce mode. Pour choisir un noyau vous-même, passez un KernelConfig et utilisez "xpu" comme clé d'appareil pour les mappages spécifiques à XPU. Consultez Chargement des noyaux pour le mappage complet.

Quantifier les modèles

La quantification permet à un modèle plus volumineux de tenir en mémoire GPU. Consultez la colonne Intel GPU dans le résumé de la quantization pour les méthodes qui s'exécutent sur XPU.

Pour affiner un modèle qui ne tient pas dans la mémoire GPU, chargez-le en 4 bits avec bitsandbytes et entraînez des adaptateurs LoRA avec PEFT.

Entraîner avec Trainer

TrainingArguments détecte les GPU Intel et définit le dispositif sur xpu, de sorte que Trainer entraîne sur ces GPU sans aucune configuration de dispositif. TrainingArguments vérifie la prise en charge de bf16 avec torch.xpu.is_bf16_supported() et lève une ValueError si le GPU ne le prend pas en charge.

from transformers import TrainingArguments

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

Il affiche xpu:0 lorsque Trainer entraîne sur un seul XPU.

Entraînement distribué

L’entraînement distribué utilise le backend collectif xccl. Lancez un processus par XPU avec torchrun ou accelerate launch.

torchrun --nproc_per_node=2 train.py

Consultez DDP, FSDP2, DeepSpeed ZeRO et Tensor parallelism pour choisir une stratégie de parallélisme.

Étapes suivantes

• Consultez le guide pour débuter avec PyTorch sur GPU Intel pour connaître le matériel et les plateformes pris en charge.
• Lisez Backends d'attention pour comprendre comment attn_implementation sélectionne une fonction d'attention.