# GPU Intel

Les GPU Intel exécutent PyTorch via l’arrière-plan XPU, avec la chaîne de périphérique `xpu`. La version 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](https://www.intel.com/content/www/us/en/developer/articles/tool/pytorch-prerequisites-for-intel-gpu/2-15.html), puis exécutez `xpu-smi` pour [vérifier que votre système détecte le GPU](https://dgpu-docs.intel.com/driver/verification.html).

Installez PyTorch depuis l'index XPU ainsi que Transformers.

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

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

```py
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 :

```cli
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`, ce qui permet de signaler les appareils du plus petit au plus grand ID de bus PCI.

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

Consultez la [spécification Level Zero](https://oneapi-src.github.io/level-zero-spec/level-zero/latest/core/PROG.html) 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](./attention_interface) 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](https://huggingface.co/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.

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

## Exécuter l'inférence

Passez `device_map="auto"` à [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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()](/docs/transformers/v5.23.0/fr/main_classes/pipelines#transformers.pipeline) sélectionne automatiquement un XPU si vous ne passez pas `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) 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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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.

```py
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](/docs/transformers/v5.23.0/fr/main_classes/kernels#transformers.KernelConfig) et utilisez `"xpu"` comme clé d'appareil pour les mappages spécifiques à XPU. Consultez [Chargement des noyaux](./kernel_doc/loading_kernels) 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](./quantization/overview) pour les méthodes qui s'exécutent sur XPU.

Pour affiner un modèle qui ne tient pas en mémoire GPU, chargez-le en 4 bits avec [bitsandbytes](./quantization/bitsandbytes) et entraînez des adaptateurs LoRA avec [PEFT](./peft).

## Entraîner avec Trainer

[TrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments) détecte les GPU Intel et définit l'appareil sur `xpu`, de sorte que [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) entraîne sur ces GPU sans aucun paramètre d'appareil. `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.

```py
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`.

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

Consultez [DDP](./ddp), [FSDP2](./fsdp), [DeepSpeed ZeRO](./deepspeed) et [Tensor parallelism](./tensor_parallelism) pour choisir une stratégie de parallélisme.

## Étapes suivantes

- Consultez le guide [pour débuter avec PyTorch sur GPU Intel](https://docs.pytorch.org/docs/stable/notes/get_start_xpu.html) pour connaître le matériel et les plateformes pris en charge.
- Lisez [Backends d'attention](./attention_interface) pour comprendre comment `attn_implementation` sélectionne une fonction d'attention.

