> 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
Guide du débutant pour créer un assistant personnel personnalisé (comme ChatGPT) à exécuter localement sur Ollama
À la fin de ce tutoriel, vous créerez un chatbot personnalisé en **affinant Llama-3** par [**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 `Modelfile` intégrée ! 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** [**notebook Ollama Colab**](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 dégradation de la précision ! Nous utiliserons Google Colab, qui fournit un GPU gratuit pendant ce tutoriel. Vous pouvez accéder à nos notebooks gratuits ci-dessous :
* [Ollama Llama-3 Alpaca](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb) (notebook que nous utiliserons)
* [Guide Ollama CSV/Excel](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 qui peut exécuter en arrière-plan un modèle de langage comme Llama-3. Si vous voulez soudainement poser une question au modèle de langage, vous pouvez simplement 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 notebook Colab, voici une brève introduction au notebook lui-même :
1. **Bouton Lecture dans 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’avez pas exécutée auparavant. Une autre option consiste à cliquer 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 également utiliser ce bouton et cliquer sur « Run all » pour exécuter tout le notebook en une seule fois. Cela sautera toutes les étapes de personnalisation, et peut constituer un bon premier essai.
3. **Bouton Connect / Reconnect T4.** Vous pouvez cliquer ici pour obtenir des statistiques système plus avancées.
La première cellule d’installation ressemble à ceci : pensez à cliquer sur le bouton LECTURE dans les crochets \[ ]. Nous récupérons notre paquet open source GitHub et installons d’autres paquets.
## 4. Sélection d’un modèle à affiner
Sélectionnons maintenant un modèle pour l’affinage ! Nous avons choisi par défaut Llama-3 de Meta / Facebook, qui a été entraîné sur la somme colossale de 15 000 milliards de « tokens ». Supposons qu’un token soit comme un mot anglais. Cela représente environ 350 000 encyclopédies épaisses ! D’autres modèles populaires incluent Mistral, Phi-3 (entraîné à l’aide des sorties de GPT-4) et Gemma de Google (13 000 milliards de tokens !)
Unsloth prend en charge ces modèles et bien d’autres ! En fait, tapez simplement un modèle du hub de modèles Hugging Face pour voir s’il fonctionne ! Nous afficherons une erreur si ce n’est pas le cas.
Il y a 3 autres paramètres que vous pouvez activer ou désactiver :
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 d’un 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 à 2048 à des fins de test. Unsloth prend également en charge l’affinage avec de très longues fenêtres de contexte, et nous montrons que nous pouvons fournir des longueurs de contexte 4x plus longues que les meilleures.
2. ```python
dtype = None
```
Laissez ceci à 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 d’un facteur 4, ce qui nous permet de réellement faire de l’affinage sur un GPU gratuit avec 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 ceci sur False sur des GPU plus puissants comme les H100 si vous voulez ce léger gain de précision.
Si vous exécutez la cellule, vous obtiendrez quelques impressions 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 l’instant.
## 5. Paramètres pour l’affinage
Maintenant, pour personnaliser votre affinage, vous pouvez modifier les nombres ci-dessus, mais vous pouvez aussi les ignorer, car nous avons déjà choisi des valeurs assez raisonnables.
L’objectif 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 ensemble de données au modèle de langage, au point de ne plus pouvoir répondre à de nouvelles questions. Nous voulons qu’un modèle final réponde à des questions inédites, et ne fasse pas de mémorisation.
1. ```python
r = 16, # Choisissez n’importe quel nombre > 0 ! Suggestion : 8, 16, 32, 64, 128
```
Le rang du processus d’affinage. Un nombre plus grand utilise plus de mémoire et sera plus lent, mais peut augmenter la précision sur les tâches plus difficiles. Nous suggérons normalement des nombres comme 8 (pour des affinages rapides), et jusqu’à 128. Des nombres trop élevés peuvent provoquer du surapprentissage et nuire à 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 grand fera apprendre davantage au modèle à partir de votre ensemble de données, mais peut favoriser le surapprentissage. Nous suggérons de le fixer égal au rang `r`, ou de le doubler.
4. ```python
lora_dropout = 0, # Prend en charge n’importe quelle valeur, mais = 0 est optimisé
```
Laissez ceci à 0 pour un entraînement plus rapide ! Peut réduire le surapprentissage, mais pas de beaucoup.
5. ```python
bias = "none", # Prend en charge n’importe quelle valeur, mais = "none" est optimisé
```
Laissez ceci à 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 `Vrai`, `Faux` 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 avec un contexte extrêmement long. Vous pouvez en lire plus ici : pour plus de détails.
7. ```python
random_state = 3407,
```
Le nombre utilisé pour 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 avec stabilisation du rang
```
Fonctionnalité avancée pour définir le `lora_alpha = 16` automatiquement. Vous pouvez utiliser cela si vous le souhaitez !
9. ```python
loftq_config = None, # Et LoftQ
```
Fonctionnalité avancée permettant d’initialiser les matrices LoRA avec les premiers vecteurs singuliers r des poids. Peut améliorer un peu la précision, mais peut faire exploser l’utilisation de la mémoire au début.
## 6. Ensemble de données Alpaca
Nous allons maintenant utiliser l’ensemble de données Alpaca créé en faisant appel à GPT-4 lui-même. Il s’agit d’une liste de 52 000 instructions et sorties, très populaire lors de la sortie de Llama-1, car elle rendait l’affinage d’un LLM de base compétitif avec ChatGPT lui-même.
Vous pouvez accéder ici à la version GPT4 de l’ensemble de données Alpaca : . Une ancienne première version de l’ensemble de données se trouve ici : . Ci-dessous, quelques exemples de l’ensemble 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 une grande invite comme ci-dessous. Nous utilisons ensuite cela pour affiner le modèle de langage, et cela l’a rendu très similaire à ChatGPT. Nous appelons ce processus **l’affinage supervisé par instruction**.
## 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 / une seule invite, et non plusieurs colonnes / entrées. Par exemple, dans ChatGPT, vous pouvez voir que nous devons soumettre une seule invite, et non plusieurs invites.
Cela signifie essentiellement que nous devons « fusionner » plusieurs colonnes en une grande invite pour que l’affinage fonctionne réellement !
Par exemple, le très célèbre ensemble de données Titanic comporte énormément de colonnes. Votre tâche consistait à prédire si un passager avait survécu ou non, en fonction de son âge, de sa classe de passager, du prix du billet, etc. Nous ne pouvons pas simplement envoyer cela à ChatGPT, mais plutôt, nous devons « fusionner » ces informations en une grande invite.
Par exemple, si nous interrogeons ChatGPT avec notre invite unique « fusionnée » qui inclut toutes les informations de 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 vous demandent de préparer manuellement votre ensemble de données pour l’affinage, en fusionnant toutes vos colonnes en une seule invite. Dans Unsloth, nous fournissons simplement la fonction appelée `to_sharegpt` qui fait cela en une seule fois !
Pour accéder au notebook d’affinage Titanic ou si vous voulez téléverser un fichier CSV ou Excel, rendez-vous ici :
Maintenant, c’est un peu plus compliqué, car nous autorisons beaucoup de personnalisation, mais voici quelques points :
* Vous devez entourer toutes les colonnes avec des accolades `{}`. Ce sont les noms des colonnes dans le fichier CSV / Excel réel.
* Les composants de texte facultatifs doivent être entourés de `[[]]`. Par exemple, si la colonne "input" est vide, la fonction de fusion n’affichera pas le texte et l’ignorera. C’est utile pour les ensembles de données avec des valeurs manquantes.
* Sélectionnez la colonne de sortie ou cible / prédiction dans `output_column_name`. Pour l’ensemble de données Alpaca, ce sera `output`.
Par exemple, dans l’ensemble de données Titanic, nous pouvons créer un grand format d’invite fusionnée comme ci-dessous, où chaque colonne / fragment de texte devient facultatif.
Par exemple, imaginez que l’ensemble 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 de 23 ans. Son tarif est **VIDE**.
2. Le passager a embarqué à **VIDE**. Son âge est de 18 ans. Son tarif est de 7,25 $.
Au lieu de cela, en entourant optionnellement les colonnes avec `[[]]`, nous pouvons exclure entièrement cette information.
1. \[\[Le passager a embarqué à S.]] \[\[Son âge est de 23 ans.]] \[\[Son tarif est **VIDE**.]]
2. \[\[Le passager a embarqué à **VIDE**.]] \[\[Son âge est de 18 ans.]] \[\[Son tarif est de 7,25 $.]]
devient :
1. Le passager a embarqué à S. Son âge est de 23 ans.
2. Son âge est de 18 ans. Son tarif est de 7,25 $.
## 8. Conversations à plusieurs tours
Un problème si vous ne l’aviez pas remarqué est que l’ensemble de données Alpaca est à tour unique, alors que rappelez-vous que l’utilisation de ChatGPT était interactive et que vous pouviez lui parler en plusieurs tours. Par exemple, la partie gauche est ce que nous voulons, mais la partie droite, qui est l’ensemble de données Alpaca, ne fournit que des conversations uniques. Nous voulons que le modèle de langage affiné apprenne en quelque sorte à faire des conversations à plusieurs tours, tout comme ChatGPT.
Nous avons donc introduit le `conversation_extension` paramètre, qui sélectionne essentiellement certaines lignes aléatoires dans votre ensemble de données à tour unique, 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 1 ! Les régler trop longtemps peut rendre l’entraînement plus lent, mais cela peut améliorer considérablement votre chatbot et votre affinage final !
Puis réglez `output_column_name` sur la colonne de prédiction / sortie. Pour l’ensemble de données Alpaca, ce serait la colonne output.
Nous utilisons ensuite la fonction `standardize_sharegpt` pour mettre simplement l’ensemble de données dans un format correct pour l’affinage ! Appelez toujours cela !
## 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 ne requièrent qu’une seule invite ? Puisque nous avons fusionné avec succès toutes les colonnes de l’ensemble de données en une seule grâce à Unsloth, nous pouvons essentiellement créer le modèle de chat ci-dessous avec 1 colonne d’entrée (instruction) et 1 sortie :
Nous vous demandons simplement de mettre un `{INPUT}` champ pour l’instruction et un `{OUTPUT}` champ pour le champ de sortie du modèle. Nous autorisons en fait aussi un `{SYSTEM}` champ facultatif, utile pour personnaliser une invite système, tout 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 `{SYSTEM}` champ facultatif, utile pour personnaliser une invite système, tout 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 notebook Colab qui inclut le téléversement de fichiers 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 sur plus d’étapes ou entraîner sur de grandes tailles de lot.
Nous ne suggérons généralement pas de modifier les paramètres ci-dessus, mais pour en expliquer certains :
1. ```python
per_device_train_batch_size = 2,
```
Augmentez la taille du lot si vous souhaitez davantage utiliser la mémoire de votre GPU. Augmentez également cela pour rendre l’entraînement plus fluide et éviter que le processus ne surapprenne. Nous ne le suggérons généralement pas, car cela peut en fait rendre l’entraînement plus lent à cause des problèmes de padding. Nous vous demandons normalement plutôt d’augmenter `gradient_accumulation_steps` ce qui fait simplement davantage de passages sur l’ensemble de données.
2. ```python
gradient_accumulation_steps = 4,
```
Équivalent à l’augmentation de la taille du lot elle-même, mais sans impact sur la consommation de mémoire ! Nous suggérons généralement d’augmenter cela si vous voulez des courbes de perte d’entraînement plus lisses.
3. ```python
max_steps = 60, # num_train_epochs = 1,
```
Nous avons fixé le nombre d’étapes à 60 pour un entraînement plus rapide. Pour des entraînements complets qui peuvent durer des heures, commentez plutôt `max_steps`, et remplacez-le par `num_train_epochs = 1`. Le fixer à 1 signifie 1 passage complet sur votre ensemble de données. Nous suggérons généralement 1 à 3 passages, et pas plus, sinon vous surapprendrez votre affinage.
4. ```python
learning_rate = 2e-4,
```
Réduisez le taux d’apprentissage si vous voulez ralentir le processus d’affinage, mais aussi converger très probablement vers un résultat de meilleure précision. Nous suggérons généralement d’essayer 2e-4, 1e-4, 5e-5, 2e-5.
Vous verrez un journal de chiffres pendant l’entraînement. Il s’agit de la perte d’entraînement, qui montre à quel point le modèle apprend à partir de votre ensemble 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 ensemble de données et de votre tâche. Si la perte ne diminue pas, vous devrez peut-être ajuster vos paramètres. Si la perte tombe à 0, cela pourrait signifier du 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, comme nous avons créé un chatbot à plusieurs tours, nous pouvons maintenant aussi appeler le modèle comme s’il avait vu certaines conversations dans le passé comme ci-dessous :
Rappel : Unsloth fournit lui-même **une inférence 2x plus rapide** nativement aussi, 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 un nombre plus grand comme 256 ou 1024. Notez que vous devrez aussi attendre plus longtemps pour le résultat !
## 12. Sauvegarder le modèle
Nous pouvons maintenant sauvegarder le modèle affiné sous forme d’un petit fichier de 100 Mo appelé adaptateur LoRA comme ci-dessous. Vous pouvez aussi le pousser vers le hub Hugging Face si vous voulez téléverser votre modèle ! N’oubliez pas d’obtenir un jeton Hugging Face via et d’ajouter 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é vers les formats GGUF de llama.cpp comme ci-dessous :
Rappel : convertir `Faux` à `Vrai` pour une ligne, et ne pas changer chaque ligne en `Vrai`, sinon vous devrez attendre très longtemps ! Nous recommandons généralement de mettre la première ligne sur `Vrai`, afin de pouvoir exporter rapidement le modèle affiné vers `Q8_0` le format (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 aussi des instructions manuelles sur la façon d’exporter vers GGUF si vous le souhaitez ici :
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` car Colab n’aime pas les appels asynchrones, mais normalement on exécute simplement `ollama serve` dans le terminal / l’invite de commandes.
## 14. Automatique `Modelfile` création
L’astuce qu’Unsloth fournit est que nous créons automatiquement un `Modelfile` qu’Ollama exige ! Il s’agit simplement d’une liste de paramètres et elle inclut le template de conversation que nous avons utilisé pour le processus de fine-tuning ! Vous pouvez aussi afficher le `Modelfile` généré comme ci-dessous :
Nous demandons ensuite à Ollama de créer un modèle compatible avec Ollama, en utilisant le `Modelfile`
## 15. Inférence Ollama
Et nous pouvons maintenant appeler le modèle pour l’inférence si vous voulez appeler le serveur Ollama lui-même, qui s’exécute en arrière-plan sur votre propre machine locale / dans le notebook Colab gratuit. N’oubliez pas que vous pouvez modifier la partie soulignée en jaune.
## 16. Chat interactif de style ChatGPT
Mais pour exécuter réellement le modèle affiné comme un ChatGPT, nous devons faire un peu plus ! Cliquez d’abord 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 avez réussi !
Vous avez affiné avec succès un modèle de langage et l’avez exporté vers Ollama avec Unsloth 2x plus rapide et 70 % de VRAM en moins ! Et tout cela gratuitement dans un notebook Google Colab !
Si vous voulez apprendre à faire du reward modelling, du continued pretraining, exporter vers vLLM ou GGUF, faire de la complétion de texte, ou en apprendre plus 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 également rejoindre notre serveur Discord [ici](https://discord.gg/unsloth). Si vous voulez de l’aide avec Ollama, vous pouvez également rejoindre leur serveur [ici](https://discord.gg/ollama).
Enfin, nous voulons 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 d’ensemble 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 by asking a question.
Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:
```
GET https://unsloth.ai/docs/fr/commencer/fine-tuning-llms-guide/tutorial-how-to-finetune-llama-3-and-use-in-ollama.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
.png?alt=media)
.png?alt=media)
.png?alt=media)
