# Tutoriel : comment affiner 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 une création automatique intégrée du `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** [**notebook 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 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 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 qui peut exécuter en arrière-plan un modèle de langage comme Llama-3. Si vous souhaitez 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 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. Une autre option consiste à 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 notebook en une seule fois. Cela sautera toutes les étapes de personnalisation, et peut être 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 : 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élection d’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 somme colossale de 15 billions de « tokens ». Imaginez qu’un token corresponde à peu près à 1 mot anglais. Cela représente environ 350 000 encyclopédies épaisses ! Parmi les autres modèles populaires, on trouve Mistral, Phi-3 (entraîné à l’aide des sorties de GPT-4) et Gemma de Google (13 billions de tokens !).
Unsloth prend en charge ces modèles et bien d’autres ! En fait, il suffit de saisir un modèle du hub de modèles Hugging Face pour voir s’il fonctionne ! Nous afficherons une erreur s’il ne fonctionne pas.
Il existe 3 autres paramètres que vous pouvez activer/désactiver :
1. ```
max_seq_length = 2048
```
Cela détermine la longueur du 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 sur de très longs contextes, et nous montrons que nous pouvons fournir des longueurs de contexte 4x plus longues que le meilleur.
2. ```
dtype = None
```
Laissez cela à None, mais vous pouvez sélectionner torch.float16 ou torch.bfloat16 pour les GPU plus récents.
3. ```
load_in_4bit = True
```
Nous effectuons l’affinage en quantification 4 bits. Cela réduit l’utilisation de mémoire d’un facteur 4, ce qui nous permet en pratique d’effectuer 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 mémoire. L’inconvénient est une dégradation de la précision de 1 à 2 %. Réglez cela sur False sur des GPU plus puissants comme les H100 si vous voulez ce tout petit supplément 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 dont dispose votre GPU et de quelques autres statistiques. Ignorez cela pour le moment.
## 5. Paramètres pour l’affinage
Pour personnaliser votre affinage, vous pouvez maintenant modifier les nombres ci-dessus, mais vous pouvez les ignorer, car nous en avons déjà sélectionné des tout à fait raisonnables.
Le but est de modifier ces nombres pour augmenter la précision, mais aussi **de contrebalancer le surapprentissage**. Le surapprentissage se produit lorsque vous faites mémoriser au 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 jamais vues, et ne fasse pas de mémorisation.
1. ```
r = 16, # Choisissez n’importe quel nombre > 0 ! Recommandé : 8, 16, 32, 64, 128
```
Le rang du processus d’affinage. Un nombre plus élevé utilise davantage 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), jusqu’à 128. Des nombres trop élevés peuvent provoquer du surapprentissage et dégrader la qualité de votre modèle.
2. ```
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 mémoire et accélérer l’entraînement, mais nous le déconseillons fortement. Entraînez simplement tous les modules !
3. ```
lora_alpha = 16,
```
Le facteur d’échelle pour l’affinage. Un nombre plus élevé fera en sorte que l’affinage apprenne davantage de votre jeu de données, mais peut favoriser le surapprentissage. Nous suggérons de le fixer à la même valeur que le rang `r`, ou au double.
4. ```notebook-python
lora_dropout = 0, # Prend en charge toute valeur, mais = 0 est optimisé
```
Laissez cela à 0 pour un entraînement plus rapide ! Peut réduire le surapprentissage, mais pas de beaucoup.
5. ```
bias = "none", # Prend en charge toute valeur, mais = "none" est optimisé
```
Laissez cela à 0 pour un entraînement plus rapide et avec moins de surapprentissage !
6. ```
use_gradient_checkpointing = "unsloth", # True ou "unsloth" pour de très longs contextes
```
Les options incluent `True`, `False` et `"unsloth"`. Nous recommandons `"unsloth"` car nous réduisons l’utilisation de mémoire de 30 % supplémentaires et prenons en charge des affinages sur des contextes extrêmement longs. Vous pouvez en savoir plus ici : pour plus de détails.
7. ```
random_state = 3407,
```
Le nombre permettant de déterminer les 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. ```
use_rslora = False, # Nous prenons en charge LoRA avec rang stabilisé
```
Fonction avancée pour définir automatiquement `lora_alpha = 16` . Vous pouvez l’utiliser si vous le souhaitez !
9. ```
loftq_config = None, # Et LoftQ
```
Fonction avancée pour initialiser les matrices LoRA sur les premiers vecteurs singuliers r des poids. Peut améliorer quelque peu la précision, mais peut faire exploser l’utilisation de mémoire au début.
## 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é de rivaliser avec ChatGPT lui-même.
Vous pouvez accéder ici à la version GPT4 du jeu de données Alpaca : . Une première version plus ancienne du jeu de données se trouve ici : . Ci-dessous, 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 seul grand prompt comme ci-dessous. Nous utilisons ensuite cela pour affiner le modèle de langage, ce qui l’a rendu très similaire à ChatGPT. Nous appelons ce processus **l’affinage supervisé par instructions**.
## 7. Colonnes multiples 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, vous pouvez voir que nous devons soumettre un seul 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 travail consistait à prédire si un passager avait survécu ou était mort en fonction de son âge, de sa classe passager, du prix du billet, etc. Nous ne pouvons pas simplement injecter cela dans 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 de ce passager, nous pouvons ensuite 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 notebook 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 autorisons beaucoup de personnalisation, mais il y a quelques points :
* Vous devez entourer 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 entourés par `[[]]`. Par exemple, si la colonne "input" est vide, la fonction de fusion n’affichera pas le texte et passera cette partie. C’est utile pour les jeux de données comportant des valeurs manquantes.
* Sélectionnez la colonne de sortie ou 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 / morceau de texte devient facultatif.
Par exemple, imaginons que le jeu de données ressemble à cela 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 éventuellement les colonnes à l’aide de `[[]]`, nous pouvons exclure complètement 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’avez pas remarqué, est que le jeu de données Alpaca est à tour unique, alors qu’avec ChatGPT l’interaction est conversationnelle et vous pouvez lui parler en plusieurs tours. Par exemple, à gauche se trouve ce que nous voulons, mais à droite, le jeu de données Alpaca ne fournit que des conversations uniques. Nous voulons que le modèle affiné apprenne d’une manière ou d’une autre à mener des conversations à plusieurs tours, tout comme ChatGPT.
Nous avons donc introduit le `conversation_extension` paramètre, qui sélectionne essentiellement quelques lignes aléatoires dans votre jeu 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 une seule ! Le régler trop haut peut ralentir l’entraînement, mais pourrait rendre votre chatbot et votre affinage final bien meilleurs !
Puis définissez `output_column_name` sur la colonne de prédiction / sortie. Pour le jeu de données Alpaca, ce serait la colonne output.
Nous utilisons ensuite la fonction `standardize_sharegpt` pour simplement mettre le jeu de données dans un format correct pour l’affinage ! Appelez-la toujours !
## 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 souvenez-vous que nous avons dit que c’était une mauvaise idée parce que les affinages de type ChatGPT ne nécessitent qu’un seul prompt ? Comme 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 ci-dessous avec 1 colonne d’entrée (instruction) et 1 sortie :
Nous demandons simplement que vous mettiez un champ `{INPUT}` pour l’instruction et un champ `{OUTPUT}` pour le champ de sortie du modèle. Nous autorisons en fait également un champ facultatif `{SYSTEM}` qui est utile pour personnaliser un prompt système, tout comme dans ChatGPT. Par exemple, ci-dessous se trouvent quelques exemples sympas de personnalisation du 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 également un champ facultatif `{SYSTEM}` qui est également utile pour personnaliser un prompt 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 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 les paramètres ci-dessous, sauf si vous souhaitez affiner pendant plus d’étapes ou entraîner avec de grandes tailles de batch.
Nous ne suggérons généralement pas de modifier les paramètres ci-dessus, mais pour en expliquer certains :
1. ```
per_device_train_batch_size = 2,
```
Augmentez la taille du batch si vous souhaitez davantage 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 padding. Nous vous demandons plutôt d’augmenter `gradient_accumulation_steps` ce qui effectue simplement davantage de passes sur le jeu de données.
2. ```
gradient_accumulation_steps = 4,
```
Équivalent à augmenter la taille du batch ci-dessus, mais sans impact sur la consommation de mémoire ! Nous suggérons généralement d’augmenter ce paramètre si vous voulez des courbes de perte d’entraînement plus fluides.
3. ```
max_steps = 60, # num_train_epochs = 1,
```
Nous fixons le nombre d’étapes à 60 pour un entraînement plus rapide. Pour des exécutions d’entraînement complètes qui peuvent prendre des heures, commentez plutôt `max_steps`, et remplacez-le par `num_train_epochs = 1`. Le régler sur 1 signifie 1 passe complète sur votre jeu de données. Nous suggérons généralement 1 à 3 passes, pas plus, sinon vous allez suradapter votre affinage.
4. ```
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 plus précis. Nous suggérons généralement d’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 dans quelle mesure le modèle apprend à partir 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 votre 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, donc il est important de vérifier aussi la validation.
## 11. Inférence / exécution du modèle
Passons maintenant à l’exécution du modèle après avoir terminé l’entraînement ! Vous pouvez modifier la partie soulignée en jaune ! En fait, comme nous avons créé un chatbot à plusieurs tours, nous pouvons désormais aussi appeler le modèle comme s’il avait vu des conversations auparavant, 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 génère des réponses plus longues, réglez `max_new_tokens = 128` sur une valeur plus élevée comme 256 ou 1024. Notez que vous devrez également attendre plus longtemps pour le résultat !
## 12. Sauvegarde du modèle
Nous pouvons maintenant enregistrer 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. Exportation vers Ollama
Enfin, nous pouvons exporter notre modèle affiné vers Ollama lui-même ! Nous devons d’abord installer Ollama dans le notebook Colab :
Ensuite, nous exportons le modèle affiné vers les formats GGUF de llama.cpp comme ci-dessous :
Rappel de convertir `False` en `True` pour 1 ligne, et de ne pas changer chaque ligne en `True`, sinon vous attendrez très longtemps ! Nous suggérons généralement de régler la première ligne sur `True`, afin de pouvoir exporter rapidement le modèle affiné au format `Q8_0` (quantification 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 des instructions manuelles pour exporter vers GGUF ici 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. Création automatique `Modelfile` création
L’astuce qu’Unsloth fournit est que nous créons automatiquement un `Modelfile` dont Ollama a besoin ! Il s’agit simplement d’une liste de paramètres et elle inclut le modèle de chat que nous avons utilisé pour le processus d’affinage ! 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 en inférence si vous voulez appeler le serveur Ollama lui-même, qui s’exécute sur votre machine locale / dans le notebook Colab gratuit en arrière-plan. N’oubliez pas que vous pouvez modifier la partie soulignée en jaune.
## 16. Style ChatGPT interactif
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é tout comme avec un véritable ChatGPT ! Appuyez sur CTRL + D pour quitter le système, puis sur ENTRÉE pour converser avec le chatbot !
## C’est 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 notebook Google Colab !
Si vous souhaitez apprendre à faire du reward modeling, du continued pretraining, exporter vers vLLM ou GGUF, faire de la complétion de texte, ou en savoir 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 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 voulons vous remercier d’avoir lu et suivi jusqu’ici ! Nous espérons que cela vous a aidé à comprendre certains des tenants et aboutissants 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: 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.