# Intel Gaudi

Les accélérateurs Intel Gaudi exécutent PyTorch sur la pile [Intel Gaudi](https://docs.habana.ai/en/latest/index.html), avec la chaîne de périphérique `hpu`. Gaudi exécute PyTorch en mode eager par défaut. Le mode eager exécute chaque opération dès qu'elle est appelée, de la même manière que PyTorch s'exécute sur un CPU ou un GPU, de sorte que les modèles Transformers s'exécutent sur Gaudi sans modifications spécifiques à Gaudi. Pour capturer le modèle dans un graphe à la place, [compilez-le](#compile-the-model) avec `torch.compile`.

## Installation

Installez le logiciel Intel Gaudi et son package PyTorch (`habana-torch-plugin`, importé sous le nom `habana_frameworks`) à l’aide du [guide d’installation Intel Gaudi](https://docs.habana.ai/en/latest/Installation_Guide/index.html), ainsi qu’[Accelerate](https://huggingface.co/docs/accelerate/index) 1.5.0 ou une version ultérieure.

Transformers utilise des tenseurs int64 pour les identifiants de jetons, il est donc nécessaire d’activer la prise en charge de int64 sur Gaudi. La CI Gaudi de Transformers s’exécute avec le même paramétrage.

```bash
export PT_ENABLE_INT64_SUPPORT=1
```

Vérifiez que Transformers peut détecter l'appareil.

```py
from transformers import is_torch_hpu_available

print(is_torch_hpu_available())
```

Il affiche `True` lorsque Gaudi est prêt à l’emploi, et `False` avec Accelerate antérieur à la version 1.5.0, même si un périphérique Gaudi est présent.

## Sélectionner les appareils

Choisissez les périphériques Gaudi qu’un conteneur Docker peut utiliser lors de son démarrage. Définissez `HABANA_VISIBLE_MODULES` sur des identifiants de modules, qui restent identiques après un redémarrage ou une réinstallation du pilote, ou `HABANA_VISIBLE_DEVICES` sur des index de périphériques, qui peuvent changer. Si vous ne définissez ni l’un ni l’autre, PyTorch utilise tout périphérique Gaudi disponible sur le serveur.

```bash
docker run --runtime=habana -e HABANA_VISIBLE_MODULES=0,1,2,3 ...
```

Exécutez `hl-smi -Q index,module_id -f csv` pour associer les indices de périphériques aux identifiants de modules. Pour une charge de travail distribuée sur une partie d'un serveur, Intel ne prend en charge que les groupes de 2 et de 4 périphériques. Consultez [Plusieurs Docker, chacun avec une charge de travail unique](https://docs.habana.ai/en/latest/Orchestration/Multiple_Tenants_on_HPU/Multiple_Dockers_each_with_Single_Workload.html) pour les combinaisons d'identifiants de modules prises en charge.

## Exécuter l'inférence

Passez `device_map="hpu"` à [from_pretrained()](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained). [pipeline()](/docs/transformers/main/fr/main_classes/pipelines#transformers.pipeline) sélectionne Gaudi automatiquement lorsque vous ne passez pas `device`.

```py
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen3-0.6B", device_map="hpu")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-0.6B")

inputs = tokenizer("Intel Gaudi is", 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))
```

## Quantifier les modèles

[bitsandbytes](./quantization/bitsandbytes) quantifie les modèles en 4 ou 8 bits sur Gaudi 2 et Gaudi 3. Si vous ne transmettez pas `device_map`, il place le modèle sur le périphérique Gaudi actuel.

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

## Entraîner avec Trainer

[TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments) détecte Gaudi et définit le dispositif sur `hpu`, de sorte que `Trainer` entraîne dessus sans aucun paramètre de dispositif. Toutes les générations de Gaudi prennent en charge bf16.

```py
from transformers import TrainingArguments

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

Il affiche un appareil `hpu` lorsque `Trainer` entraîne sur Gaudi.

## Compiler le modèle

Transformers encapsule `torch.compile` sur Gaudi, de sorte que tout appel avec un backend autre que `hpu_backend` ou `eager`, y compris un décorateur `@torch.compile` dans le code de modélisation, bascule sur `hpu_backend` et journalise un avertissement. L’encapsulation s’applique à chaque appel de `torch.compile`, pour l’inférence ou l’entraînement.

Pour compiler un modèle pour l'entraînement, définissez `torch_compile=True` dans [TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments), ce qui définit `torch_compile_backend` sur `"hpu_backend"`.

```py
from transformers import TrainingArguments

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

### Entraînement distribué

L’entraînement distribué utilise le backend collectif [HCCL](https://docs.habana.ai/en/latest/API_Reference_Guides/HCCL_APIs/index.html). Transformers le sélectionne sur Gaudi, et vous pouvez également le définir explicitement avec `ddp_backend="hccl"`.

```py
training_args = TrainingArguments(
    output_dir="./outputs",
    bf16=True,
    ddp_backend="hccl",
)
```

Lancez un processus par appareil Gaudi avec `torchrun` ou `accelerate launch`, après avoir [sélectionné les appareils](#select-devices). `accelerate launch` définit le nombre de processus au nombre d'appareils Gaudi lorsque vous ne passez pas `--num_processes`.

```bash
accelerate launch train.py
```

## Étapes suivantes

- Consultez la [documentation Intel Gaudi](https://docs.habana.ai/en/latest/index.html) pour les détails sur le matériel, la pile logicielle et l'[architecture Gaudi](https://docs.habana.ai/en/latest/Gaudi_Overview/Gaudi_Architecture.html).
- Essayez [Optimum for Intel Gaudi](https://huggingface.co/docs/optimum-habana/index) pour des implémentations de modèles optimisées pour Gaudi, destinées à l’entraînement et à l’inférence.