> 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/notions-de-base/chat-templates.md).

# Modèles de chat

Sur notre GitHub, nous avons une liste de tous les modèles de chat qu’Unsloth utilise, y compris pour Llama, Mistral, Phi-4, etc. Donc si vous avez besoin d’indications sur le formatage ou le cas d’utilisation, vous pouvez les consulter ici : [github.com/unslothai/unsloth/blob/main/unsloth/chat\_templates.py](https://github.com/unslothai/unsloth/blob/main/unsloth/chat_templates.py)

#### Liste des notebooks Colab sur les modèles de chat :

* [Conversationnel](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.2_\(1B_and_3B\)-Conversational.ipynb)
* [ChatML](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3_\(8B\)-Ollama.ipynb)
* [Ollama](https://colab.research.google.com/drive/1WZDi7APtQ9VsvOrQSSC5DDtxq159j8iZ?usp=sharing)
* [Classification de texte](https://github.com/timothelaborie/text_classification_scripts/blob/main/unsloth_classification.ipynb) par Timotheeee
* [Jeux de données multiples](https://colab.research.google.com/drive/1njCCbE1YVal9xC83hjdo2hiGItpY_D6t?usp=sharing) par Flail

### Ajout de nouveaux jetons

Unsloth a une fonction appelée `add_new_tokens` qui vous permet d’ajouter de nouveaux jetons à votre fine-tuning. Par exemple, si vous voulez ajouter `<CHARACTER_1>`, `<THINKING>` et `<SCRATCH_PAD>` nous pouvons faire ce qui suit :

```python
model, tokenizer = FastLanguageModel.from_pretrained(...)
from unsloth import add_new_tokens
add_new_tokens(model, tokenizer, new_tokens = ["<CHARACTER_1>", "<THINKING>", "<SCRATCH_PAD>"])
model = FastLanguageModel.get_peft_model(...)
```

{% hint style="warning" %}
Remarque - vous DEVEZ toujours appeler `add_new_tokens` avant `FastLanguageModel.get_peft_model`!
{% endhint %}

## Conversations à plusieurs 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.

<figure><img src="/files/415abaf3237603ab574a04d43eeb764b544eea5c" alt=""><figcaption></figcaption></figure>

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 !

<figure><img src="/files/d470e9afb208b14db6a12f51ba543cde06ac03c1" alt=""><figcaption></figcaption></figure>

Puis réglez `output_column_name` dans 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 !

<figure><img src="/files/bd75ed25619b920c6932cf5f1364d50f3ef96914" alt=""><figcaption></figcaption></figure>

## 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 :

<figure><img src="/files/8a0b61436be42b1d60604f763194decfd312bb4e" alt=""><figcaption></figcaption></figure>

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 :

<figure><img src="/files/0f8ce93fe8b831879278eb49a402fe3a485b9c47" alt=""><figcaption></figcaption></figure>

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 :

<figure><img src="/files/9f2cd9cbb17379d4b5d377981cb2b14b5e51598a" alt=""><figcaption></figcaption></figure>

Pour le format ChatML utilisé dans les modèles OpenAI :

<figure><img src="/files/c21e35480f8457d392f12275102a566e2a2f2709" alt=""><figcaption></figcaption></figure>

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.

<figure><img src="/files/ee58e385a3708caaab28c76d74e2a1ed5ed617d8" alt=""><figcaption></figcaption></figure>

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 : <https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing>

<figure><img src="/files/46d341abeaee32bee8d3f2a4ef3f3ecd812ec83c" alt=""><figcaption></figcaption></figure>

## Application des modèles de chat avec Unsloth

Pour les jeux de données qui suivent généralement le format chatml courant, le processus de préparation du jeu de données pour l’entraînement ou le fine-tuning consiste en quatre étapes simples :

* Vérifiez les modèles de chat actuellement pris en charge par Unsloth :\\

  ```
  from unsloth.chat_templates import CHAT_TEMPLATES
  print(list(CHAT_TEMPLATES.keys()))
  ```

  \
  Cela affichera la liste des modèles actuellement pris en charge par Unsloth. Voici un exemple de sortie :\\

  ```
  ['unsloth', 'zephyr', 'chatml', 'mistral', 'llama', 'vicuna', 'vicuna_old', 'vicuna old', 'alpaca', 'gemma', 'gemma_chatml', 'gemma2', 'gemma2_chatml', 'llama-3', 'llama3', 'phi-3', 'phi-35', 'phi-3.5', 'llama-3.1', 'llama-31', 'llama-3.2', 'llama-3.3', 'llama-32', 'llama-33', 'qwen-2.5', 'qwen-25', 'qwen25', 'qwen2.5', 'phi-4', 'gemma-3', 'gemma3']
  ```

  \\
* Utilisez `get_chat_template` pour appliquer le bon modèle de chat à votre tokenizer :\\

  ```
  from unsloth.chat_templates import get_chat_template

  tokenizer = get_chat_template(
      tokenizer,
      chat_template = "gemma-3", # changez ceci pour le bon nom de chat_template
  )
  ```

  \\
* Définissez votre fonction de formatage. Voici un exemple :\\

  ```
  def formatting_prompts_func(examples):
     convos = examples["conversations"]
     texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos]
     return { "text" : texts, }
  ```

  \
  \
  Cette fonction parcourt votre jeu de données en appliquant le modèle de chat que vous avez défini à chaque exemple.\\
* Enfin, chargeons le jeu de données et appliquons les modifications nécessaires à notre jeu de données : \\

  ```
  # Importer et charger le jeu de données
  from datasets import load_dataset
  dataset = load_dataset("repo_name/dataset_name", split = "train")

  # Appliquez la fonction de formatage à votre jeu de données à l’aide de la méthode map
  dataset = dataset.map(formatting_prompts_func, batched = True,)
  ```

  \
  Si votre jeu de données utilise le format ShareGPT avec des clés "from"/"value" au lieu du format ChatML "role"/"content", vous pouvez utiliser la `standardize_sharegpt` fonction pour le convertir d’abord. Le code révisé ressemblera désormais à ceci :\
  \\

  ```
  # Importer le jeu de données
  from datasets import load_dataset
  dataset = load_dataset("mlabonne/FineTome-100k", split = "train")

  # Convertissez votre jeu de données au format "role"/"content" si nécessaire
  from unsloth.chat_templates import standardize_sharegpt
  dataset = standardize_sharegpt(dataset)

  # Appliquez la fonction de formatage à votre jeu de données à l’aide de la méthode map
  dataset = dataset.map(formatting_prompts_func, batched = True,)
  ```

## Plus d’informations

En supposant que votre jeu de données soit une liste de listes de dictionnaires comme ci-dessous :

```python
[
    [{'from': 'human', 'value': 'Salut !'},
     {'from': 'gpt', 'value': 'Salut, comment puis-je vous aider ?'},
     {'from': 'human', 'value': 'Combien font 2+2 ?'}],
    [{'from': 'human', 'value': 'Quel est ton nom ?'},
     {'from': 'gpt', 'value': 'Je m’appelle Daniel !'},
     {'from': 'human', 'value': 'D’accord ! Sympa !'},
     {'from': 'gpt', 'value': 'Que puis-je faire pour vous ?'},
     {'from': 'human', 'value': 'Oh rien :)'},],
]
```

Vous pouvez utiliser notre `get_chat_template` pour le formater. Sélectionnez `chat_template` pour être l’un de `zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, unsloth`, et utilisez `mapping` pour faire correspondre les valeurs du dictionnaire `from`, `value` etc. `map_eos_token` vous permet de faire correspondre `<|im_end|>` à EOS sans aucun entraînement.

```python
from unsloth.chat_templates import get_chat_template

tokenizer = get_chat_template(
    tokenizer,
    chat_template = "chatml", # prend en charge zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, unsloth
    mapping = {"role" : "from", "content" : "value", "user" : "human", "assistant" : "gpt"}, # style ShareGPT
    map_eos_token = True, # mappe <|im_end|> vers </s> à la place
)

def formatting_prompts_func(examples):
    convos = examples["conversations"]
    texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos]
    return { "text" : texts, }
pass

from datasets import load_dataset
dataset = load_dataset("philschmid/guanaco-sharegpt-style", split = "train")
dataset = dataset.map(formatting_prompts_func, batched = True,)
```

Vous pouvez aussi créer vos propres modèles de chat personnalisés ! Par exemple, notre modèle de chat interne que nous utilisons est ci-dessous. Vous devez passer un `tuple` de `(custom_template, eos_token)` où le `eos_token` doit être utilisé à l’intérieur du modèle.

```python
unsloth_template = \
    "{{ bos_token }}"\
    "{{ 'Vous êtes un assistant utile pour l’utilisateur\n' }}"\
    "</div>"\
    "<div data-gb-custom-block data-tag="for">"\
        "<div data-gb-custom-block data-tag="if" data-0='role' data-1='role' data-2='] == ' data-3='user'>"\
            "{{ '>>> Utilisateur : ' + message['content'] + '\n' }}"\
        "<div data-gb-custom-block data-tag="elif" data-0='role' data-1='role' data-2='] == ' data-3='assistant'></div>"\
            "{{ '>>> Assistant : ' + message['content'] + eos_token + '\n' }}"\
        "</div>"\
    "</div>"\
    "<div data-gb-custom-block data-tag="if">"\
        "{{ '>>> Assistant : ' }}"\
    "</div>"
unsloth_eos_token = "eos_token"

tokenizer = get_chat_template(
    tokenizer,
    chat_template = (unsloth_template, unsloth_eos_token,), # Vous devez fournir un modèle et un jeton EOS
    mapping = {"role" : "from", "content" : "value", "user" : "human", "assistant" : "gpt"}, # style ShareGPT
    map_eos_token = True, # mappe <|im_end|> vers </s> à la place
)
```


---

# 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, and the optional `goal` query parameter:

```
GET https://unsloth.ai/docs/fr/notions-de-base/chat-templates.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.