💬Modèles de chat

Apprenez les fondamentaux et les options de personnalisation des modèles de chat, y compris les formats Conversational, ChatML, ShareGPT, Alpaca, et plus encore !

Sur notre GitHub, nous avons une liste de chaque modèle de conversation 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

Liste des notebooks Colab de modèles de conversation :

• Conversationnel

• ChatML

• Ollama

• Classification de texte par Timotheeee

• Jeux de données multiples par Flail

Ajout de nouveaux tokens

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

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(...)

Remarque - vous DEVEZ toujours appeler add_new_tokens avant FastLanguageModel.get_peft_model!

Conversations à tours multiples

Un petit problème si vous ne l'avez pas remarqué est que le jeu de données Alpaca est à tour unique, tandis que rappelez-vous que l'utilisation de ChatGPT était interactive et que vous pouvez discuter en plusieurs tours. Par exemple, la gauche est ce que nous voulons, mais la droite, qui est le jeu de données Alpaca, ne fournit que des conversations singulières. Nous voulons que le modèle de langage affiné apprenne d'une manière ou d'une autre à faire des conversations multi-tours comme ChatGPT.

Ainsi nous avons 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 1 conversation ! Par exemple, si vous le réglez à 3, nous sélectionnons au hasard 3 lignes et les fusionnons en 1 ! Les définir trop longs peut ralentir l'entraînement, mais peut améliorer considérablement votre chatbot et l'affinage final !

Ensuite, 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 standardize_sharegpt fonction pour simplement mettre le jeu de données dans un format correct pour l'affinage ! Appelez toujours ceci !

Modèles de conversation personnalisables

Nous pouvons maintenant spécifier le modèle de chat pour l'affinage lui-même. Le format Alpaca très célèbre est ci-dessous :

Mais rappelez-vous que nous avons dit que c'était une mauvaise idée parce que les affinages de style ChatGPT n'acceptent qu'une seule invite ? Puisque nous avons réussi à fusionner toutes les colonnes du jeu de données en 1 en utilisant 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 placiez un {INPUT} champ pour l'instruction et un {OUTPUT} champ pour la sortie du modèle. Nous autorisons en fait un {SYSTEM} champ optionnel également, ce qui est utile pour personnaliser une instruction système comme dans ChatGPT. Par exemple, ci-dessous se trouvent quelques exemples sympas que vous pouvez personnaliser pour 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 un {SYSTEM} champ optionnel également, ce qui est utile pour personnaliser une instruction système comme dans ChatGPT.

Ou dans la tâche de prédiction Titanic où vous deviez prédire si un passager est décédé ou a survécu dans ce carnet Colab qui inclut le téléversement CSV et Excel : https://colab.research.google.com/drive/1VYkncZMfGFkeCEgN2IzbZIKEDkyQuJAS?usp=sharing

Application des modèles de conversation 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 conversation que Unsloth prend actuellement en charge :\

  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 conversation à 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 conversation que vous avez défini à chaque échantillon.\

• Enfin, chargeons le jeu de données et appliquons les modifications requises à notre jeu de données : \

  # Importer et charger le jeu de données
  #token = "hf_...", # en utiliser un si vous utilisez des modèles régulés comme meta-llama/Llama-2-7b-hf
  dataset = load_dataset("repo_name/dataset_name", split = "train")
  
  # Appliquer la fonction de formatage à votre jeu de données en utilisant la méthode map
  dataset = dataset.map(formatting_prompts_func, batched = True,)

  Si votre jeu de données utilise le format ShareGPT avec les 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 à ce qui suit : \

  # Importer le jeu de données
  #token = "hf_...", # en utiliser un si vous utilisez des modèles régulés comme meta-llama/Llama-2-7b-hf
  dataset = load_dataset("mlabonne/FineTome-100k", split = "train")
  
  # Convertir votre jeu de données au format "role"/"content" si nécessaire
  from unsloth.chat_templates import standardize_sharegpt
  dataset = standardize_sharegpt(dataset)
  
  # Appliquer la fonction de formatage à votre jeu de données en utilisant 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 :

[
    [{'from': 'human', 'value': 'Hi there!'},
     {'from': 'gpt', 'value': 'Hi how can I help?'},
     {'from': 'human', 'value': 'What is 2+2?'}],
    [{'from': 'human', 'value': 'What's your name?'},
     {'from': 'gpt', 'value': 'I'm Daniel!'},
     {'from': 'human', 'value': 'Ok! Nice!'},
     {'from': 'gpt', 'value': 'What can I do for you?'},
     {'from': 'human', 'value': 'Oh nothing :)'},],
]

Vous pouvez utiliser notre get_chat_template pour le formater. Sélectionnez chat_template pour être n'importe lequel de zephyr, chatml, mistral, llama, alpaca, vicuna, vicuna_old, unsloth, et utiliser mapping pour mapper les valeurs du dictionnaire depuis, value etc. map_eos_token vous permet de mapper <|im_end|> à EOS sans aucun entraînement.

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

#token = "hf_...", # en utiliser un si vous utilisez des modèles régulés comme meta-llama/Llama-2-7b-hf
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 conversation personnalisés ! Par exemple, notre modèle de conversation 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.

unsloth_template = \
    "{{ bos_token }}"\
    "{{ 'You are a helpful assistant to the user\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'>"\
            "{{ '>>> User: ' + 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 template et un token EOS
    mapping = {"role" : "from", "content" : "value", "user" : "human", "assistant" : "gpt"}, # Style ShareGPT
    map_eos_token = True, # Mappe <|im_end|> vers </s> à la place
)