💬Modèles de chat

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

Sur notre GitHub, nous avons une liste de tous les modèles 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 jetons

Unsloth dispose d'une fonction appelée add_new_tokens qui vous permet d'ajouter de nouveaux jetons à votre affinement. Par exemple si vous souhaitez 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 multi-tours

Un problème, si vous ne l'avez pas remarqué, est que le jeu de données Alpaca est à tour unique, tandis que se souvenir de l'utilisation de ChatGPT était interactif et vous pouvez lui parler sur 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.

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 1 conversation ! Par exemple, si vous le réglez sur 3, nous sélectionnons au hasard 3 lignes et les fusionnons en 1 ! Les régler trop longs peut ralentir l'entraînement, mais pourrait rendre votre chatbot et l'affinement 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 de sortie.

Nous utilisons ensuite la standardize_sharegpt fonction pour juste mettre le jeu de données dans un format correct pour l'affinement ! Appelez toujours ceci !

Modèles de chat personnalisables

Nous pouvons maintenant spécifier le modèle de chat pour l'affinement 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 affinités de style ChatGPT nécessitent seulement 1 prompt ? Puisque nous avons réussi à fusionner toutes les colonnes du jeu de données en 1 avec Unsloth, nous pouvons essentiellement créer le modèle de chat 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. Nous permettons en fait un {SYSTEM} champ optionnel également, ce qui est utile pour personnaliser un prompt système tout comme dans ChatGPT. Par exemple, ci-dessous se trouvent quelques exemples sympas que vous pouvez personnaliser dans 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 permettons en fait un {SYSTEM} champ également, ce qui est utile pour personnaliser un prompt système tout comme dans ChatGPT.

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

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 l'affinement se compose de quatre étapes simples :

• Vérifiez les modèles de chat 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 chat à votre tokenizer :\

  from unsloth.chat_templates import get_chat_template
  
  tokenizer = get_chat_template(
      tokenizer,
      chat_template = "gemma-3", # changez ceci pour le nom du chat_template approprié
  )

  \

• 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 é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
  from datasets import load_dataset
  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 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 maintenant à ce qui suit : \

  # Importer le jeu de données
  from datasets import load_dataset
  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 utilisez mapping pour mapper les valeurs du dictionnaire de, 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

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

Vous pouvez également 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.

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