# gpt-oss : guide d'exécution

OpenAI lance « **gpt-oss-120b'** et « **gpt-oss-20b'** », deux modèles de langage ouverts SOTA sous licence Apache 2.0. Les deux modèles de contexte 128k surpassent les modèles ouverts de taille similaire en raisonnement, utilisation d’outils et tâches agentiques. Vous pouvez désormais les exécuter et les affiner localement avec Unsloth !

<a href="#run-gpt-oss-20b" class="button secondary">Exécuter gpt-oss-20b</a><a href="#run-gpt-oss-120b" class="button secondary">Exécuter gpt-oss-120b</a><a href="#fine-tuning-gpt-oss-with-unsloth" class="button primary">Affiner gpt-oss</a>

> [**Affiner**](#fine-tuning-gpt-oss-with-unsloth) **gpt-oss-20b gratuitement avec notre** [**notebook Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-Fine-tuning.ipynb)

Entraîné avec [RL](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide), **gpt-oss-120b** rivalise avec o4-mini et **gpt-oss-20b** rivalise avec o3-mini. Les deux excellent dans l’appel de fonctions et le raisonnement CoT, surpassant o1 et GPT-4o.

Pour de meilleures performances, assurez-vous que votre mémoire totale disponible (mémoire unifiée + VRAM + RAM système) dépasse la taille du fichier de modèle quantifié que vous téléchargez. Si ce n’est pas le cas, llama.cpp peut quand même fonctionner via le déchargement SSD/HDD, mais l’inférence sera plus lente.

#### **gpt-oss - Unsloth GGUFs :**

{% hint style="success" %}
**Inclut les** [**correctifs du modèle de chat d’Unsloth**](#unsloth-fixes-for-gpt-oss)**. Pour de meilleurs résultats, utilisez nos uploads et entraînez avec Unsloth !**
{% endhint %}

* 20B : [gpt-oss-**20B**](https://huggingface.co/unsloth/gpt-oss-20b-GGUF)
* 120B : [gpt-oss-**120B**](https://huggingface.co/unsloth/gpt-oss-120b-GGUF)

## :scroll:Correctifs Unsloth pour gpt-oss

{% hint style="info" %}
Certains de nos correctifs ont été remontés en amont vers le modèle officiel d’OpenAI sur Hugging Face. [Voir](https://huggingface.co/openai/gpt-oss-20b/discussions/94/files)
{% endhint %}

OpenAI a publié une bibliothèque autonome d’analyse et de tokenisation appelée [Harmony](https://github.com/openai/harmony) qui permet de tokeniser les conversations au format préféré d’OpenAI pour gpt-oss.

Les moteurs d’inférence utilisent généralement à la place le modèle de chat jinja et non le package Harmony, et nous avons constaté quelques problèmes en les comparant directement à Harmony. Si vous voyez ci-dessous, le haut est la forme rendue correcte, comme avec Harmony. Le dessous est celui rendu par le modèle de chat jinja actuel. Il y a pas mal de différences !

<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%2Fgit-blob-9b377044965ac55a125d6c703ec1c50555157266%2FScreenshot%202025-08-08%20at%2008-19-49%20Untitled151.ipynb%20-%20Colab.png?alt=media" alt="" width="563"><figcaption></figcaption></figure></div>

Nous avons également créé quelques fonctions qui vous permettent d’utiliser directement la bibliothèque Harmony d’OpenAI sans modèle de chat jinja si vous le souhaitez - vous pouvez simplement analyser des conversations normales comme ci-dessous :

```python
messages = [
    {"role" : "user", "content" : "Combien font 1+1 ?"},
    {"role" : "assistant", "content" : "2"},
    {"role": "user",  "content": "Quelle est la température à San Francisco maintenant ? Et demain ? La date d’aujourd’hui est le 2024-09-30."},
    {"role": "assistant",  "content": "L’utilisateur demande : 'Quelle est la météo à San Francisco ?' Nous devons utiliser l’outil get_current_temperature.", "thinking" : ""},
    {"role": "assistant", "content": "", "tool_calls": [{"name": "get_current_temperature", "arguments": '{"location": "San Francisco, California, United States", "unit": "celsius"}'}]},
    {"role": "tool", "name": "get_current_temperature", "content": '{"temperature": 19.9, "location": "San Francisco, California, United States", "unit": "celsius"}'},
]
```

Ensuite, utilisez la `encode_conversations_with_harmony` fonction d’Unsloth :

```python
from unsloth_zoo import encode_conversations_with_harmony

def encode_conversations_with_harmony(
    messages,
    reasoning_effort = "medium",
    add_generation_prompt = True,
    tool_calls = None,
    developer_instructions = None,
    model_identity = "You are ChatGPT, a large language model trained by OpenAI.",
)
```

Le format Harmony comprend plusieurs éléments intéressants :

1. `reasoning_effort = "medium"` Vous pouvez choisir low, medium ou high, et cela modifie le budget de raisonnement de gpt-oss - en général, plus c’est élevé, meilleure est la précision du modèle.
2. `developer_instructions` est comme une instruction système que vous pouvez ajouter.
3. `model_identity` est mieux laissé tel quel - vous pouvez le modifier, mais nous ne savons pas si les valeurs personnalisées fonctionneront.

Nous constatons plusieurs problèmes avec les modèles de chat jinja actuels (il en existe plusieurs implémentations dans l’écosystème) :

1. Les appels de fonctions et d’outils sont rendus avec `tojson`, ce qui est correct s’il s’agit d’un dictionnaire, mais si c’est une chaîne, les guillemets et autres **symboles deviennent échappés par des antislashs**.
2. Il y a quelques **retours à la ligne supplémentaires** dans le modèle jinja à certaines limites.
3. Les pensées liées à l’appel d’outils du modèle devraient avoir la balise **`analysis` et non la balise `final` balise**.
4. D’autres modèles de chat semblent ne pas utiliser `<|channel|>final` du tout - il faut utiliser cela pour le message final de l’assistant. Vous ne devez pas l’utiliser pour les traces de réflexion ni pour les appels d’outils.

Nos modèles de chat pour le GGUF, nos uploads BnB et BF16, ainsi que toutes les versions, sont corrigés ! Par exemple, en comparant notre format et celui de Harmony, nous n’obtenons aucun caractère différent :

<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%2Fgit-blob-4c42f3d83194ea2fbe436670a550e1b6f148f4cd%2FScreenshot%202025-08-08%20at%2008-20-00%20Untitled151.ipynb%20-%20Colab.png?alt=media" alt="" width="563"><figcaption></figcaption></figure></div>

### :1234: Problèmes de précision

Nous avons constaté plusieurs problèmes de précision sur les machines Tesla T4 et float16, principalement parce que le modèle a été entraîné en BF16, et donc des valeurs aberrantes et des dépassements existaient. MXFP4 n’est en réalité pas pris en charge sur Ampere et les GPU plus anciens, donc Triton fournit `tl.dot_scaled` pour la multiplication matricielle MXFP4. Il convertit les matrices en BF16 en interne à la volée.

Nous avons créé un [notebook d’inférence MXFP4](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/GPT_OSS_MXFP4_\(20B\)-Inference.ipynb) également sur Colab Tesla T4 !

{% hint style="info" %}
[L’émulation logicielle](https://triton-lang.org/main/python-api/generated/triton.language.dot_scaled.html) permet de cibler des architectures matérielles sans prise en charge native des opérations de microscaling. À l’heure actuelle, dans un tel cas, les lhs/rhs microscalés sont convertis en amont vers le type d’élément `bf16` avant le calcul du produit scalaire,
{% endhint %}

Nous avons constaté que si vous utilisez float16 comme type de données d’autocast en précision mixte, vous obtiendrez des infinis après un certain temps. Pour contrer cela, nous avons constaté qu’il fallait faire le MoE en bfloat16, puis le laisser soit en bfloat16 soit en précision float32. Si les anciens GPU ne prennent même pas en charge bfloat16 (comme le T4), alors float32 est utilisé.

Nous modifions également toutes les précisions des opérations (comme le routeur) en float32 pour les machines float16.

## 🖥️ **Exécution de gpt-oss**

Ci-dessous se trouvent des guides pour les [20B](#run-gpt-oss-20b) et [120B](#run-gpt-oss-120b) variantes du modèle.

{% hint style="info" %}
Toute quantification inférieure à F16, y compris 2 bits, entraîne une perte de précision minimale, car seules certaines parties (par exemple, les couches d’attention) sont en faible précision tandis que la plupart restent en pleine précision. C’est pourquoi les tailles sont proches du modèle F16 ; par exemple, la version 2 bits (11,5 Go) donne presque les mêmes performances que la version complète 16 bits (14 Go). Dès que llama.cpp prendra en charge une meilleure quantification pour ces modèles, nous les publierons au plus vite.
{% endhint %}

Les `gpt-oss` modèles d’OpenAI incluent une fonctionnalité qui permet aux utilisateurs d’ajuster le « niveau d’effort de raisonnement » du modèle. Cela vous donne le contrôle sur le compromis entre les performances du modèle et sa vitesse de réponse (latence), qui dépend du nombre de jetons que le modèle utilisera pour réfléchir.

Les `gpt-oss` modèles offrent trois niveaux distincts d’effort de raisonnement parmi lesquels vous pouvez choisir :

* **Faible**: Optimisé pour les tâches nécessitant des réponses très rapides et ne demandant pas de raisonnement complexe en plusieurs étapes.
* **Moyen**: Un équilibre entre performance et vitesse.
* **Élevé**: Offre les meilleures performances de raisonnement pour les tâches qui l’exigent, mais cela se traduit par une latence plus élevée.

### :gear: Paramètres recommandés

OpenAI recommande ces paramètres d’inférence pour les deux modèles :

`temperature=1.0`, `top_p=1.0`, `top_k=0`

* <mark style="background-color:green;">**Température de 1.0**</mark>
* Top\_K = 0 (ou expérimentez avec 100 pour de possibles meilleurs résultats)
* Top\_P = 1.0
* Contexte minimum recommandé : 16 384
* Longueur maximale de fenêtre de contexte : 131 072

**Modèle de chat :**

```
<|start|>system<|message|>Vous êtes ChatGPT, un grand modèle de langage entraîné par OpenAI.\nDate limite de connaissances : 2024-06\nDate actuelle : 2025-08-05\n\nRaisonnement : moyen\n\n# Canaux valides : analysis, commentary, final. Un canal doit être inclus pour chaque message.<|end|><|start|>user<|message|>Bonjour<|end|><|start|>assistant<|channel|>final<|message|>Salut !<|end|><|start|>user<|message|>Combien font 1+1 ?<|end|><|start|>assistant
```

Le jeton de fin de phrase/génération : EOS est `<|return|>`

### Exécuter gpt-oss-20B

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-920b641670a166258845bbe8152999983b1e68af%2Fgpt-oss-20b.svg?alt=media" alt=""><figcaption></figcaption></figure>

Pour atteindre des vitesses d’inférence de 6 jetons par seconde ou plus avec notre quantification dynamique 4 bits, ayez au moins **14 Go de mémoire unifiée** (VRAM et RAM combinées) ou **14 Go de RAM système** seuls. En règle générale, votre mémoire disponible doit être égale ou supérieure à la taille du modèle que vous utilisez. Lien GGUF : [unsloth/gpt-oss-20b-GGUF](https://huggingface.co/unsloth/gpt-oss-20b-GGUF)

**REMARQUE :** Le modèle peut fonctionner avec moins de mémoire que sa taille totale, mais cela ralentira l’inférence. La mémoire maximale n’est nécessaire que pour les vitesses les plus rapides.

{% hint style="info" %}
Suivez les [**meilleures pratiques ci-dessus**](#recommended-settings). Elles sont les mêmes que pour le modèle 120B.
{% endhint %}

Vous pouvez exécuter le modèle sur Google Colab, Docker, LM Studio ou llama.cpp pour le moment. Voir ci-dessous :

> **Vous pouvez exécuter gpt-oss-20b gratuitement avec notre** [**notebook Google Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/GPT_OSS_MXFP4_\(20B\)-Inference.ipynb)

#### 🦥 Guide Unsloth Studio

Pour ce tutoriel, nous allons utiliser [Unsloth Studio](https://unsloth.ai/docs/fr/nouveau/studio), notre nouvelle interface web pour exécuter et entraîner des LLM. Avec Unsloth Studio, vous pouvez exécuter des modèles localement sur **Mac, Windows**, et Linux et :

{% columns %}
{% column %}

* Rechercher, télécharger, [exécuter des GGUF](https://unsloth.ai/docs/fr/nouveau/studio#run-models-locally) et des modèles safetensor
* **Comparer** des modèles **côte à côte**
* [**Auto-réparation** appel d’outils](https://unsloth.ai/docs/fr/nouveau/studio#execute-code--heal-tool-calling) + **recherche web**
* [**Exécution de code**](https://unsloth.ai/docs/fr/nouveau/studio#run-models-locally) (Python, Bash)
* [Inférence automatique](https://unsloth.ai/docs/fr/nouveau/studio#model-arena) ajustement des paramètres (temp, top-p, etc.)
* [Entraîner des LLM](https://unsloth.ai/docs/fr/nouveau/studio#no-code-training) 2x plus rapide avec 70 % de VRAM en moins
  {% endcolumn %}

{% column %}

<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%2FFeQ0UUlnjXkDdqhcWglh%2Fskinny%20studio%20chat.png?alt=media&#x26;token=c2ee045f-c243-4024-a8e4-bb4dbe7bae79" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}

#### Installer Unsloth

Exécutez dans votre terminal :

**MacOS, Linux, WSL :**

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

**Windows PowerShell :**

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

{% endstep %}

{% step %}

#### Lancer Unsloth

**MacOS, Linux, WSL, Windows :**

```bash
unsloth studio -H 0.0.0.0 -p 8888
```

<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%2Fd1yMMNa65Ccz50Ke0E7r%2FScreenshot%202026-03-17%20at%2012.32.38%E2%80%AFAM.png?alt=media&#x26;token=9369cfe7-35b1-4955-b8cb-42f7ecb43780" alt="" width="375"><figcaption></figcaption></figure></div>

**Puis ouvrez `http://localhost:8888` dans votre navigateur.**
{% endstep %}

{% step %}

#### Rechercher et télécharger gpt-oss-20b

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d’accueil pour choisir un modèle, un jeu de données et les paramètres de base. Vous pouvez le passer à tout moment.

Ensuite, allez à l’onglet [Studio Chat](https://unsloth.ai/docs/fr/nouveau/studio/chat) et recherchez gpt-oss dans la barre de recherche, puis téléchargez le modèle et la quantification souhaités.

<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%2F24OqTOq1fYvW3oZ5WlNG%2FScreenshot%202026-03-20%20at%201.35.19%E2%80%AFAM.png?alt=media&#x26;token=b1e463ee-33a2-4e77-b725-d715b03f5d28" alt="" width="375"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}

#### Exécuter gpt-oss-20b

Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio, mais vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur du contexte, le modèle de chat et d’autres paramètres.

Pour plus d’informations, vous pouvez consulter notre [guide d’inférence d’Unsloth Studio](https://unsloth.ai/docs/fr/nouveau/studio/chat).

<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%2FXPQGEEr1YoKofrTatAKK%2Ftoolcallingif.gif?alt=media&#x26;token=25d68698-fb13-4c46-99b2-d39fb025df08" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

#### 🐋 Docker : tutoriel pour exécuter gpt-oss-20b

Si vous avez déjà Docker Desktop, il vous suffit d’exécuter la commande ci-dessous et c’est terminé :

```bash
docker model run hf.co/unsloth/gpt-oss-20b-GGUF:F16
```

#### :sparkles: Llama.cpp : tutoriel pour exécuter gpt-oss-20b

1. Obtenez la dernière version de `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez suivre également les instructions de compilation ci-dessous. Remplacez `-DGGML_CUDA=ON` par `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou si vous souhaitez simplement une inférence CPU. **Pour les appareils Apple Mac / Metal**, définissez `-DGGML_CUDA=OFF` puis continuez normalement - la prise en charge de Metal est activée par défaut.

```bash
apt-get update
apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
git clone https://github.com/ggml-org/llama.cpp
cmake llama.cpp -B llama.cpp/build \
    -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split
cp llama.cpp/build/bin/llama-* llama.cpp
```

2. Vous pouvez télécharger directement depuis Hugging Face via :

   ```bash
   ./llama.cpp/llama-cli \
       -hf unsloth/gpt-oss-20b-GGUF:F16 \
       --jinja -ngl 99 --ctx-size 16384 \
       --temp 1.0 --top-p 1.0 --top-k 0
   ```
3. Téléchargez le modèle via (après installation de `pip install huggingface_hub hf_transfer` ). Si les téléchargements se bloquent, voir [hugging-face-hub-xet-debugging](https://unsloth.ai/docs/fr/bases/troubleshooting-and-faqs/hugging-face-hub-xet-debugging "mention")

```python
# !pip install huggingface_hub hf_transfer
import os
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"
from huggingface_hub import snapshot_download
snapshot_download(
    repo_id = "unsloth/gpt-oss-20b-GGUF",
    local_dir = "unsloth/gpt-oss-20b-GGUF",
    allow_patterns = ["*F16*"],
)
```

### Exécuter gpt-oss-120b :

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-4f6fc3b98363be32b7c7cf07c713947cb1bd9444%2Fgpt-oss-120b.svg?alt=media" alt=""><figcaption></figcaption></figure>

Pour atteindre des vitesses d’inférence de 6 jetons par seconde ou plus avec notre quantification 1 bit, nous recommandons au moins **66 Go de mémoire unifiée** (VRAM et RAM combinées) ou **66 Go de RAM système** seuls. En règle générale, votre mémoire disponible doit être égale ou supérieure à la taille du modèle que vous utilisez. Lien GGUF : [unsloth/gpt-oss-120b-GGUF](https://huggingface.co/unsloth/gpt-oss-120b-GGUF)

**REMARQUE :** Le modèle peut fonctionner avec moins de mémoire que sa taille totale, mais cela ralentira l’inférence. La mémoire maximale n’est nécessaire que pour les vitesses les plus rapides.

{% hint style="info" %}
Suivez les [**meilleures pratiques ci-dessus**](#recommended-settings). Elles sont les mêmes que pour le modèle 20B.
{% endhint %}

#### 🦥 Guide Unsloth Studio

Pour ce tutoriel, nous allons utiliser [Unsloth Studio](https://unsloth.ai/docs/fr/nouveau/studio), notre nouvelle interface web pour exécuter et entraîner des LLM. Avec Unsloth Studio, vous pouvez exécuter des modèles localement sur **Mac, Windows**, et Linux et :

{% columns %}
{% column %}

* Rechercher, télécharger, [exécuter des GGUF](https://unsloth.ai/docs/fr/nouveau/studio#run-models-locally) et des modèles safetensor
* **Comparer** des modèles **côte à côte**
* [**Auto-réparation** appel d’outils](https://unsloth.ai/docs/fr/nouveau/studio#execute-code--heal-tool-calling) + **recherche web**
* [**Exécution de code**](https://unsloth.ai/docs/fr/nouveau/studio#run-models-locally) (Python, Bash)
* [Inférence automatique](https://unsloth.ai/docs/fr/nouveau/studio#model-arena) ajustement des paramètres (temp, top-p, etc.)
* [Entraîner des LLM](https://unsloth.ai/docs/fr/nouveau/studio#no-code-training) 2x plus rapide avec 70 % de VRAM en moins
  {% endcolumn %}

{% column %}

<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%2FFeQ0UUlnjXkDdqhcWglh%2Fskinny%20studio%20chat.png?alt=media&#x26;token=c2ee045f-c243-4024-a8e4-bb4dbe7bae79" alt=""><figcaption></figcaption></figure></div>
{% endcolumn %}
{% endcolumns %}

{% stepper %}
{% step %}

#### Installer Unsloth

**MacOS, Linux, WSL :**

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

**Windows PowerShell :**

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

{% endstep %}

{% step %}

#### Configurer Unsloth Studio (une seule fois)

La configuration installe automatiquement Node.js (via nvm), compile le frontend, installe toutes les dépendances Python et compile llama.cpp avec prise en charge CUDA.

{% hint style="warning" %}
**La première installation peut prendre 5 à 10 minutes. C’est normal car `llama.cpp` doit compiler les binaires. N**e l’annulez pas.
{% endhint %}

{% hint style="info" %}
**Utilisateurs de WSL :** on vous demandera votre `sudo` mot de passe pour installer les dépendances de compilation (`cmake`, `git`, `libcurl4-openssl-dev`).
{% endhint %}
{% endstep %}

{% step %}

#### Lancer Unsloth

**MacOS, Linux, WSL :**

```bash
source unsloth_studio/bin/activate
unsloth studio -H 0.0.0.0 -p 8888
```

**Windows Powershell :**

```bash
& .\unsloth_studio\Scripts\unsloth.exe studio -H 0.0.0.0 -p 8888
```

<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%2Fd1yMMNa65Ccz50Ke0E7r%2FScreenshot%202026-03-17%20at%2012.32.38%E2%80%AFAM.png?alt=media&#x26;token=9369cfe7-35b1-4955-b8cb-42f7ecb43780" alt="" width="375"><figcaption></figcaption></figure></div>

**Puis ouvrez `http://localhost:8888` dans votre navigateur.**
{% endstep %}

{% step %}

#### Rechercher et télécharger gpt-oss-120b

Lors du premier lancement, vous devrez créer un mot de passe pour sécuriser votre compte et vous reconnecter plus tard. Vous verrez ensuite un bref assistant d’accueil pour choisir un modèle, un jeu de données et les paramètres de base. Vous pouvez le passer à tout moment.

Ensuite, allez à l’onglet [Studio Chat](https://unsloth.ai/docs/fr/nouveau/studio/chat) et recherchez gpt-oss dans la barre de recherche, puis téléchargez le modèle et la quantification souhaités.

<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%2FgKxB8OhIRVgT29vCGFEg%2FScreenshot%202026-03-20%20at%201.34.07%E2%80%AFAM.png?alt=media&#x26;token=9950d667-4ff1-463e-b017-601d5e8e38a5" alt="" width="375"><figcaption></figcaption></figure></div>
{% endstep %}

{% step %}

#### Exécuter gpt-oss-120b

Les paramètres d’inférence devraient être définis automatiquement lors de l’utilisation d’Unsloth Studio, mais vous pouvez toujours les modifier manuellement. Vous pouvez également modifier la longueur du contexte, le modèle de chat et d’autres paramètres.

Pour plus d’informations, vous pouvez consulter notre [guide d’inférence d’Unsloth Studio](https://unsloth.ai/docs/fr/nouveau/studio/chat).

<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%2FXPQGEEr1YoKofrTatAKK%2Ftoolcallingif.gif?alt=media&#x26;token=25d68698-fb13-4c46-99b2-d39fb025df08" alt="" width="563"><figcaption></figcaption></figure></div>
{% endstep %}
{% endstepper %}

#### 📖 Llama.cpp : tutoriel pour exécuter gpt-oss-120b

Pour gpt-oss-120b, nous utiliserons spécifiquement Llama.cpp pour une inférence optimisée.

{% hint style="success" %}
Si vous voulez une **version non quantifiée en précision complète**, utilisez nos `versions F16` !
{% endhint %}

1. Obtenez la dernière version de `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez suivre également les instructions de compilation ci-dessous. Remplacez `-DGGML_CUDA=ON` par `-DGGML_CUDA=OFF` si vous n’avez pas de GPU ou si vous souhaitez simplement une inférence CPU.

   ```bash
   apt-get update
   apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y
   git clone https://github.com/ggml-org/llama.cpp
   cmake llama.cpp -B llama.cpp/build \
       -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON
   cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split
   cp llama.cpp/build/bin/llama-* llama.cpp
   ```
2. Vous pouvez utiliser directement llama.cpp pour télécharger le modèle, mais je suggère normalement d’utiliser `huggingface_hub` Pour utiliser directement llama.cpp, faites :

   ```bash
   ./llama.cpp/llama-cli \
       -hf unsloth/gpt-oss-120b-GGUF:F16 \
       --ctx-size 16384 \
       --n-gpu-layers 99 \
       -ot ".ffn_.*_exps.=CPU" \
       --temp 1.0 \
       --min-p 0.0 \
       --top-p 1.0 \
       --top-k 0.0 \
   ```
3. Ou, téléchargez le modèle via (après installation de `pip install huggingface_hub hf_transfer` ). Vous pouvez choisir UD-Q2\_K\_XL, ou d’autres versions quantifiées..

   ```python
   # !pip install huggingface_hub hf_transfer
   import os
   os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "0" # Peut parfois limiter le débit, donc mettez à 0 pour désactiver
   from huggingface_hub import snapshot_download
   snapshot_download(
       repo_id = "unsloth/gpt-oss-120b-GGUF",
       local_dir = "unsloth/gpt-oss-120b-GGUF",
       allow_patterns = ["*F16*"],
   )
   ```
4. Exécutez le modèle en mode conversation et essayez n’importe quel prompt.
5. Modifier `--threads -1` pour le nombre de threads CPU, `--ctx-size` 262114 pour la longueur du contexte, `--n-gpu-layers 99` pour le déchargement GPU, selon le nombre de couches. Essayez de l’ajuster si votre GPU manque de mémoire. Supprimez-le également si vous n’avez qu’une inférence CPU.

{% hint style="success" %}
Utilisez `-ot ".ffn_.*_exps.=CPU"` pour décharger toutes les couches MoE sur le CPU ! Cela permet effectivement de faire tenir toutes les couches non MoE sur 1 GPU, améliorant ainsi les vitesses de génération. Vous pouvez personnaliser l’expression régulière pour faire tenir plus de couches si vous avez plus de capacité GPU. Plus d’options sont discutées [ici](#improving-generation-speed).
{% endhint %}

{% code overflow="wrap" %}

```bash
./llama.cpp/llama-cli \
    --model unsloth/gpt-oss-120b-GGUF/gpt-oss-120b-F16.gguf \
    --ctx-size 16384 \
    --n-gpu-layers 99 \
    -ot ".ffn_.*_exps.=CPU" \
    --temp 1.0 \
    --min-p 0.0 \
    --top-p 1.0 \
    --top-k 0.0 \
```

{% endcode %}

### :tools: Améliorer la vitesse de génération

Si vous avez plus de VRAM, vous pouvez essayer de décharger davantage de couches MoE, ou de décharger des couches entières elles-mêmes.

Normalement, `-ot ".ffn_.*_exps.=CPU"` décharge toutes les couches MoE sur le CPU ! Cela permet effectivement de faire tenir toutes les couches non MoE sur 1 GPU, améliorant ainsi les vitesses de génération. Vous pouvez personnaliser l’expression régulière pour faire tenir plus de couches si vous avez plus de capacité GPU.

Si vous avez un peu plus de mémoire GPU, essayez `-ot ".ffn_(up|down)_exps.=CPU"` Cela décharge les couches MoE de projection vers le haut et vers le bas.

Essayez `-ot ".ffn_(up)_exps.=CPU"` si vous avez encore plus de mémoire GPU. Cela décharge uniquement les couches MoE de projection vers le haut.

Vous pouvez aussi personnaliser l’expression régulière, par exemple `-ot "\.(6|7|8|9|[0-9][0-9]|[0-9][0-9][0-9])\.ffn_(gate|up|down)_exps.=CPU"` signifie décharger les couches MoE gate, up et down, mais seulement à partir de la 6e couche.

Les [dernière version de llama.cpp](https://github.com/ggml-org/llama.cpp/pull/14363) introduit également un mode à haut débit. Utilisez `llama-parallel`. En savoir plus à ce sujet [ici](https://github.com/ggml-org/llama.cpp/tree/master/examples/parallel). Vous pouvez aussi **quantifier le cache KV à 4 bits** par exemple pour réduire le mouvement VRAM / RAM, ce qui peut aussi accélérer le processus de génération.

## 🦥 Affiner gpt-oss avec Unsloth

{% hint style="success" %}
[**Mise à jour du 28 août**](https://unsloth.ai/docs/fr/modeles/long-context-gpt-oss-training#new-saving-to-gguf-vllm-after-gpt-oss-training)**:** Vous pouvez désormais exporter/enregistrer votre modèle gpt-oss affiné avec QLoRA vers llama.cpp, vLLM, HF, etc.

Nous avons également introduit [Unsloth Flex Attention](https://unsloth.ai/docs/fr/modeles/long-context-gpt-oss-training#introducing-unsloth-flex-attention-support) qui permet **des longueurs de contexte plus de 8× plus longues**, **plus de 50 % de VRAM en moins** et **un entraînement plus de 1,5× plus rapide** par rapport à toutes les implémentations. [En savoir plus ici](https://unsloth.ai/docs/fr/modeles/long-context-gpt-oss-training#introducing-unsloth-flex-attention-support)
{% endhint %}

L’affinage gpt-oss avec Unsloth est 1,5x plus rapide, utilise 70 % de VRAM en moins et prend en charge des longueurs de contexte 10x plus longues. L’entraînement QLoRA de gpt-oss-20b tient sur 14 Go de VRAM, et gpt-oss-120b fonctionne sur 65 Go de VRAM.

* **Exigences QLoRA :** gpt-oss-20b = 14 Go de VRAM • gpt-oss-120b = 65 Go de VRAM.
* **Exigences BF16 LoRA :** gpt-oss-20b = 44 Go de VRAM • gpt-oss-120b = 210 Go de VRAM.

Lisez notre tutoriel étape par étape pour affiner gpt-oss :

{% content-ref url="gpt-oss-how-to-run-and-fine-tune/tutorial-how-to-fine-tune-gpt-oss" %}
[tutorial-how-to-fine-tune-gpt-oss](https://unsloth.ai/docs/fr/modeles/gpt-oss-how-to-run-and-fine-tune/tutorial-how-to-fine-tune-gpt-oss)
{% endcontent-ref %}

{% hint style="success" %}
Vous pouvez désormais exporter/enregistrer votre modèle gpt-oss affiné avec QLoRA vers llama.cpp, vLLM, HF, etc.
{% endhint %}

Notebooks Unsloth gratuits pour affiner gpt-oss :

* gpt-oss-20b [Notebook raisonnement + conversationnel](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-Fine-tuning.ipynb)

### Apprentissage par renforcement (GRPO)

Unsloth prend désormais en charge le RL pour gpt-oss ! Nous avons তৈরি deux notebooks ; pour plus de détails, lisez notre blog spécifique sur le RL de gpt-oss : [gpt-oss-reinforcement-learning](https://unsloth.ai/docs/fr/modeles/gpt-oss-how-to-run-and-fine-tune/gpt-oss-reinforcement-learning "mention")

| [Notebook 2048](https://colab.research.google.com/github/openai/gpt-oss/blob/main/examples/reinforcement-fine-tuning.ipynb) (Exemple officiel d’OpenAI) | [Notebook de génération de kernels](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/gpt-oss-\(20B\)-GRPO.ipynb) |
| ------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |

### 💾**NOUVEAU : enregistrement vers GGUF, vLLM après l’entraînement gpt-oss**

Vous pouvez désormais affiner gpt-oss avec QLoRA et enregistrer, exporter ou fusionner directement le modèle vers **llama.cpp**, **vLLM**, ou **HF** - pas seulement Unsloth. Nous publierons bientôt, espérons-le, un notebook gratuit.

Auparavant, tout modèle gpt-oss affiné avec QLoRA était limité à une exécution dans Unsloth. Nous avons supprimé cette limitation en introduisant **la déquantification à la demande des modèles de base MXFP4** (comme gpt-oss) pendant le processus de fusion LoRA. Cela permet de **exporter votre modèle affiné au format bf16**.

Après avoir affiné votre modèle gpt-oss, vous pouvez désormais le fusionner dans un format 16 bits avec une **seule commande**:

```python
model.save_pretrained_merged(save_directory, tokenizer)
```

Si vous préférez plutôt fusionner le modèle et le pousser directement vers le hub Hugging Face, vous pouvez le faire en utilisant :

```python
model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token=hf_token)
```

### 💡 Faire fonctionner efficacement l’affinage de gpt-oss

Nous avons constaté que, bien que MXFP4 soit très efficace, il ne prend pas nativement en charge l’entraînement avec gpt-oss. Pour surmonter cette limitation, nous avons implémenté des fonctions d’entraînement personnalisées spécifiquement pour les couches MXFP4 en les mimant via `Bitsandbytes` la quantification NF4.

Nous avons utilisé directement la bibliothèque Triton Kernels d’OpenAI pour permettre l’inférence MXFP4. Pour l’affinage / l’entraînement, cependant, les kernels MXFP4 ne prennent pas encore en charge l’entraînement, car la passe arrière n’est pas encore implémentée. Nous travaillons activement à l’implémenter dans Triton ! Il existe un drapeau appelé `W_TRANSPOSE` comme mentionné [ici](https://github.com/triton-lang/triton/blob/main/python/triton_kernels/triton_kernels/matmul_ogs_details/_matmul_ogs.py#L39), qui devrait être implémenté. La dérivée peut être calculée par la transposition des matrices de poids, et nous devons donc implémenter l’opération de transposition.

Si vous souhaitez entraîner gpt-oss avec une bibliothèque autre qu’Unsloth, vous devrez convertir les poids en bf16 avant l’entraînement. Cette approche, cependant, **augmente considérablement** à la fois l’utilisation de VRAM et le temps d’entraînement jusqu’à **300 % de mémoire en plus**! <mark style="background-color:green;">**TOUTES les autres méthodes d’entraînement nécessiteront un minimum de 65 Go de VRAM pour entraîner le modèle 20b, tandis qu’Unsloth n’en nécessite que 14 Go (-80 %).**</mark>

Comme les deux modèles utilisent une architecture MoE, le modèle 20B sélectionne 4 experts sur 32, tandis que le modèle 120B en sélectionne 4 sur 128 par jeton. Pendant l’entraînement et la mise à disposition, les poids sont stockés au format MXFP4 sous forme de `nn.Parameter` objets, et non comme des `nn.Linear` couches, ce qui complique la quantification, d’autant plus que les experts MoE/MLP représentent environ 19B des 20B paramètres.

Pour permettre la `quantification BitsandBytes` et un affinage économe en mémoire, nous avons converti ces paramètres en `nn.Linear` couches. Bien que cela ralentisse légèrement les opérations, cela permet un affinage sur des GPU à mémoire limitée, ce qui est un compromis intéressant.

### Guide d’affinage des ensembles de données

Bien que gpt-oss ne prenne en charge que le raisonnement, vous pouvez quand même l’affiner avec un [jeu de données](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/datasets-guide)sans raisonnement, mais cela peut affecter sa capacité de raisonnement. Si vous souhaitez conserver ses capacités de raisonnement (facultatif), vous pouvez utiliser un mélange de réponses directes et d’exemples de chaîne de pensée. Utilisez au moins <mark style="background-color:green;">75 % de raisonnement</mark> et <mark style="background-color:green;">25 % de non-raisonnement</mark> dans votre jeu de données pour que le modèle conserve ses capacités de raisonnement.

Notre notebook conversationnel gpt-oss-20b utilise l’exemple d’OpenAI qui est le jeu de données Multilingual-Thinking de Hugging Face. Le but d’utiliser ce jeu de données est de permettre au modèle d’apprendre et de développer des capacités de raisonnement dans ces quatre langues distinctes.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-4d648159c0ba6d62d5c9b5cd519767f764e5faab%2Fwider%20gptoss%20image.png?alt=media" alt=""><figcaption></figcaption></figure>


---

# Agent Instructions: Querying This Documentation

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

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/fr/modeles/gpt-oss-how-to-run-and-fine-tune.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.