# Tutoriel : comment fine-tuner gpt-oss Dans ce guide avec captures d'écran, vous apprendrez à affiner votre propre modèle gpt-oss personnalisé soit [localement](#local-gpt-oss-fine-tuning) sur votre machine avec [Unsloth](https://github.com/unslothai/unsloth) ou gratuitement en utilisant [Google Colab](#colab-gpt-oss-fine-tuning). Nous vous guiderons tout au long du processus, de la configuration à l'exécution et à l'enregistrement de votre modèle entraîné. {% hint style="success" %} [**Mise à jour du 28 août**](https://unsloth.ai/docs/fr/modeles/long-context-gpt-oss-training#introducing-unsloth-flex-attention-support)**:** 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 **>8× des longueurs de contexte plus longues**, **>50% de réduction de l'utilisation de la VRAM** et **>1,5× d'entraînement 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 %} > **Démarrage rapide :** Affinez 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) L'affinage gpt-oss d'Unsloth, comparé à toutes les autres implémentations FA2, atteint un entraînement 1,5× plus rapide, une réduction de 70% de l'utilisation de la VRAM et des longueurs de contexte 10× plus longues - sans perte de précision. * **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. Guide local Guide Colab ## 🌐 Affinage gpt-oss sur Colab Cette section couvre l'affinage de gpt-oss en utilisant notre Google Colab [notebooks](https://unsloth.ai/docs/fr/commencer/unsloth-notebooks). Vous pouvez également enregistrer et utiliser le notebook gpt-oss dans votre éditeur de code préféré et suivre notre [guide gpt-oss local](#local-gpt-oss-fine-tuning). {% stepper %} {% step %} #### Installer Unsloth (dans Colab) Dans Colab, exécutez les cellules **du haut vers le bas**. Utilisez **Exécuter tout** pour la première passe. La première cellule installe Unsloth (et les dépendances associées) et affiche les informations GPU/mémoire. Si une cellule renvoie une erreur, réexécutez-la simplement.

{% endstep %} {% step %} #### Configuration de gpt-oss et de l'Effort de Raisonnement Nous chargerons **`gpt-oss-20b`** en utilisant la [version linéarisée](https://unsloth.ai/docs/fr/modeles/gpt-oss-how-to-run-and-fine-tune/..#making-efficient-gpt-oss-fine-tuning-work) (car aucune autre version ne fonctionnera). Configurez les paramètres suivants : * `max_seq_length = 1024` * Recommandé pour des tests rapides et des expériences initiales. * `load_in_4bit = True` * Utilisez `False` pour l'entraînement LoRA (remarque : définir ceci sur `False` nécessitera au moins 43 Go de VRAM). Vous ***DEVEZ*** également définir **`model_name = "unsloth/gpt-oss-20b-BF16"`**

Vous devriez voir une sortie similaire à l'exemple ci-dessous. Remarque : nous changeons explicitement le `dtype` en `float32` pour garantir un comportement d'entraînement correct.

{% endstep %} {% step %} #### Hyperparamètres d'affinage (LoRA) Il est maintenant temps d'ajuster vos hyperparamètres d'entraînement. Pour un examen approfondi de comment, quand et quoi ajuster, consultez notre [guide détaillé des hyperparamètres](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide). {% hint style="info" %} Pour éviter [le surapprentissage](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide#avoiding-overfitting-and-underfitting), surveillez votre perte d'entraînement et évitez de fixer ces valeurs trop haut. {% endhint %} Cette étape ajoute des adapteurs LoRA pour un affinage efficace en paramètres. Environ 1% seulement des paramètres du modèle sont entraînés, ce qui rend le processus nettement plus efficace.

{% endstep %} {% step %} #### Essayer l'inférence Dans le notebook, il y a une section appelée *"Effort de raisonnement"* qui démontre l'inférence gpt-oss dans Colab. Vous pouvez sauter cette étape, mais vous devrez quand même exécuter le modèle plus tard une fois l'affinage terminé.

{% endstep %} {% step %} #### Préparation des données Pour cet exemple, nous utiliserons le [`HuggingFaceH4/Multilingual-Thinking`](https://huggingface.co/datasets/HuggingFaceH4/Multilingual-Thinking). Cet ensemble de données contient des exemples de raisonnement en chaîne (chain-of-thought) dérivés de questions d'utilisateurs traduites de l'anglais vers quatre langues supplémentaires. C'est le même ensemble de données référencé dans le guide d'affinage d'OpenAI. L'objectif d'utiliser un ensemble de données multilingue est d'aider le modèle à apprendre et à généraliser des schémas de raisonnement à travers plusieurs langues.

gpt-oss introduit un système d'effort de raisonnement qui contrôle la quantité de raisonnement effectuée par le modèle. Par défaut, l'effort de raisonnement est réglé sur `faible`, mais vous pouvez le modifier en définissant le `reasoning_effort` paramètre sur `faible`, `moyen` ou `élevé`. Exemple : ```python tokenizer.apply_chat_template( text, tokenize = False, add_generation_prompt = False, reasoning_effort = "medium", ) ``` Pour formater l'ensemble de données, nous appliquons une version personnalisée du prompt gpt-oss : ```python from unsloth.chat_templates import standardize_sharegpt dataset = standardize_sharegpt(dataset) dataset = dataset.map(formatting_prompts_func, batched = True,) ``` Inspectons l'ensemble de données en affichant le premier exemple : ```notebook-python print(dataset[0]['text']) ```

Pendant l'entraînement, surveillez la perte pour vous assurer qu'elle diminue au fil du temps. Cela confirme que le processus d'entraînement fonctionne correctement.

Cela devrait produire une sortie similaire à :

{% endstep %} {% step %} #### Enregistrez/exportez votre modèle Pour enregistrer votre modèle affiné, vous pouvez exporter votre modèle affiné à la fois en **format bf16 ,** avec notre **déquantification à la demande de MXFP4** des modèles de base en utilisant `save_method="merged_16bit"`ou en **MXFP4** format Safetensors en utilisant `save_method="mxfp4"` . Le **MXFP4** le format de fusion natif offre des améliorations de performance significatives par rapport au **format bf16** : il utilise jusqu'à 75% d'espace disque en moins, réduit la consommation de VRAM de 50%, accélère la fusion de 5 à 10×, et permet une conversion beaucoup plus rapide en **GGUF** format. {% hint style="success" %} Nouveau : l'enregistrement ou la fusion des modèles QLoRA affinés vers GGUF est désormais pris en charge pour une utilisation dans d'autres frameworks (par ex. Hugging Face, llama.cpp avec GGUF). {% endhint %} Après avoir affiné votre modèle gpt-oss, vous pouvez le fusionner en **MXFP4** format avec : ```python model.save_pretrained_merged(save_directory, tokenizer, save_method="mxfp4) ``` Si vous préférez fusionner le modèle et pousser directement vers le hub hugging-face : ```python model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token= hf_token, save_method="mxfp4") ``` #### :sparkles: Enregistrement vers Llama.cpp 1. Obtenez le dernier `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez suivre les instructions de compilation ci-dessous également. Changez `-DGGML_CUDA=ON` en `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez 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.cp ``` 2. Convertir le **MXFP4** modèle fusionné : ```bash python3 llama.cpp/convert_hf_to_gguf.py gpt-oss-finetuned-merged/ --outfile gpt-oss-finetuned-mxfp4.gguf ``` 3. Exécuter l'inférence sur le modèle quantifié : ```bash llama.cpp/llama-cli --model gpt-oss-finetuned-mxfp4.gguf \ --jinja -ngl 99 --threads -1 --ctx-size 16384 \ --temp 1.0 --top-p 1.0 --top-k 0 \ -p "Le sens de la vie et de l'univers est" ```

{% endstep %} {% endstepper %} ## 🖥️ Affinage gpt-oss local Ce chapitre couvre l'affinage de gpt-oss sur votre appareil local. Bien que **gpt-oss-20b** l'affinage puisse fonctionner avec seulement 14 Go de VRAM, nous recommandons d'avoir au moins 16 Go de VRAM disponibles pour garantir des exécutions d'entraînement stables et fiables. {% hint style="info" %} Nous recommandons de télécharger ou d'incorporer des éléments de notre Colab [notebooks](https://unsloth.ai/docs/fr/commencer/unsloth-notebooks) dans votre configuration locale pour une utilisation plus facile. {% endhint %} {% stepper %} {% step %} #### Installer Unsloth localement Assurez-vous que votre appareil est [compatible Unsloth](https://unsloth.ai/docs/fr/commencer/fine-tuning-for-beginners/unsloth-requirements) et vous pouvez lire notre [guide d'installation détaillé](https://unsloth.ai/docs/fr/commencer/install). **Vous pouvez également installer Unsloth en utilisant notre** [**image Docker**](https://unsloth.ai/docs/models/qwen3-coder-next)**.** Notez que `pip install unsloth` ne fonctionnera pas pour cette configuration, car nous devons utiliser les dernières versions de PyTorch, Triton et des packages associés. Installez Unsloth en utilisant cette commande spécifique : ```python # Nous installons les dernières versions de Torch, Triton, les noyaux Triton d'OpenAI, Transformers et Unsloth ! !pip install --upgrade -qqq uv try: import numpy; install_numpy = f"numpy=={numpy.__version__}" except: install_numpy = "numpy" !uv pip install -qqq \ "torch>=2.8.0" "triton>=3.4.0" {install_numpy} \ "unsloth_zoo[base] @ git+https://github.com/unslothai/unsloth-zoo" \ "unsloth[base] @ git+https://github.com/unslothai/unsloth" \ torchvision bitsandbytes \ git+https://github.com/huggingface/transformers \ git+https://github.com/triton-lang/triton.git@05b2c186c1b6c9a08375389d5efe9cb4c401c075#subdirectory=python/triton_kernels ``` {% endstep %} {% step %} #### Configuration de gpt-oss et de l'Effort de Raisonnement Nous chargerons **`gpt-oss-20b`** en utilisant la [version linéarisée](https://unsloth.ai/docs/fr/modeles/gpt-oss-how-to-run-and-fine-tune/..#making-efficient-gpt-oss-fine-tuning-work) (car aucune autre version ne fonctionnera pour l'affinage QLoRA). Configurez les paramètres suivants : * `max_seq_length = 2048` * Recommandé pour des tests rapides et des expériences initiales. * `load_in_4bit = True` * Utilisez `False` pour l'entraînement LoRA (remarque : définir ceci sur `False` nécessitera au moins 43 Go de VRAM). Vous ***DEVEZ*** également définir **`model_name = "unsloth/gpt-oss-20b-BF16"`**

from unsloth import FastLanguageModel
import torch
max_seq_length = 1024
dtype = None

# Modèles pré-quantifiés 4 bits que nous prenons en charge pour un téléchargement 4× plus rapide + pas d'OOM.
fourbit_models = [
    "unsloth/gpt-oss-20b-unsloth-bnb-4bit", # modèle 20B utilisant la quantification bitsandbytes 4bit
    "unsloth/gpt-oss-120b-unsloth-bnb-4bit",
    "unsloth/gpt-oss-20b", # modèle 20B utilisant le format MXFP4
    "unsloth/gpt-oss-120b",
] # Plus de modèles sur https://huggingface.co/unsloth

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/gpt-oss-20b",
    dtype = dtype, # None pour détection automatique
    max_seq_length = max_seq_length, # Choisissez n'importe quelle valeur pour un contexte long !
    load_in_4bit = True,  # quantification 4 bits pour réduire la mémoire
    full_finetuning = False, # [NOUVEAU!] Nous avons maintenant le fine-tuning complet !
    # token = "hf_...", # utilisez-en un si vous utilisez des modèles à accès restreint
)

Vous devriez voir une sortie similaire à l'exemple ci-dessous. Remarque : nous changeons explicitement le `dtype` en `float32` pour garantir un comportement d'entraînement correct. {% endstep %} {% step %} #### Hyperparamètres d'affinage (LoRA) Il est maintenant temps d'ajuster vos hyperparamètres d'entraînement. Pour un examen approfondi de comment, quand et quoi ajuster, consultez notre [guide détaillé des hyperparamètres](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide). {% hint style="info" %} Pour éviter [le surapprentissage](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide#avoiding-overfitting-and-underfitting), surveillez votre perte d'entraînement et évitez de fixer ces valeurs trop haut. {% endhint %} Cette étape ajoute des adapteurs LoRA pour un affinage efficace en paramètres. Environ 1% seulement des paramètres du modèle sont entraînés, ce qui rend le processus nettement plus efficace. ```python model = FastLanguageModel.get_peft_model( model, r = 8, # Choisissez n'importe quel nombre > 0 ! Suggestion : 8, 16, 32, 64, 128 target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj",], lora_alpha = 16, lora_dropout = 0, # Prend en charge n'importe quelle valeur, mais = 0 est optimisé bias = "none", # Prend en charge n'importe quelle valeur, mais = "none" est optimisé # [NOUVEAU] "unsloth" utilise 30% de VRAM en moins, permet des tailles de batch 2× supérieures ! use_gradient_checkpointing = "unsloth", # True or "unsloth" pour des contextes très longs random_state = 3407, use_rslora = False, # Nous prenons en charge le LoRA à rang stabilisé loftq_config = None, # Et LoftQ ) ``` {% endstep %} {% step %} #### Préparation des données Pour cet exemple, nous utiliserons le [`HuggingFaceH4/Multilingual-Thinking`](https://huggingface.co/datasets/HuggingFaceH4/Multilingual-Thinking). Cet ensemble de données contient des exemples de raisonnement en chaîne (chain-of-thought) dérivés de questions d'utilisateurs traduites de l'anglais vers quatre langues supplémentaires. C'est le même ensemble de données référencé dans le guide d'affinage d'OpenAI. L'objectif d'utiliser un ensemble de données multilingue est d'aider le modèle à apprendre et à généraliser des schémas de raisonnement à travers plusieurs langues. ```python def formatting_prompts_func(examples): convos = examples["messages"] texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos] return { "text" : texts, } pass #token = "hf_...", # en utiliser un si vous utilisez des modèles régulés comme meta-llama/Llama-2-7b-hf dataset = load_dataset("HuggingFaceH4/Multilingual-Thinking", split="train") Elise ``` gpt-oss introduit un système d'effort de raisonnement qui contrôle la quantité de raisonnement effectuée par le modèle. Par défaut, l'effort de raisonnement est réglé sur `faible`, mais vous pouvez le modifier en définissant le `reasoning_effort` paramètre sur `faible`, `moyen` ou `élevé`. Exemple : ```python tokenizer.apply_chat_template( text, tokenize = False, add_generation_prompt = False, reasoning_effort = "medium", ) ``` Pour formater l'ensemble de données, nous appliquons une version personnalisée du prompt gpt-oss : ```python from unsloth.chat_templates import standardize_sharegpt dataset = standardize_sharegpt(dataset) dataset = dataset.map(formatting_prompts_func, batched = True,) ``` Inspectons l'ensemble de données en affichant le premier exemple : ```notebook-python print(dataset[0]['text']) ```

Une caractéristique unique de gpt-oss est son utilisation du [**format OpenAI Harmony**](https://github.com/openai/harmony)**,** qui prend en charge des conversations structurées, la sortie de raisonnement et l'appel d'outils. Ce format inclut des balises telles que `<|start|>` , `<|message|>` , et `<|return|>` . {% hint style="info" %} 🦥 Unsloth corrige le modèle de chat pour s'assurer qu'il est correct. Consultez ce [tweet](https://x.com/danielhanchen/status/1953901104150065544) pour des détails techniques sur notre correction de modèle. {% endhint %} N'hésitez pas à adapter le prompt et la structure à votre propre ensemble de données ou cas d'utilisation. Pour plus d'orientation, référez-vous à notre [guide d'ensemble de données](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/datasets-guide). {% endstep %} {% step %} #### Entraîner le modèle Nous avons présélectionné des hyperparamètres d'entraînement pour des résultats optimaux. Cependant, vous pouvez les modifier en fonction de votre cas d'utilisation spécifique. Consultez notre [guide des hyperparamètres](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide). Dans cet exemple, nous entraînons pendant 60 étapes pour accélérer le processus. Pour un entraînement complet, définissez `num_train_epochs=1` et désactivez la limitation d'étapes en définissant `max_steps=None`. ```python from trl import SFTConfig, SFTTrainer trainer = SFTTrainer( trainer = Trainer( tokenizer = tokenizer, model = model, args = SFTConfig( args = TrainingArguments( gradient_accumulation_steps = 4, per_device_train_batch_size = 1, warmup_steps = 5, max_steps = 30, max_steps = 60, bf16 = is_bfloat16_supported(), optim = "adamw_8bit", logging_steps = 1, weight_decay = 0.01,','t201':'lr_scheduler_type = "linear",'] seed = 3407, output_dir = "outputs", report_to = "none", # Utilisez ceci pour WandB, etc. ), ) ``` Pendant l'entraînement, surveillez la perte pour vous assurer qu'elle diminue au fil du temps. Cela confirme que le processus d'entraînement fonctionne correctement.

{% endstep %} {% step %} #### Inférence : Exécutez votre modèle entraîné Il est maintenant temps d'exécuter l'inférence avec votre modèle affiné. Vous pouvez modifier l'instruction et l'entrée, mais laissez la sortie vide. Dans cet exemple, nous testons la capacité du modèle à raisonner en français en ajoutant une instruction spécifique au prompt système, suivant la même structure utilisée dans notre ensemble de données. ```python messages = [ {"role": "system", "content": "langue de raisonnement : Français\n\nVous êtes un assistant utile qui peut résoudre des problèmes mathématiques."}, {"role": "user", "content": "Résoudre x^5 + 3x^4 - 10 = 3."}, ] inputs = tokenizer.apply_chat_template( messages, add_generation_prompt = True, return_tensors = "pt", return_dict = True, reasoning_effort = "medium", ).to(model.device) from transformers import TextStreamer _ = model.generate(**inputs, max_new_tokens = 2048, streamer = TextStreamer(tokenizer)) ``` Cela devrait produire une sortie similaire à :

{% endstep %} {% step %} #### Enregistrez et exportez votre modèle Pour enregistrer votre modèle affiné, il peut être exporté au format Safetensors avec notre nouveau **déquantification à la demande de MXFP4** modèles de base (comme gpt-oss) lors du processus de fusion LoRA. Cela rend possible de **exporter votre modèle affiné au format bf16**. {% hint style="success" %} Nouveau : l'enregistrement ou la fusion des modèles QLoRA affinés vers GGUF est désormais pris en charge pour une utilisation dans d'autres frameworks (par ex. Hugging Face, llama.cpp avec GGUF). {% endhint %} Après avoir affiné votre modèle gpt-oss, vous pouvez le fusionner en format 16 bits avec : ```python model.save_pretrained_merged(save_directory, tokenizer) ``` Si vous préférez fusionner le modèle et pousser directement vers le hub hugging-face : ```python model.push_to_hub_merged(repo_name, tokenizer=tokenizer, token= hf_token) ``` #### :sparkles: Enregistrement vers Llama.cpp 1. Obtenez le dernier `llama.cpp` sur [GitHub ici](https://github.com/ggml-org/llama.cpp). Vous pouvez suivre les instructions de compilation ci-dessous également. Changez `-DGGML_CUDA=ON` en `-DGGML_CUDA=OFF` si vous n'avez pas de GPU ou si vous voulez 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.cp ``` 2. Convertir et quantifier le modèle fusionné : ```bash python3 llama.cpp/convert_hf_to_gguf.py gpt-oss-finetuned-merged/ --outfile gpt-oss-finetuned.gguf llama.cpp/llama-quantize gpt-oss-finetuned.gguf gpt-oss-finetuned-Q8_0.gguf Q8_0 ``` 3. Exécuter l'inférence sur le modèle quantifié : ```bash llama.cpp/llama-cli --model gpt-oss-finetuned-Q8_0.gguf \ --jinja -ngl 99 --threads -1 --ctx-size 16384 \ --temp 1.0 --top-p 1.0 --top-k 0 \ -p "Le sens de la vie et de l'univers est" ``` {% endstep %} {% endstepper %} ### 🏁 Et voilà ! Vous avez affiné gpt-oss avec Unsloth. Nous travaillons actuellement sur des implémentations RL et GRPO, ainsi que sur l'amélioration de l'enregistrement et de l'exécution des modèles, alors restez à l'écoute. Comme toujours, n'hésitez pas à passer sur notre [Discord](https://discord.com/invite/unsloth) ou [Reddit](https://www.reddit.com/r/unsloth/) si vous avez besoin d'aide. ## ❓FAQ (Foire aux questions) #### 1. Puis-je exporter mon modèle pour l'utiliser plus tard dans Hugging Face, llama.cpp GGUF ou vLLM ? Oui, vous pouvez désormais [enregistrer/exporter votre gpt-oss affiné](https://unsloth.ai/docs/fr/modeles/long-context-gpt-oss-training#new-saving-to-gguf-vllm-after-gpt-oss-training) modèle en utilisant la nouvelle mise à jour d'Unsloth ! #### 2. Puis-je faire un entraînement fp4 ou MXFP4 avec gpt-oss ? Non, actuellement aucun framework ne prend en charge l'entraînement fp4 ou MXFP4. Unsloth est cependant le seul framework à prendre en charge l'affinage QLoRA 4 bits pour le modèle, permettant une utilisation de VRAM plus de 4× moindre. #### 3. Puis-je exporter mon modèle au format MXFP4 après l'entraînement ? Non, actuellement aucune bibliothèque ou framework ne prend cela en charge. #### 4. Puis-je faire de l'apprentissage par renforcement (RL) ou GRPO avec gpt-oss ? Oui ! Unsloth prend désormais en charge le RL pour gpt-oss avec GRPO/GSPO. Nous l'avons fait fonctionner sur un notebook Kaggle gratuit et avons obtenu l'inférence la plus rapide pour le RL. [En savoir plus ici](https://unsloth.ai/docs/fr/modeles/gpt-oss-how-to-run-and-fine-tune/gpt-oss-reinforcement-learning) *** ***Remerciements :** Un grand merci à* [*Eyera*](https://huggingface.co/Orenguteng) *pour avoir contribué à ce guide !* --- # 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/tutorial-how-to-fine-tune-gpt-oss.md?ask= ``` 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.