> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/fr/commencer/install/amd.md).

# Guide pour le fine-tuning de LLM sur GPU AMD avec Unsloth

Découvrez comment fine-tuner de grands modèles de langage (LLM) sur GPU AMD avec Unsloth.

Ajustez finement des LLM jusqu’à 2 fois plus vite, avec environ 70 % de mémoire en moins sur du matériel AMD, sans NVIDIA. Unsloth prend en charge les cartes AMD Radeon RDNA 3/3.5/4 (séries RX 6000 à 9000) sous Windows et Linux, ainsi que les GPU pour centres de données, notamment le MI300X (192 Go).

{% stepper %}
{% step %}

#### **Programme d’installation en une ligne**

Pour installer Unsloth sur AMD, le plus simple est de télécharger notre [application de bureau](https://unsloth.ai/docs/fr/desktop.md).

<a href="https://unsloth.ai/download/windows" class="button secondary" data-icon="windows">Télécharger pour Windows</a><a href="https://unsloth.ai/download/linux" class="button secondary" data-icon="linux">Télécharger pour Linux</a>\
\
Pour une installation manuelle :

**Linux :**

```bash
curl -fsSL https://unsloth.ai/install.sh | sh
```

**Windows (PowerShell) :**

```powershell
irm https://unsloth.ai/install.ps1 | iex
```

Les étapes manuelles ci-dessous s’adressent aux utilisateurs qui souhaitent installer la bibliothèque Python Unsloth sur AMD avec les dépendances requises.
{% endstep %}

{% step %}

#### **Créer un nouvel environnement isolé (facultatif)**

Les étapes ci-dessous concernent Linux. Sous Windows, utilisez l’application de bureau ou le programme d’installation PowerShell ci-dessus : ils installent pour vous la version de PyTorch d’AMD pour Windows.

Pour éviter d’endommager les paquets système, créez un environnement isolé. Pensez à vérifier la version de Python dont vous disposez ! Il peut s’agir de `python3`, `python3.12`, `python3.13` etc. Python 3.10 à 3.13 est pris en charge.

{% code overflow="wrap" %}

```bash
apt update && apt install python3.13-venv -y
python3.13 -m venv unsloth_env
source unsloth_env/bin/activate
pip install uv
```

{% endcode %}
{% endstep %}

{% step %}

#### **Installer PyTorch**

PyPI ne propose que la version NVIDIA (CUDA) de PyTorch ; installez donc d’abord la version ROCm depuis l’index PyTorch correspondant à votre version de ROCm. Vérifiez-la avec `amd-smi version` (la ligne `ROCm version:` ), puis :

{% code overflow="wrap" %}

```bash
uv pip install "torch<2.15" torchvision torchaudio \
    --index-url https://download.pytorch.org/whl/rocm7.2 --upgrade --force-reinstall
```

{% endcode %}

Remplacez `rocm7.2` par votre version de ROCm. Les balises d’index disponibles vont de `rocm6.0` à `rocm6.4` et `rocm7.0` à `rocm7.2`. ROCm 6.5 à 6.9 utilise `rocm6.4`, et ROCm 7.3 ou version ultérieure utilise `rocm7.2`. ROCm 6.0 ou version ultérieure est requis.

Vous pouvez aussi laisser cette commande choisir la balise :

{% code overflow="wrap" %}

```bash
ROCM_VER="$(amd-smi version 2>/dev/null | sed -n 's/.*ROCm version: \([0-9]*\.[0-9]*\).*/\1/p' | head -n 1)"
[ -n "$ROCM_VER" ] || ROCM_VER="$(cut -d. -f1,2 /opt/rocm/.info/version 2>/dev/null)"
case "$ROCM_VER" in
    6.[0-4]|7.[0-2]) ROCM_TAG="rocm$ROCM_VER" ;;
    6.*) ROCM_TAG="rocm6.4" ;;
    *) ROCM_TAG="rocm7.2" ;;
esac
echo "ROCm ${ROCM_VER:-unknown}: using $ROCM_TAG"
uv pip install "torch<2.15" torchvision torchaudio \
    --index-url "https://download.pytorch.org/whl/$ROCM_TAG" --upgrade --force-reinstall
```

{% endcode %}

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FTVWdHJi4m8thLmCwOocd%2Fimage.png?alt=media&amp;token=c3c2dc1d-a405-4998-96ec-8dc320e3e4ce" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}

#### **Installer Unsloth**

La version d’Unsloth sur PyPI dépend de `torch`, si bien qu’une installation standard peut remplacer la version de PyTorch pour ROCm que vous venez d’installer par celle pour CUDA disponible sur PyPI. Pour éviter cela, épinglez la version de PyTorch installée et installez avec `uv pip` (et non avec `pip`):

{% code overflow="wrap" %}

```bash
uv pip freeze | grep -E '^(torch|torchvision|torchaudio)==' > torch-pins.txt
echo "triton ; sys_platform == 'never'" >> torch-pins.txt
echo "xformers ; sys_platform == 'never'" >> torch-pins.txt
uv pip install "unsloth[amd]" --overrides torch-pins.txt
```

{% endcode %}

`torch-pins.txt` doit contenir une ligne `torch==...+rocm...` . Les deux dernières lignes empêchent le `triton` de PyPI de remplacer la version de Triton fournie avec votre PyTorch, et évitent d’installer le `xformers`de PyPI, qui est conçu uniquement pour les GPU NVIDIA.

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fe0HmhIq3WvgX4hMh5B8N%2Fimage.png?alt=media&amp;token=8376914f-e8b8-4a84-bee9-83c80ed5ad92" alt="" width="547"><figcaption></figcaption></figure></div>

**Mettre Unsloth à jour**

Mettez à niveau Unsloth uniquement, en conservant les mêmes épinglages :

{% code overflow="wrap" %}

```bash
uv pip install --upgrade-package unsloth --upgrade-package unsloth-zoo "unsloth[amd]" --overrides torch-pins.txt
```

{% endcode %}

N’exécutez pas `uv pip install -U unsloth` ni `--force-reinstall` sans les épinglages : ces deux commandes résolvent à nouveau PyTorch depuis PyPI et remplacent votre version pour ROCm par celle pour CUDA. Si cela s’est déjà produit, `import unsloth` indique la présence d’un GPU AMD, mais aucun accélérateur HIP utilisable : relancez l’étape PyTorch ci-dessus, puis celle-ci.
{% endstep %}

{% step %}

#### **Commencez le réglage fin avec Unsloth !**

Et voilà. Essayez quelques exemples sur notre page [**Notebooks Unsloth**](https://unsloth.ai/docs/fr/commencer/unsloth-notebooks.md) !

Consultez nos guides dédiés au [réglage fin](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide.md) et à l’ [apprentissage par renforcement](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide.md) . Voici également un bref exemple :

**1. Définir les variables d’environnement**

{% code overflow="wrap" %}

```bash
export HF_HUB_DISABLE_XET=1            # Fixes HuggingFace download issues on AMD
```

{% endcode %}

**2. Charger et configurer le modèle**

{% code overflow="wrap" %}

```python
from unsloth import FastModel

model, tokenizer = FastModel.from_pretrained(
    model_name = "unsloth/gemma-4-26b-a4b-it",
    max_seq_length = 2048,
    load_in_4bit = True,
)

model = FastModel.get_peft_model(
    model,
    r = 16,
    lora_alpha = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj"],
)
```

{% endcode %}

**3. Entraîner**

{% code overflow="wrap" %}

```python
from trl import SFTTrainer, SFTConfig

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    formatting_func = formatting_func,
    args = SFTConfig(
        per_device_train_batch_size = 1,
        gradient_accumulation_steps = 4,
        max_steps = 60,
        output_dir = "outputs",
        report_to = "none",
    ),
)

trainer_stats = trainer.train()
```

{% endcode %}

<div data-with-frame="true"><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FwIcg0yj5i1hSyHDLyMYG%2Fimage.png?alt=media&amp;token=a6cbe0c7-fdbf-4feb-ad7b-7ac55ba91872" alt="" width="375"><figcaption></figcaption></figure></div>

***Remarque :** Flash Attention 2 n’est pas installé par défaut sur les GPU AMD ; Unsloth utilise donc à la place le mécanisme d’attention SDPA intégré à PyTorch. Vous pouvez ignorer cet avertissement sans risque.*
{% endstep %}
{% endstepper %}

### :1234: Apprentissage par renforcement sur les GPU AMD

Vous pouvez utiliser notre :ledger:[exemple d’apprentissage par renforcement automatique de gpt-oss pour gagner à 2048](https://github.com/unslothai/notebooks/blob/main/nb/AMD-gpt_oss_\(20B\)_Reinforcement_Learning_2048_Game_BF16.ipynb) sur un GPU MI300X (192 Go). L’objectif est de jouer automatiquement au jeu 2048 et de le gagner grâce à l’apprentissage par renforcement. Le LLM (gpt-oss 20b) élabore automatiquement une stratégie pour gagner au jeu 2048 ; nous attribuons une récompense élevée aux stratégies gagnantes et une faible récompense à celles qui échouent.

{% columns %}
{% column %}

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-2bc5a2e25a51781fd945ab9e87e73821ed4eb6c9%2Fimage.png?alt=media" alt=""><figcaption></figcaption></figure>
{% endcolumn %}

{% column %}
La récompense augmente au fil du temps après environ 300 étapes !

L’objectif de l’apprentissage par renforcement est de maximiser la récompense moyenne afin de gagner au jeu 2048.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-8d7ea897fd57156a796e4f74aa2e3b60afe9d405%2F2048%20Auto%20Win%20Game%20Reward.png?alt=media" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

Nous avons utilisé une machine AMD MI300X (192 Go) pour exécuter l’exemple d’apprentissage par renforcement avec Unsloth sur le jeu 2048, et cela a bien fonctionné !

<div><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-174890aa5f63632ebe6f3f212f1ced0d0e8dc381%2FScreenshot%202025-10-17%20052504.png?alt=media" alt=""><figcaption></figcaption></figure> <figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-f907ba596705496515fdfb39b49d649697317ca7%2FScreenshot%202025-10-17%20052641.png?alt=media" alt=""><figcaption></figcaption></figure></div>

Vous pouvez également utiliser notre :ledger:[notebook d’apprentissage par renforcement pour la génération automatique de noyaux](https://github.com/unslothai/notebooks/blob/main/nb/AMD-gpt_oss_\(20B\)_GRPO_BF16.ipynb) également avec gpt-oss, afin de créer automatiquement des noyaux de multiplication matricielle en Python. Le notebook teste également plusieurs méthodes pour contrer le piratage des récompenses.

{% columns %}
{% column width="50%" %}
Voici le prompt que nous avons utilisé pour générer automatiquement ces noyaux :

{% code overflow="wrap" %}

````
Crée une nouvelle fonction rapide de multiplication matricielle en utilisant uniquement du code Python natif.
On te donne une liste de listes de nombres.
Affiche ta nouvelle fonction entre accents graves en utilisant le format ci-dessous :
```
python
def matmul(A, B):
    return ...
```
````

{% endcode %}
{% endcolumn %}

{% column width="50%" %}
Par exemple, le processus d’apprentissage par renforcement apprend à appliquer l’algorithme de Strassen en Python pour accélérer la multiplication matricielle.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-ddb993e5d2c986794ede1f2b0d08897469b78506%2Fimage%20(1)%20(1)%20(1)%20(1)%20(1)%20(1).png?alt=media" alt="" width="375"><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

### :books:Notebooks AMD gratuits en un clic

AMD propose des notebooks en un clic équipés de **GPU MI300X avec 192 Go de VRAM gratuits** via son Dev Cloud. Entraînez gratuitement des modèles de grande taille (aucune inscription ni carte bancaire requise) :

* [Qwen3 (32B)](https://amd-ai-academy.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(32B\)_A100-Reasoning-Conversational.ipynb)
* [Llama 3.3 (70B)](https://amd-ai-academy.com/github/unslothai/notebooks/blob/main/nb/AMD-Llama3.3_\(70B\)_A100-Conversational.ipynb)
* [Qwen3 (14B)](https://amd-ai-academy.com/github/unslothai/notebooks/blob/main/nb/AMD-Qwen3_\(14B\)-Reasoning-Conversational.ipynb)
* [Mistral v0.3 (7B)](https://amd-ai-academy.com/github/unslothai/notebooks/blob/main/nb/AMD-Mistral_v0.3_\(7B\)-Alpaca.ipynb)
* [GPT OSS MXFP4 (20B)](https://amd-ai-academy.com/github/unslothai/notebooks/blob/main/nb/AMD-GPT_OSS_MXFP4_\(20B\)-Inference.ipynb) - Inférence
* [Gemma4 (E2B)](https://amd-ai-academy.com/github/unslothai/notebooks/blob/main/nb/Gemma4_\(E2B\)_Reinforcement_Learning_Sudoku_Game.ipynb) - Sudoku avec apprentissage par renforcement
* Unsloth Studio

{% embed url="<https://oneclickamd.ai/github/unslothai/notebooks/blob/main/nb/gpt_oss_(20B)_Reinforcement_Learning_2048_Game_BF16.ipynb>" %}

Pour ouvrir un notebook AMD depuis [les notebooks Unsloth](https://unsloth.ai/docs/get-started/unsloth-notebooks), remplacez `https://github.com/` dans son URL par `https://amd-ai-academy.com/github/`. Conservez le reste de l’URL à l’identique.

Essayez le notebook **d’apprentissage par renforcement de gpt-oss 20B pour 2048**. [Voir sur GitHub](https://github.com/unslothai/notebooks/blob/main/nb/AMD-gpt_oss_%2820B%29_Reinforcement_Learning_2048_Game_BF16.ipynb) ou [ouvrir dans AMD Developer Cloud](https://amd-ai-academy.com/github/unslothai/notebooks/blob/main/nb/AMD-gpt_oss_%2820B%29_Reinforcement_Learning_2048_Game_BF16.ipynb).

{% columns %}
{% column width="33.33333333333333%" %}

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2F7NNi4jLKvmZoRnLel9Kg%2Fimage.png?alt=media&amp;token=0379eda9-569c-4614-afb5-ffec463a7676" alt=""><figcaption></figcaption></figure>
{% endcolumn %}

{% column width="66.66666666666667%" %}

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FRfKS1GAW7BqL9lGNTcxh%2Fimage.png?alt=media&amp;token=3a8aeb01-62a7-4d55-89a9-98526052e305" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://unsloth.ai/docs/fr/commencer/install/amd.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
