Intel Gaudi

Les accélérateurs Intel Gaudi exécutent PyTorch sur la pile Intel Gaudi, 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 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, ainsi qu’Accelerate 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.

export PT_ENABLE_INT64_SUPPORT=1

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

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.

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 pour les combinaisons d'identifiants de modules prises en charge.

Exécuter l'inférence

Passez device_map="hpu" à from_pretrained(). pipeline() sélectionne Gaudi automatiquement lorsque vous ne passez pas device.

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

Entraîner avec Trainer

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.

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, ce qui définit torch_compile_backend sur "hpu_backend".

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. Transformers le sélectionne sur Gaudi, et vous pouvez également le définir explicitement avec ddp_backend="hccl".

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. accelerate launch définit le nombre de processus au nombre d’appareils Gaudi lorsque vous ne passez pas --num_processes.

accelerate launch train.py

Étapes suivantes

• Consultez la documentation Intel Gaudi pour les détails sur le matériel, la pile logicielle et l'architecture Gaudi.
• Essayez Optimum for Intel Gaudi pour des implémentations de modèles optimisées pour Gaudi, destinées à l’entraînement et à l’inférence.