GPU AMD

Les GPU AMD Instinct (séries MI200, MI300, MI350) et Radeon exécutent PyTorch via ROCm, la pile logicielle GPU d’AMD. La version ROCm de PyTorch utilise HIP, l’interface de programmation d’AMD similaire à CUDA, pour exposer les GPU AMD à travers l’API torch.cuda. La chaîne de caractères du périphérique est cuda, de sorte que le code écrit pour les GPU NVIDIA s’exécute sans modification. Transformers vérifie torch.version.hip à l’exécution pour les distinguer et oriente les noyaux d’attention et de Hub vers les compilations spécifiques à AMD.

Installation

Installez ROCm à partir de l’image Docker huggingface/transformers-pytorch-amd-gpu. Elle inclut la version ROCm de PyTorch, une compilation de flash-attn pour les GPU MI300 et MI350 (gfx942 et gfx950), ainsi que Transformers installé depuis le code source.

docker run -it --device=/dev/kfd --device=/dev/dri --group-add video \
    --ipc=host --shm-size 16G \
    huggingface/transformers-pytorch-amd-gpu

--device=/dev/kfd et --device=/dev/dri exposent les GPU AMD au conteneur. Installez les kernels dans le conteneur pour utiliser les kernels du Hub.

pip install "transformers[kernels]"

Pour l’installer sur votre propre système, sélectionnez ROCm dans le sélecteur d’installation de PyTorch et assurez-vous que la version ROCm de la roue est prise en charge par votre pilote.

Vérifiez que PyTorch détecte les GPU AMD.

import torch

print(torch.version.hip, torch.cuda.is_available(), torch.cuda.device_count())
print(torch.cuda.get_device_properties(0).gcnArchName)

7.2.53211 True 2
gfx942:sramecc+:xnack-

torch.version.hip est None sur une version de PyTorch compilée pour CUDA. gcnArchName indique l’architecture du GPU, par exemple gfx942 pour MI300, gfx950 pour MI350 et gfx1151 pour Ryzen AI Max (Strix Halo).

Sélectionner et ordonner les GPU

Utilisez HIP_VISIBLE_DEVICES pour sélectionner les GPU et définir leur ordre. Définissez-le sur la même ligne de commande que l’exécution.

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

PyTorch ne voit que les GPU 0 et 2, qui sont mappés sur cuda:0 et cuda:1. ROCR_VISIBLE_DEVICES filtre les GPU à un niveau inférieur de la pile et est généralement défini par les planificateurs de cluster. Si les deux sont définis, HIP_VISIBLE_DEVICES indexe les GPU restés visibles après le filtrage par ROCR_VISIBLE_DEVICES.

Utilisez rocm-smi ou amd-smi pour lister les GPU et leurs indices.

Exécuter l'inférence

Pipeline et device_map="auto" détectent les GPU AMD et placent le modèle sur cuda automatiquement. Vous pouvez également passer explicitement device_map="cuda" ou device_map="cuda:1".

from transformers import AutoModelForCausalLM, AutoTokenizer

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

inputs = tokenizer("The French Bread Law states", return_tensors="pt").to(model.device)
output = model.generate(**inputs, do_sample=False, max_new_tokens=50)
print(tokenizer.decode(output[0], skip_special_tokens=True))

The French Bread Law states that the French government must provide a certain amount of bread for the citizens of the country. The law is passed by the French parliament. The French parliament is a body of the French government. The French government is a body of the French state. The

Choisir un backend d'attention

Définissez le backend d’attention avec attn_implementation lors du chargement d’un modèle ; il s’applique à la fois à l’inférence et à l’entraînement. SDPA est le backend par défaut et fonctionne sur tous les GPU AMD pris en charge par PyTorch. Deux options FlashAttention sont également disponibles.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-0.6B",
    dtype="bfloat16",
    device_map="auto",
    attn_implementation="flash_attention_3",
)

Sur ROCm, flash_attention_3 résout vers le noyau AITER et journalise ce qui suit. Transformers utilise actuellement l'alias kernels-community/aiter-flash-attn, qui redirige vers amd/aiter-flash-attn. Le message fait référence au package FlashAttention-3, il apparaît donc même lorsque flash_attention_2 est installé.

You do not have `flash_attn` installed, using `kernels-community/aiter-flash-attn` from the `kernels` library instead!

Vous pouvez également passer directement le dépôt du noyau avec attn_implementation="kernels-community/aiter-flash-attn". Consultez Backends d'attention pour savoir comment les backends sont sélectionnés.

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. Transformers détecte ROCm et sélectionne la build AMD pour chaque couche, par exemple amd/aiter-rope pour les embeddings rotationnels et kernels-community/liger-kernels pour RMSNorm. Lorsque vous écrivez une KernelConfig personnalisée, utilisez "rocm" comme clé d’appareil pour les mappages spécifiques à AMD.

from transformers import AutoModelForCausalLM

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

Les noyaux du Hub accélèrent principalement le préremplissage et les lots volumineux. Effectuez des benchmarks sur votre propre charge de travail avant de les activer pour le décodage en petits lots. Consultez Chargement des noyaux pour la correspondance complète.

Quantifier les modèles

Les méthodes prises en charge sur ROCm incluent AWQ, GPT-QModel, compressed-tensors et Quark d’AMD. bitsandbytes est partiellement pris en charge. Les GPU MI300 et plus récents prennent en charge nativement le FP8. Consultez le tableau de compatibilité pour la liste complète.

Entraîner avec Trainer

TrainingArguments détecte les GPU AMD et définit automatiquement l’appareil sur cuda.

from transformers import TrainingArguments

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

Entraînement distribué

La version ROCm de PyTorch inclut RCCL, l’implémentation de l’API NCCL par AMD, de sorte que l’arrière-plan nccl, torchrun, FSDP, DeepSpeed et l’API distribuée de Transformers fonctionnent sans modification.

import torch
from transformers import AutoModelForCausalLM, DistributedConfig

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3-1.7B",
    dtype=torch.bfloat16,
    distributed_config=DistributedConfig(tp_size=2, fsdp_size=4),
)

torchrun --nproc_per_node=8 train.py

Voir Tensor parallelism, Expert parallelism et FSDP pour les options disponibles.

Limites

• CodeCarbonCallback n’est pas compatible avec ROCm. Définissez report_to dans TrainingArguments pour exclure codecarbon.
• Les méthodes de quantification marquées 🔴 pour ROCm dans le tableau de compatibilité reposent sur des noyaux exclusifs à CUDA et échouent au chargement sur les GPU AMD.

Étapes suivantes

• Consultez la documentation ROCm pour la configuration du pilote et de PyTorch.
• Parcourez les builds ROCm dans les organisations AMD et kernels-community.
• Consultez Chargement des noyaux pour personnaliser les noyaux qui remplacent les couches.