# Guide du fine-tuning de LLMs

## 1. Qu'est-ce que l'affinage (fine-tuning) ?

L'affinage / l'entraînement / le post-entraînement des modèles personnalise leur comportement, enrichit et injecte des connaissances, et optimise les performances pour des domaines et des tâches spécifiques. Par exemple :

* OpenAI **GPT-5** a été post-entraîné pour améliorer le suivi des instructions et le comportement utile en conversation.
* La méthode standard de post-entraînement s'appelle Supervised Fine-Tuning (SFT). D'autres méthodes incluent l'optimisation par préférence (DPO, ORPO), la distillation et [l'apprentissage par renforcement (RL)](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide) (GRPO, GSPO), où un « agent » apprend à prendre des décisions en interagissant avec un environnement et en recevant **des retours** sous la forme de **récompenses** ou **pénalités**.

Avec [Unsloth](https://github.com/unslothai/unsloth), vous pouvez affiner ou faire du RL gratuitement sur Colab, Kaggle ou localement avec seulement 3 Go de VRAM en utilisant nos [notebooks](https://docs.unsloth.ai/get-started/unsloth-notebooks). En affinant un modèle pré-entraîné sur un jeu de données, vous pouvez :

* **Mettre à jour et apprendre de nouvelles connaissances** : Injecter et apprendre de nouvelles informations spécifiques au domaine.
* **Personnaliser le comportement** : Ajuster le ton, la personnalité ou le style de réponse du modèle.
* **Optimiser pour des tâches** : Améliorer la précision et la pertinence pour des cas d'utilisation spécifiques.

**Exemples de cas d'utilisation d'affinage ou de RL**:

* Permet aux LLMs de prédire si un titre a un impact positif ou négatif sur une entreprise.
* Peut utiliser des interactions historiques avec des clients pour des réponses plus précises et personnalisées.
* Affiner un LLM sur des textes juridiques pour l'analyse de contrats, la recherche de jurisprudence et la conformité.

Vous pouvez considérer un modèle affiné comme un agent spécialisé conçu pour accomplir des tâches spécifiques de manière plus efficace et efficiente. **L'affinage peut reproduire toutes les capacités de RAG**, mais pas l'inverse.

{% columns %}
{% column %}

#### :question:Qu'est-ce que LoRA/QLoRA ?

Dans les LLM, nous avons des poids de modèle. Llama 70B a 70 milliards de nombres. Au lieu de changer les 70 milliards de nombres, nous ajoutons des matrices fines A et B à chaque poids, et optimisons celles-ci. Cela signifie que nous n'optimisons que 1 % des poids. LoRA correspond à lorsque le modèle original est en 16 bits non quantifié tandis que QLoRA quantifie en 4 bits pour économiser 75 % de mémoire.
{% endcolumn %}

{% column %}

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-715b6260aae497f160d7f9a1019bcfa472675dcf%2Fimage%20(7)%20(1)%20(1).png?alt=media" alt=""><figcaption><p>Au lieu d'optimiser les poids du modèle (jaune), nous optimisons 2 matrices fines A et B.</p></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

#### Idées reçues sur l'affinage :

Vous avez peut-être entendu que l'affinage ne permet pas à un modèle d'apprendre de nouvelles connaissances ou que RAG est meilleur que l'affinage. C'est **false**. Vous pouvez entraîner un modèle spécialisé en codage avec l'affinage et le RL tandis que RAG ne peut pas changer les poids du modèle et se contente d'augmenter ce que le modèle voit au moment de l'inférence. Lisez plus de FAQ + idées reçues [ici](https://unsloth.ai/docs/fr/fine-tuning-for-beginners/faq-+-is-fine-tuning-right-for-me#fine-tuning-vs.-rag-whats-the-difference):

{% content-ref url="fine-tuning-for-beginners/faq-+-is-fine-tuning-right-for-me" %}
[faq-+-is-fine-tuning-right-for-me](https://unsloth.ai/docs/fr/commencer/fine-tuning-for-beginners/faq-+-is-fine-tuning-right-for-me)
{% endcontent-ref %}

> [**Présentation d'Unsloth Studio :** ](https://unsloth.ai/docs/fr/nouveau/studio) Notre nouvelle interface web open-source pour entraîner et exécuter des modèles. Cela signifie que vous pouvez désormais affiner des modèles sans code et bénéficier de fonctionnalités d'observabilité et de création automatique de jeux de données.

<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%2FxV1PO5DbF3ksB51nE2Tw%2Fmore%20cropped%20ui%20for%20homepage.png?alt=media&#x26;token=f75942c9-3d8d-4b59-8ba2-1a4a38de1b86" alt="" width="563"><figcaption></figcaption></figure></div>

## 2. Choisir le bon modèle et la bonne méthode

Si vous êtes débutant, il est préférable de commencer par un petit modèle instructif comme Llama 3.1 (8B) et d'expérimenter à partir de là. Vous devrez également décider entre l'affinage normal, le RL, QLoRA ou l'entraînement LoRA :

* **l'apprentissage par renforcement (RL)** est utilisé lorsque vous avez besoin qu'un modèle excelle dans un comportement spécifique (par ex. appeler des outils) en utilisant un environnement et une fonction de récompense plutôt que des données étiquetées. Nous avons plusieurs [exemples de notebooks](https://unsloth.ai/docs/fr/unsloth-notebooks#grpo-reasoning-rl-notebooks), mais pour la plupart des cas d'utilisation, le SFT standard suffit.
* **LoRA** est une méthode d'entraînement économe en paramètres qui garde généralement les poids du modèle de base gelés et entraîne un petit ensemble de poids adaptateurs à faible rang (en précision 16 bits).
* **QLoRA** combine LoRA avec la précision 4 bits pour gérer des modèles très grands avec des ressources minimales.
* Unsloth prend également en charge l'affinage complet (FFT) et le pré-entraînement, qui nécessitent beaucoup plus de ressources, mais le FFT est généralement inutile. Lorsqu'il est bien fait, LoRA peut égaler le FFT.
* Unsloth **tous types de modèles**: [texte en parole](https://unsloth.ai/docs/fr/bases/text-to-speech-tts-fine-tuning), [embeddings](https://unsloth.ai/docs/fr/bases/embedding-finetuning), GRPO, RL, [vision](https://unsloth.ai/docs/fr/bases/vision-fine-tuning), multimodal et plus.

{% hint style="info" %}
La recherche montre que **s'entraîner et servir dans la même précision** aide à préserver la précision. Cela signifie que si vous voulez servir en 4 bits, entraînez en 4 bits et vice versa.
{% endhint %}

Nous recommandons de commencer par QLoRA, car c'est l'une des méthodes les plus accessibles et efficaces pour entraîner des modèles. Nos [quants dynamiques 4 bits](https://unsloth.ai/blog/dynamic-4bit) la perte de précision pour QLoRA par rapport à LoRA est désormais en grande partie récupérée.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-cfc51c261e6d24df3aa967d9b9a482313465cbc1%2Fmodel%20name%20change.png?alt=media" alt="" width="563"><figcaption></figcaption></figure>

Vous pouvez changer le nom du modèle par celui que vous souhaitez en le faisant correspondre au nom du modèle sur Hugging Face par ex. '`unsloth/llama-3.1-8b-unsloth-bnb-4bit`'.

Nous recommandons de commencer par **modèles Instruct**, car ils permettent un affinage direct en utilisant des modèles de conversation (ChatML, ShareGPT etc.) et nécessitent moins de données comparés aux **modèles de base** (qui utilisent Alpaca, Vicuna etc.). En savoir plus sur les différences entre [modèles instruct et modèles de base ici](https://unsloth.ai/docs/fr/commencer/what-model-should-i-use#instruct-or-base-model).

* Les noms de modèles se terminant par **`unsloth-bnb-4bit`** indiquent qu'ils sont [**quants dynamiques 4 bits Unsloth**](https://unsloth.ai/blog/dynamic-4bit) **des quantifications**. Ces modèles consomment légèrement plus de VRAM que les modèles standard BitsAndBytes 4 bits mais offrent une précision nettement supérieure.
* Si un nom de modèle se termine seulement par **`bnb-4bit`**, sans "unsloth", il fait référence à une quantification standard BitsAndBytes en 4 bits.
* Les modèles sans **suffixe** sont dans leur **format original 16 bits ou 8 bits**. Bien qu'il s'agisse des modèles originaux des créateurs officiels, nous incluons parfois des corrections importantes - telles que des correctifs de modèle de conversation ou de tokenizer. Il est donc recommandé d'utiliser nos versions lorsqu'elles sont disponibles.

Il existe d'autres paramètres que vous pouvez activer/désactiver :

* **`max_seq_length = 2048`** – Contrôle la longueur du contexte. Alors que Llama-3 prend en charge 8192, nous recommandons 2048 pour les tests. Unsloth permet un affinage avec un contexte 4× plus long.
* **`dtype = None`** – Par défaut None ; utilisez `torch.float16` ou `torch.bfloat16` pour les GPU plus récents.
* **`load_in_4bit = True`** – Active la quantification en 4 bits, réduisant l'utilisation de mémoire par 4 pour l'affinage. La désactiver active l'affinage LoRA en 16 bits. Vous pouvez également activer LoRA 16 bits avec `load_in_16bit = True`
* Pour activer l'affinage complet (FFT), définissez `full_finetuning = True`. Pour l'affinage en 8 bits, définissez `load_in_8bit = True`.
* **Remarque :** Une seule méthode d'entraînement peut être définie sur `True` à la fois.

{% hint style="info" %}
Une erreur fréquente est de se lancer directement dans l'affinage complet (FFT), qui est gourmand en calcul. Commencez par tester avec LoRA ou QLoRA d'abord ; si cela ne fonctionne pas là, cela ne fonctionnera presque certainement pas avec FFT. Et si LoRA échoue, n'assumez pas que le FFT résoudra magiquement le problème.
{% endhint %}

Vous pouvez aussi faire [Texte en parole (TTS)](https://unsloth.ai/docs/fr/bases/text-to-speech-tts-fine-tuning), [raisonnement (GRPO)](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide), [vision](https://unsloth.ai/docs/fr/bases/vision-fine-tuning), [RL](https://unsloth.ai/docs/fr/commencer/reinforcement-learning-rl-guide/preference-dpo-orpo-and-kto) (GRPO, DPO), [pré-entraînement continu](https://unsloth.ai/docs/fr/bases/continued-pretraining), complétion de texte et d'autres méthodologies d'entraînement avec Unsloth.

{% columns %}
{% column %}
Lisez notre guide sur le choix des modèles :

{% content-ref url="fine-tuning-llms-guide/what-model-should-i-use" %}
[what-model-should-i-use](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/what-model-should-i-use)
{% endcontent-ref %}
{% endcolumn %}

{% column %}
Pour des tutoriels individuels sur les modèles :

{% content-ref url="../modeles/tutorials" %}
[tutorials](https://unsloth.ai/docs/fr/modeles/tutorials)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

## 3. Votre jeu de données

Pour les LLM, les jeux de données sont des collections de données pouvant être utilisées pour entraîner nos modèles. Afin d'être utiles pour l'entraînement, les données textuelles doivent être dans un format pouvant être tokenisé.

* Vous devrez créer un jeu de données généralement avec 2 colonnes - question et réponse. La qualité et la quantité refléteront en grande partie le résultat final de votre affinage, il est donc impératif de bien faire cette partie.
* Vous pouvez [générer des données de manière synthétique](https://unsloth.ai/docs/fr/commencer/datasets-guide#synthetic-data-generation) et structurer votre jeu de données (en paires Q/R) en utilisant ChatGPT ou des LLM locaux.
* Vous pouvez également utiliser notre nouveau notebook Synthetic Dataset qui analyse automatiquement les documents (PDF, vidéos, etc.), génère des paires Q/R et nettoie automatiquement les données en utilisant des modèles locaux comme Llama 3.2. [Accédez au notebook ici.](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Meta_Synthetic_Data_Llama3_2_\(3B\).ipynb)
* L'affinage peut apprendre à partir d'un référentiel existant de documents et étendre continuellement sa base de connaissances, mais le simple dépôt de données ne fonctionnera pas aussi bien. Pour des résultats optimaux, sélectionnez un jeu de données bien structuré, idéalement sous forme de paires question-réponse. Cela améliore l'apprentissage, la compréhension et la précision des réponses.
* Mais ce n'est pas toujours le cas, par ex. si vous affinez un LLM pour le code, le simple dépôt de toutes vos données de code peut en fait permettre à votre modèle d'obtenir des améliorations de performance significatives, même sans formatage structuré. Donc cela dépend vraiment de votre cas d'utilisation.

***En savoir plus sur la création de votre jeu de données :***

{% content-ref url="fine-tuning-llms-guide/datasets-guide" %}
[datasets-guide](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/datasets-guide)
{% endcontent-ref %}

Pour la plupart de nos exemples de notebooks, nous utilisons le [jeu de données Alpaca](https://docs.unsloth.ai/basics/tutorial-how-to-finetune-llama-3-and-use-in-ollama#id-6.-alpaca-dataset) cependant d'autres notebooks comme Vision utiliseront des jeux de données différents qui peuvent nécessiter des images dans la sortie de la réponse également.

### 4. Comprendre les hyperparamètres d'entraînement

Apprenez à choisir les [hyperparamètres](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide) en utilisant les bonnes pratiques issues de la recherche et d'expériences réelles - et comprenez comment chacun affecte les performances de votre modèle.

**Pour un guide complet sur la façon dont les hyperparamètres affectent l'entraînement, voir :**

{% content-ref url="fine-tuning-llms-guide/lora-hyperparameters-guide" %}
[lora-hyperparameters-guide](https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/lora-hyperparameters-guide)
{% endcontent-ref %}

## 5. Installation et exigences

Vous pouvez utiliser Unsloth de deux manières principales : nos notebooks gratuits ou localement.

### Notebooks Unsloth

Nous recommandons aux débutants d'utiliser nos [notebooks](https://unsloth.ai/docs/fr/commencer/unsloth-notebooks) premiers car c'est la façon la plus simple de commencer avec des étapes guidées. Vous pouvez ensuite exporter les notebooks pour les utiliser localement.

Unsloth propose des notebooks pas à pas pour [texte en parole](https://unsloth.ai/docs/fr/bases/text-to-speech-tts-fine-tuning), [embeddings](https://unsloth.ai/docs/fr/bases/embedding-finetuning), GRPO, RL, [vision](https://unsloth.ai/docs/fr/bases/vision-fine-tuning), multimodal, différents cas d'utilisation et plus.

### Installation locale

Vous pouvez aussi installer Unsloth localement via [docker](https://unsloth.ai/docs/fr/commencer/install/docker "mention") ou `pip install unsloth` (avec Linux, WSL ou [Windows](https://unsloth.ai/docs/fr/commencer/install/windows-installation)). Selon le modèle que vous utilisez, vous aurez également besoin de suffisamment de VRAM et de ressources.

L'installation d'Unsloth nécessitera un appareil Windows ou Linux. Une fois Unsloth installé, vous pouvez copier-coller nos notebooks et les utiliser dans votre propre environnement local. Voir :

{% columns %}
{% column %}
{% content-ref url="fine-tuning-for-beginners/unsloth-requirements" %}
[unsloth-requirements](https://unsloth.ai/docs/fr/commencer/fine-tuning-for-beginners/unsloth-requirements)
{% endcontent-ref %}
{% endcolumn %}

{% column %}
{% content-ref url="install" %}
[install](https://unsloth.ai/docs/fr/commencer/install)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

## 6. Entraînement et évaluation

Une fois que tout est prêt, il est temps d'entraîner ! Si quelque chose ne fonctionne pas, souvenez-vous que vous pouvez toujours modifier les hyperparamètres, votre jeu de données, etc.

Vous verrez un journal de nombres pendant l'entraînement. Il s'agit de la perte d'entraînement, qui montre à quel point le modèle apprend de votre jeu de données. Dans de nombreux cas, une perte autour de 0,5 à 1,0 est un bon signe, mais cela dépend de votre jeu de données et de la tâche. Si la perte ne diminue pas, vous devrez peut-être ajuster vos paramètres. Si la perte tombe à 0, cela peut signifier un surapprentissage, il est donc important de vérifier la validation également.

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-feb9b0f5763d41cecaec9a3a9cd227ad918f0ca7%2Fimage.png?alt=media" alt="" width="375"><figcaption><p>La perte d'entraînement apparaîtra sous forme de nombres</p></figcaption></figure>

Nous recommandons généralement de conserver les paramètres par défaut sauf si vous avez besoin d'un entraînement plus long ou de tailles de lot plus grandes.

* **`per_device_train_batch_size = 2`** – Augmentez pour une meilleure utilisation du GPU mais attention à un entraînement plus lent dû au padding. À la place, augmentez `gradient_accumulation_steps` pour un entraînement plus fluide.
* **`gradient_accumulation_steps = 4`** – Simule une taille de lot plus grande sans augmenter l'utilisation mémoire.
* **`max_steps = 60`** – Accélère l'entraînement. Pour des exécutions complètes, remplacez par `num_train_epochs = 1` (1–3 époques recommandées pour éviter le surapprentissage).
* **`learning_rate = 2e-4`** – Plus bas pour un affinage plus lent mais plus précis. Essayez des valeurs comme `1e-4`, `5e-5`, ou `2e-5`.

#### Évaluation

Pour évaluer, vous pouvez faire une évaluation manuelle en discutant simplement avec le modèle pour voir s'il vous convient. Vous pouvez également activer l'évaluation pour Unsloth, mais gardez à l'esprit que cela peut prendre du temps selon la taille du jeu de données. Pour accélérer l'évaluation, vous pouvez : réduire la taille du jeu de données d'évaluation ou définir `evaluation_steps = 100`.

Pour les tests, vous pouvez aussi prendre 20 % de vos données d'entraînement et les utiliser pour les tester. Si vous avez déjà utilisé toutes les données d'entraînement, vous devrez alors les évaluer manuellement. Vous pouvez également utiliser des outils d'évaluation automatiques mais gardez à l'esprit que les outils automatisés peuvent ne pas correspondre parfaitement à vos critères d'évaluation.

## 7. Exécution et déploiement du modèle

Maintenant exécutons le modèle après avoir terminé le processus d'entraînement ! Vous pouvez modifier la partie soulignée en jaune ! En fait, parce que nous avons créé un chatbot multi-tours, nous pouvons désormais également appeler le modèle comme s'il avait vu des conversations passées comme ci-dessous :

<div><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-f2d5f23fa62ec89e06bf20fea433f9a1e42a2fe3%2Fimage.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-cdf5d779635901dce7793df92531dbf3caf0fb0a%2Fimage%20(47).png?alt=media" alt=""><figcaption></figcaption></figure></div>

Rappel : Unsloth lui-même offre **une inférence 2× plus rapide** nativement aussi, donc n'oubliez jamais d'appeler `FastLanguageModel.for_inference(model)`. Si vous voulez que le modèle génère des réponses plus longues, réglez `max_new_tokens = 128` sur un nombre plus grand comme 256 ou 1024. Notez que vous devrez aussi attendre plus longtemps le résultat !

### Sauvegarde et déploiement

Pour sauvegarder et déployer votre modèle dans des moteurs d'inférence souhaités comme Ollama, vLLM, Open WebUI, vous devrez utiliser l'adaptateur LoRA au-dessus du modèle de base. Nous avons des guides dédiés pour chaque framework :

{% content-ref url="../bases/inference-and-deployment" %}
[inference-and-deployment](https://unsloth.ai/docs/fr/bases/inference-and-deployment)
{% endcontent-ref %}

{% columns %}
{% column %}
Si vous exécutez l'inférence sur un seul appareil (comme un ordinateur portable ou un Mac), utilisez llama.cpp pour convertir au format GGUF pour l'utiliser dans Ollama, llama.cpp, LM Studio etc :

{% content-ref url="../bases/inference-and-deployment/saving-to-gguf" %}
[saving-to-gguf](https://unsloth.ai/docs/fr/bases/inference-and-deployment/saving-to-gguf)
{% endcontent-ref %}
{% endcolumn %}

{% column %}
Si vous déployez un LLM pour une inférence d'entreprise ou multi-utilisateurs pour FP8, AWQ, utilisez vLLM :

{% content-ref url="../bases/inference-and-deployment/vllm-guide" %}
[vllm-guide](https://unsloth.ai/docs/fr/bases/inference-and-deployment/vllm-guide)
{% endcontent-ref %}
{% endcolumn %}
{% endcolumns %}

Nous pouvons maintenant sauvegarder le modèle affiné en tant que petit fichier de 100 Mo appelé adaptateur LoRA comme ci-dessous. Vous pouvez aussi le pousser sur le hub Hugging Face si vous voulez téléverser votre modèle ! N'oubliez pas d'obtenir un [token](https://huggingface.co/settings/tokens) Hugging Face

<div><figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-8c577103f7c4fe883cabaf35c8437307c6501686%2Fimage.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-1a1be852ca551240bdce47cf99e6ccd7d31c1326%2Fimage.png?alt=media" alt=""><figcaption></figcaption></figure></div>

et d'ajouter votre token ! `Après avoir sauvegardé le modèle, nous pouvons de nouveau utiliser Unsloth pour exécuter le modèle lui-même ! Utilisez` FastLanguageModel

## à nouveau pour l'appeler en inférence !

8\. C'est terminé !

Vous avez affiné avec succès un modèle de langage et l'avez exporté vers le moteur d'inférence souhaité avec Unsloth ! [Pour en savoir plus sur des astuces et conseils d'affinage, rendez-vous sur nos blogs qui fournissent une valeur éducative et considérable :](https://unsloth.ai/blog/)

<https://unsloth.ai/blog/> [ici](https://discord.gg/unsloth) ou [Si vous avez besoin d'aide pour l'affinage, vous pouvez aussi rejoindre notre serveur Discord](https://www.reddit.com/r/unsloth/)Reddit r/unsloth

<figure><img src="https://550366147-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-69482ba90d417f7bf98dddaf83795cdd3eb20efc%2Fsloth%20sparkling%20square.png?alt=media" alt="" width="188"><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/commencer/fine-tuning-llms-guide.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.