> 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/fine-tuning-llms-guide/tutorial-how-to-finetune-llama-3-and-use-in-ollama.md).
# Tutoriel : comment fine-tuner Llama-3 et l'utiliser dans Ollama
À la fin de ce tutoriel, vous créerez un chatbot personnalisé en **affinant Llama-3** avec [**Unsloth**](https://github.com/unslothai/unsloth) gratuitement. Il peut s’exécuter localement via [**Ollama**](https://github.com/ollama/ollama) sur votre PC, ou dans une instance GPU gratuite via [**Google Colab**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb). Vous pourrez interagir avec le chatbot de manière interactive comme ci-dessous :
**Unsloth** rend l’affinage beaucoup plus facile, et peut exporter automatiquement le modèle affiné vers **Ollama** avec création automatique intégrée de `Modelfile` ! Si vous avez besoin d’aide, vous pouvez rejoindre notre serveur Discord :
{% hint style="warning" %}
**Si vous souhaitez copier ou enregistrer le code, tout est disponible dans notre** [**cahier Colab Ollama**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb)**. Vous pouvez l’utiliser directement là-bas ou l’adapter à votre configuration locale :** [**https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3\_(8B)-Ollama.ipynb**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb)
{% endhint %}
## 1. Qu’est-ce qu’Unsloth ?
[Unsloth](https://github.com/unslothai/unsloth) rend l’affinage des LLM comme Llama-3, Mistral, Phi-3 et Gemma 2x plus rapide, utilise 70 % de mémoire en moins, et sans aucune dégradation de la précision ! Nous utiliserons Google Colab, qui fournit un GPU gratuit pendant ce tutoriel. Vous pouvez accéder à nos cahiers gratuits ci-dessous :
* [Ollama Llama-3 Alpaca](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb) (cahier que nous utiliserons)
* [Guide CSV/Excel Ollama](https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing)
#### ***Vous devrez également vous connecter à votre compte Google !***
## 2. Qu’est-ce qu’Ollama ?
[Ollama ](https://github.com/ollama/ollama)vous permet d’exécuter des modèles de langage depuis votre propre ordinateur de manière rapide et simple ! Il lance discrètement un programme pouvant exécuter un modèle de langage comme Llama-3 en arrière-plan. Si vous souhaitez soudainement poser une question au modèle de langage, il vous suffit d’envoyer une requête à Ollama, et il vous renverra rapidement les résultats ! Nous utiliserons Ollama comme moteur d’inférence !
## 3. Installer Unsloth
Si vous n’avez jamais utilisé un cahier Colab, voici une brève introduction au cahier lui-même :
1. **Bouton Lecture sur chaque « cellule ».** Cliquez dessus pour exécuter le code de cette cellule. Vous ne devez sauter aucune cellule et vous devez exécuter chaque cellule dans l’ordre chronologique. Si vous rencontrez des erreurs, relancez simplement la cellule que vous n’aviez pas exécutée auparavant. Vous pouvez aussi appuyer sur CTRL + ENTRÉE si vous ne voulez pas cliquer sur le bouton Lecture.
2. **Bouton Runtime dans la barre d’outils supérieure.** Vous pouvez aussi utiliser ce bouton et cliquer sur « Run all » pour exécuter tout le cahier en une seule fois. Cela sautera toutes les étapes de personnalisation, et peut être un bon premier essai.
3. **Bouton Connecter / Reconnecter T4.** Vous pouvez cliquer ici pour des statistiques système plus avancées.
La première cellule d’installation ressemble à ceci : n’oubliez pas de cliquer sur le bouton LECTURE dans les crochets \[ ]. Nous récupérons notre paquet open source Github, et installons quelques autres paquets.
## 4. Sélectionner un modèle à affiner
Sélectionnons maintenant un modèle à affiner ! Nous avons choisi par défaut Llama-3 de Meta / Facebook, qui a été entraîné sur la bagatelle de 15 000 milliards de « jetons ». Supposons qu’un jeton soit comme un mot anglais. Cela représente environ 350 000 encyclopédies épaisses ! Parmi les autres modèles populaires figurent Mistral, Phi-3 (entraîné à l’aide des sorties de GPT-4) et Gemma de Google (13 000 milliards de jetons !).
Unsloth prend en charge ces modèles et bien plus encore ! En fait, tapez simplement un modèle du hub de modèles Hugging Face pour voir s’il fonctionne ! Nous afficherons une erreur si cela ne fonctionne pas.
Il y a 3 autres paramètres que vous pouvez modifier :
1. ```python
max_seq_length = 2048
```
Cela détermine la longueur de contexte du modèle. Gemini, par exemple, a une longueur de contexte de plus de 1 million, tandis que Llama-3 a une longueur de contexte de 8192. Nous vous permettons de sélectionner N’IMPORTE quel nombre — mais nous recommandons de le régler sur 2048 à des fins de test. Unsloth prend également en charge l’affinage sur des contextes très longs, et nous montrons que nous pouvons fournir des longueurs de contexte 4x plus longues que le meilleur.
2. ```python
dtype = None
```
Conservez cette valeur à None, mais vous pouvez sélectionner torch.float16 ou torch.bfloat16 pour les GPU plus récents.
3. ```python
load_in_4bit = True
```
Nous effectuons l’affinage en quantification 4 bits. Cela réduit l’utilisation de la mémoire par 4x, ce qui nous permet réellement d’effectuer l’affinage sur un GPU gratuit de 16 Go de mémoire. La quantification 4 bits convertit essentiellement les poids en un ensemble limité de nombres afin de réduire l’utilisation de la mémoire. L’inconvénient est une dégradation de la précision de 1 à 2 %. Réglez cette valeur sur False sur des GPU plus puissants comme les H100 si vous souhaitez ce petit gain supplémentaire en précision.
Si vous exécutez la cellule, vous obtiendrez quelques affichages de la version d’Unsloth, du modèle que vous utilisez, de la quantité de mémoire de votre GPU, et d’autres statistiques. Ignorez cela pour le moment.
## 5. Paramètres d’affinage
Pour personnaliser maintenant votre affinage, vous pouvez modifier les nombres ci-dessus, mais vous pouvez l’ignorer, car nous sélectionnons déjà des valeurs tout à fait raisonnables.
Le but est de modifier ces nombres pour augmenter la précision, mais aussi **de contrer le surapprentissage**. Le surapprentissage se produit lorsque vous faites mémoriser à un modèle de langage un jeu de données, au lieu de lui permettre de répondre à de nouvelles questions inédites. Nous voulons qu’un modèle final réponde à des questions non vues, et non qu’il mémorise.
1. ```python
r = 16, # Choisissez n’importe quel nombre > 0 ! Suggestions : 8, 16, 32, 64, 128
```
Le rang du processus d’affinage. Un nombre plus élevé utilise plus de mémoire et sera plus lent, mais peut augmenter la précision sur des tâches plus difficiles. Nous suggérons généralement des nombres comme 8 (pour des affinages rapides), et jusqu’à 128. Des nombres trop élevés peuvent provoquer un surapprentissage, nuisant à la qualité de votre modèle.
2. ```python
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj",],
```
Nous sélectionnons tous les modules à affiner. Vous pouvez en retirer certains pour réduire l’utilisation de la mémoire et accélérer l’entraînement, mais nous le déconseillons fortement. Entraînez simplement tous les modules !
3. ```python
lora_alpha = 16,
```
Le facteur d’échelle pour l’affinage. Un nombre plus élevé fera apprendre davantage le jeu de données à l’affinage, mais peut favoriser le surapprentissage. Nous suggérons de le fixer égal au rang `r`ou le doubler.
4. ```python
lora_dropout = 0, # Prend en charge n’importe quelle valeur, mais = 0 est optimisé
```
Laissez cette valeur à 0 pour un entraînement plus rapide ! Peut réduire le surapprentissage, mais pas beaucoup.
5. ```python
bias = "none", # Prend en charge n’importe quelle valeur, mais = "none" est optimisé
```
Laissez cette valeur à 0 pour un entraînement plus rapide et avec moins de surapprentissage !
6. ```python
use_gradient_checkpointing = "unsloth", # True ou "unsloth" pour un contexte très long
```
Les options incluent `True`, `False` et `"unsloth"`. Nous suggérons `"unsloth"` car nous réduisons l’utilisation de la mémoire de 30 % supplémentaires et prenons en charge des affinages sur des contextes extrêmement longs. Vous pouvez en lire plus ici : pour plus de détails.
7. ```python
random_state = 3407,
```
Le nombre permettant de déterminer des exécutions déterministes. L’entraînement et l’affinage nécessitent des nombres aléatoires, donc définir ce nombre rend les expériences reproductibles.
8. ```python
use_rslora = False, # Nous prenons en charge LoRA stabilisé par rang
```
Fonction avancée pour définir `lora_alpha = 16` automatiquement. Vous pouvez utiliser cela si vous le souhaitez !
9. ```python
loftq_config = None, # Et LoftQ
```
Fonction avancée pour initialiser les matrices LoRA avec les vecteurs singuliers principaux r des poids. Peut améliorer quelque peu la précision, mais peut faire exploser l’utilisation de la mémoire au départ.
## 6. Jeu de données Alpaca
Nous allons maintenant utiliser le jeu de données Alpaca créé en appelant GPT-4 lui-même. Il s’agit d’une liste de 52 000 instructions et sorties, qui était très populaire lors de la sortie de Llama-1, car elle permettait à un LLM de base affiné d’être compétitif avec ChatGPT lui-même.
Vous pouvez accéder ici à la version GPT4 du jeu de données Alpaca : . Une version plus ancienne du jeu de données se trouve ici : . Ci-dessous figurent quelques exemples du jeu de données :
Vous pouvez voir qu’il y a 3 colonnes dans chaque ligne — une instruction, une entrée et une sortie. Nous combinons essentiellement chaque ligne en un grand prompt comme ci-dessous. Nous l’utilisons ensuite pour affiner le modèle de langage, et cela l’a rendu très similaire à ChatGPT. Nous appelons ce processus **l’affinage supervisé par instructions**.
## 7. Plusieurs colonnes pour l’affinage
Mais un gros problème est que pour les assistants de type ChatGPT, nous n’autorisons qu’une seule instruction / un seul prompt, et non plusieurs colonnes / entrées. Par exemple dans ChatGPT, on voit qu’il faut soumettre 1 prompt, et non plusieurs prompts.
Cela signifie essentiellement que nous devons « fusionner » plusieurs colonnes en un seul grand prompt pour que l’affinage fonctionne réellement !
Par exemple, le très célèbre jeu de données Titanic comporte de nombreuses colonnes. Votre tâche consistait à prédire si un passager a survécu ou est mort en fonction de son âge, de sa classe de passager, du prix du billet, etc. Nous ne pouvons pas simplement envoyer cela à ChatGPT, mais nous devons plutôt « fusionner » ces informations en un seul grand prompt.
Par exemple, si nous interrogeons ChatGPT avec notre unique prompt « fusionné » qui inclut toutes les informations concernant ce passager, nous pouvons alors lui demander de deviner ou de prédire si le passager est mort ou a survécu.
D’autres bibliothèques d’affinage exigent que vous prépariez manuellement votre jeu de données pour l’affinage, en fusionnant toutes vos colonnes en un seul prompt. Dans Unsloth, nous fournissons simplement la fonction appelée `to_sharegpt` qui fait cela en une seule fois !
Pour accéder au cahier d’affinage Titanic ou si vous souhaitez téléverser un fichier CSV ou Excel, allez ici :
C’est maintenant un peu plus compliqué, car nous permettons beaucoup de personnalisation, mais il y a quelques points :
* Vous devez encadrer toutes les colonnes avec des accolades `{}`. Ce sont les noms de colonnes dans le fichier CSV / Excel réel.
* Les composants textuels facultatifs doivent être encadrés par `[[]]`. Par exemple, si la colonne "input" est vide, la fonction de fusion n’affichera pas le texte et passera cet élément. C’est utile pour les jeux de données contenant des valeurs manquantes.
* Sélectionnez la colonne de sortie ou la colonne cible / prédiction dans `output_column_name`. Pour le jeu de données Alpaca, ce sera `output`.
Par exemple, dans le jeu de données Titanic, nous pouvons créer un grand format de prompt fusionné comme ci-dessous, où chaque colonne / fragment de texte devient facultatif.
Par exemple, imaginez que le jeu de données ressemble à ceci avec beaucoup de données manquantes :
| Embarqué | Âge | Tarif |
| -------- | --- | ----- |
| S | 23 | |
| | 18 | 7.25 |
Alors, nous ne voulons pas que le résultat soit :
1. Le passager a embarqué à S. Son âge est 23. Son tarif est **VIDE**.
2. Le passager a embarqué à **VIDE**. Son âge est 18. Son tarif est 7,25 $.
Au lieu de cela, en encadrant facultativement les colonnes avec `[[]]`, nous pouvons exclure entièrement cette information.
1. \[\[Le passager a embarqué à S.]] \[\[Son âge est 23.]] \[\[Son tarif est **VIDE**.]]
2. \[\[Le passager a embarqué à **VIDE**.]] \[\[Son âge est 18.]] \[\[Son tarif est 7,25 $.]]
devient :
1. Le passager a embarqué à S. Son âge est 23.
2. Son âge est 18. Son tarif est 7,25 $.
## 8. Conversations multi-tours
Un problème, si vous ne l’avez pas remarqué, est que le jeu de données Alpaca est en un seul tour, alors que souvenez-vous que l’utilisation de ChatGPT était interactive et que vous pouviez lui parler en plusieurs tours. Par exemple, à gauche se trouve ce que nous voulons, mais à droite, qui est le jeu de données Alpaca, ne fournit que des conversations uniques. Nous voulons que le modèle de langage affiné apprenne d’une manière ou d’une autre à faire des conversations multi-tours, tout comme ChatGPT.
Nous avons donc introduit le `conversation_extension` paramètre, qui sélectionne essentiellement certaines lignes aléatoires dans votre jeu de données à un seul tour, et les fusionne en une seule conversation ! Par exemple, si vous le réglez sur 3, nous sélectionnons aléatoirement 3 lignes et les fusionnons en une seule ! Les définir trop long peut rendre l’entraînement plus lent, mais peut rendre votre chatbot et votre affinage final bien meilleurs !
Puis réglez `output_column_name` sur la colonne de prédiction / sortie. Pour le jeu de données Alpaca, ce serait la colonne de sortie.
Nous utilisons ensuite la fonction `standardize_sharegpt` pour simplement mettre le jeu de données dans un format correct pour l’affinage ! Appelez toujours cette fonction !
## 9. Modèles de chat personnalisables
Nous pouvons maintenant spécifier le modèle de chat pour l’affinage lui-même. Le très célèbre format Alpaca est ci-dessous :
Mais rappelez-vous que nous avons dit que c’était une mauvaise idée, car les affinages de type ChatGPT nécessitent seulement 1 prompt ? Puisque nous avons réussi à fusionner toutes les colonnes du jeu de données en une seule grâce à Unsloth, nous pouvons essentiellement créer le modèle de chat de style ci-dessous avec 1 colonne d’entrée (instruction) et 1 sortie :
Nous exigeons simplement que vous mettiez un `{INPUT}` champ pour l’instruction et un `{OUTPUT}` champ pour le champ de sortie du modèle. En fait, nous autorisons aussi un champ `{SYSTEM}` facultatif, utile pour personnaliser un prompt système comme dans ChatGPT. Par exemple, voici quelques exemples sympas pour lesquels vous pouvez personnaliser le modèle de chat :
Pour le format ChatML utilisé dans les modèles OpenAI :
Ou vous pouvez utiliser le modèle Llama-3 lui-même (qui ne fonctionne qu’en utilisant la version instruct de Llama-3) : Nous autorisons en fait aussi un champ `{SYSTEM}` facultatif, utile pour personnaliser un prompt système comme dans ChatGPT.
Ou dans la tâche de prédiction Titanic où vous deviez prédire si un passager est mort ou a survécu dans ce cahier Colab qui inclut le téléversement CSV et Excel :
## 10. Entraîner le modèle
Entraînons maintenant le modèle ! Nous suggérons généralement de ne pas modifier ce qui suit, sauf si vous souhaitez affiner pendant plus d’étapes ou entraîner avec de grandes tailles de lot.
Nous ne suggérons généralement pas de modifier les paramètres ci-dessus, mais pour expliquer certains d’entre eux :
1. ```python
per_device_train_batch_size = 2,
```
Augmentez la taille de lot si vous souhaitez mieux utiliser la mémoire de votre GPU. Augmentez-la aussi pour rendre l’entraînement plus fluide et éviter le surapprentissage. Nous ne le suggérons généralement pas, car cela peut en réalité ralentir l’entraînement à cause des problèmes de remplissage. Nous vous demandons généralement plutôt d’augmenter `gradient_accumulation_steps` qui effectue simplement davantage de passes sur le jeu de données.
2. ```python
gradient_accumulation_steps = 4,
```
Équivalent à augmenter la taille de lot ci-dessus elle-même, mais sans impact sur la consommation de mémoire ! Nous suggérons généralement d’augmenter cela si vous souhaitez des courbes de perte d’entraînement plus fluides.
3. ```python
max_steps = 60, # num_train_epochs = 1,
```
Nous définissons les étapes à 60 pour un entraînement plus rapide. Pour des entraînements complets qui peuvent prendre des heures, commentez plutôt `max_steps`, et remplacez-le par `num_train_epochs = 1`. Le régler à 1 signifie un passage complet sur votre jeu de données. Nous suggérons généralement 1 à 3 passages, pas plus, sinon vous surapprendrez votre affinage.
4. ```python
learning_rate = 2e-4,
```
Réduisez le taux d’apprentissage si vous souhaitez ralentir le processus d’affinage, mais aussi probablement converger vers un résultat de meilleure précision. Nous suggérons généralement comme valeurs à essayer 2e-4, 1e-4, 5e-5, 2e-5.
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 bien à partir de votre jeu de données. Dans beaucoup de cas, une perte autour de 0,5 à 1,0 est bon signe, mais cela dépend de votre jeu de données et de votre tâche. Si la perte ne baisse pas, vous devrez peut-être ajuster vos paramètres. Si la perte tombe à 0, cela peut signifier un surapprentissage, donc il est important de vérifier aussi la validation.
## 11. Inférence / exécution 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 maintenant aussi appeler le modèle comme s’il avait vu des conversations dans le passé, comme ci-dessous :
Rappel : Unsloth fournit lui-même **une inférence 2x plus rapide** nativement également, donc n’oubliez jamais d’appeler `FastLanguageModel.for_inference(model)`. Si vous voulez que le modèle produise des réponses plus longues, réglez `max_new_tokens = 128` sur une valeur plus grande comme 256 ou 1024. Notez que vous devrez aussi attendre plus longtemps pour le résultat !
## 12. Enregistrer le modèle
Nous pouvons maintenant enregistrer le modèle affiné sous la forme d’un petit fichier de 100 Mo appelé adaptateur LoRA, comme ci-dessous. Vous pouvez également le pousser vers le hub Hugging Face si vous souhaitez téléverser votre modèle ! N’oubliez pas d’obtenir un jeton Hugging Face via et ajoutez votre jeton !
Après avoir enregistré le modèle, nous pouvons à nouveau utiliser Unsloth pour exécuter le modèle lui-même ! Utilisez `FastLanguageModel` à nouveau pour l’appeler en inférence !
## 13. Exporter vers Ollama
Enfin, nous pouvons exporter notre modèle affiné vers Ollama lui-même ! D’abord, nous devons installer Ollama dans le notebook Colab :
Ensuite, nous exportons le modèle affiné que nous devons convertir aux formats GGUF de llama.cpp comme ci-dessous :
Rappel de convertir `False` en `True` pour 1 ligne, et ne pas changer chaque ligne en `True`, sinon vous allez attendre très longtemps ! Nous recommandons normalement de définir la première ligne sur `True`, afin que nous puissions exporter rapidement le modèle affiné vers le format `Q8_0` (quantification en 8 bits). Nous vous permettons également d’exporter vers toute une liste de méthodes de quantification, l’une des plus populaires étant `q4_k_m`.
Rendez-vous sur pour en savoir plus sur GGUF. Nous avons également ici des instructions manuelles sur la façon d’exporter vers GGUF si vous le souhaitez :
Vous verrez une longue liste de texte comme ci-dessous - veuillez attendre 5 à 10 minutes !!
Et enfin, tout à la fin, cela ressemblera à ceci :
Ensuite, nous devons exécuter Ollama lui-même en arrière-plan. Nous utilisons `subprocess` parce que Colab n’aime pas les appels asynchrones, mais normalement on exécute simplement `ollama serve` dans le terminal / l’invite de commande.
## 14. Automatique `Modelfile` création
L’astuce qu’Unsloth fournit est que nous créons automatiquement un `Modelfile` dont Ollama a besoin ! C’est simplement une liste de paramètres et elle inclut le modèle de chat que nous avons utilisé pour le processus de fine-tuning ! Vous pouvez aussi afficher le `Modelfile` généré comme ci-dessous :
Ensuite, nous demandons à Ollama de créer un modèle compatible avec Ollama, en utilisant `Modelfile`
## 15. Inférence Ollama
Et nous pouvons maintenant appeler le modèle en inférence si vous voulez appeler le serveur Ollama lui-même, qui s’exécute sur votre propre machine locale / dans le notebook Colab gratuit en arrière-plan. N’oubliez pas que vous pouvez modifier la partie jaune soulignée.
## 16. Chat interactif de style ChatGPT
Mais pour réellement exécuter le modèle affiné comme un ChatGPT, nous devons faire un peu plus ! D’abord, cliquez sur l’icône du terminal et un terminal apparaîtra. Il se trouve dans la barre latérale gauche.
Ensuite, vous devrez peut-être appuyer deux fois sur ENTRÉE pour supprimer une sortie étrange dans la fenêtre du terminal. Attendez quelques secondes et tapez `ollama run unsloth_model` puis appuyez sur ENTRÉE.
Et enfin, vous pouvez interagir avec le modèle affiné comme avec un vrai ChatGPT ! Appuyez sur CTRL + D pour quitter le système, puis sur ENTRÉE pour converser avec le chatbot !
## Vous l’avez fait !
Vous avez réussi à affiner un modèle de langage et à l’exporter vers Ollama avec Unsloth 2x plus rapide et avec 70 % de VRAM en moins ! Et tout cela gratuitement dans un cahier Google Colab !
Si vous voulez apprendre à faire du modelage de récompense, du pré-entraînement continu, à exporter vers vLLM ou GGUF, à faire de la complétion de texte, ou à en apprendre davantage sur les astuces et conseils d’affinage, rendez-vous sur notre [Github](https://github.com/unslothai/unsloth#-finetune-for-free).
Si vous avez besoin d’aide pour l’affinage, vous pouvez aussi rejoindre notre serveur Discord [ici](https://discord.gg/unsloth). Si vous voulez de l’aide avec Ollama, vous pouvez aussi rejoindre leur serveur [ici](https://discord.gg/ollama).
Et enfin, nous tenons à vous remercier d’avoir lu et suivi jusqu’ici ! Nous espérons que cela vous a aidé à comprendre certains des rouages de l’affinage des modèles de langage, et nous espérons que cela vous a été utile !
Pour accéder à notre exemple de jeu de données Alpaca, cliquez [ici](https://colab.research.google.com/drive/1WZDi7APtQ9VsvOrQSSC5DDtxq159j8iZ?usp=sharing), et notre guide d’affinage CSV / Excel est [ici](https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing).
---
# 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 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/tutorial-how-to-finetune-llama-3-and-use-in-ollama.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.