Formats et types de jeu de données

Ce guide présente un aperçu des formats et types de jeux de données pris en charge par chaque formateur dans TRL.

Aperçu des formats et types de jeux de données

• Le format d'un jeu de données désigne la manière dont les données sont structurées, généralement classées en standard ou conversationnel.
• Le type est associé à la tâche spécifique pour laquelle le jeu de données est conçu, comme prompt-only ou preference. Chaque type est caractérisé par ses colonnes, qui varient selon la tâche, comme le montre le tableau.

{"text": "The sky is blue."}

{"messages": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}]}

{"prompt": "The sky is"}

{"prompt": [{"role": "user", "content": "What color is the sky?"}]}

{"prompt": "The sky is",
 "completion": " blue."}

{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "completion": [{"role": "assistant", "content": "It is blue."}]}

{"prompt": "The sky is",
 "chosen": " blue.",
 "rejected": " green."}

{"chosen": "The sky is blue.",
 "rejected": "The sky is green."}

{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "chosen": [{"role": "assistant", "content": "It is blue."}],
 "rejected": [{"role": "assistant", "content": "It is green."}]}

{"chosen": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is blue."}],
 "rejected": [{"role": "user", "content": "What color is the sky?"},
                {"role": "assistant", "content": "It is green."}]}

{"prompt": "The sky is",
 "completion": " blue.",
 "label": True}

{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "completion": [{"role": "assistant", "content": "It is green."}],
 "label": False}

Formats

Standard

Le format de jeu de données standard se compose généralement de chaînes de texte brut. Les colonnes du jeu de données varient en fonction de la tâche. C'est le format attendu par les formateurs TRL. Voici des exemples de formats de jeu de données standard pour différentes tâches :

# Language modeling
language_modeling_example = {"text": "The sky is blue."}
# Preference
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Unpaired preference
unpaired_preference_example = {"prompt": "The sky is", "completion": " blue.", "label": True}

Conversationnel

Les jeux de données conversationnels sont utilisés pour les tâches impliquant des dialogues ou des interactions de chat entre utilisateurs et assistants. Contrairement aux formats de jeu de données standard, ils contiennent des séquences de messages où chaque message possède un role (par exemple, "user" ou "assistant") et un content (le texte du message).

messages = [
    {"role": "user", "content": "Hello, how are you?"},
    {"role": "assistant", "content": "I'm doing great. How can I help you today?"},
    {"role": "user", "content": "I'd like to show off how chat templating works!"},
]

Tout comme les jeux de données standards, les colonnes des jeux de données conversationnels varient en fonction de la tâche. Voici des exemples de formats de jeux de données conversationnels pour différentes tâches :

# Prompt-completion
prompt_completion_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                             "completion": [{"role": "assistant", "content": "It is blue."}]}
# Preference
preference_example = {
    "prompt": [{"role": "user", "content": "What color is the sky?"}],
    "chosen": [{"role": "assistant", "content": "It is blue."}],
    "rejected": [{"role": "assistant", "content": "It is green."}],
}

Appel d'outils

Certaines templates de chat prennent en charge l'appel d'outils, ce qui permet au modèle d'interagir avec des fonctions externes — appelées outils — pendant la génération. Cela étend les capacités conversationnelles du modèle en lui permettant de générer un champ "tool_calls" au lieu d'un message standard "content" lorsqu'il décide d'invoquer un outil.

Après que l'assistant a initié un appel d'outil, l'outil s'exécute et renvoie sa sortie. L'assistant peut ensuite traiter cette sortie et poursuivre la conversation en conséquence.

Voici un exemple simple d’interaction avec un outil :

messages = [
    {"role": "user", "content": "Turn on the living room lights."},
    {"role": "assistant", "tool_calls": [
        {"type": "function", "function": {
            "name": "control_light",
            "arguments": {"room": "living room", "state": "on"}
        }}]
    },
    {"role": "tool", "name": "control_light", "content": "The lights in the living room are now on."},
    {"role": "assistant", "content": "Done!"}
]

Lors de la préparation des jeux de données pour le Supervised Fine-Tuning (SFT) avec l'appel d'outils, il est important que votre jeu de données inclue une colonne supplémentaire nommée tools. Cette colonne contient la liste des outils disponibles pour le modèle, qui est généralement utilisée par le chat template pour construire le system prompt.

Les outils doivent être spécifiés dans un format de schéma JSON codifié. Vous pouvez générer automatiquement ce schéma à partir des signatures de fonctions Python à l'aide de l'utilitaire get_json_schema :

import json
from transformers.utils import get_json_schema

def control_light(room: str, state: str) -> str:
    """
    Controls the lights in a room.

    Args:
        room: The name of the room.
        state: The desired state of the light ("on" or "off").

    Returns:
        str: A message indicating the new state of the lights.
    """
    return f"The lights in {room} are now {state}."

# Generate JSON schema
json_schema = get_json_schema(control_light)

Le schéma généré ressemblerait à :

{"type": "function", "function": {"name": "control_light", "description": "Controls the lights in a room.", "parameters": {"type": "object", "properties": {"room": {"type": "string", "description": "The name of the room."}, "state": {"type": "string", "description": "The desired state of the light (\"on\" or \"off\")."}}, "required": ["room", "state"]}, "return": {"type": "string", "description": "str: A message indicating the new state of the lights."}}}

Une entrée complète du jeu de données pour le SFT pourrait ressembler à :

{"messages": messages, "tools": [json_schema]}

Pour obtenir un Dataset, vous devez utiliser le type Json() pour les arguments d’outil, car ce sont des objets JSON arbitraires et non des dictionnaires avec des champs et des types fixes :

from datasets import Dataset

data = [
    {"messages": messages1, "tools": [json_schema1]},
    {"messages": messages2, "tools": [json_schema2]},
]
# auto-apply the Json() type
dataset = Dataset.from_list(data, on_mixed_types="use_json")

# or specify the features manually
from datasets import Features, Json, List, Value

features = Features(
    {
        "messages": List({"role": Value("string"), "content": Value("string"), "tool_calls": List(Json())}),
        "tools": List(Json()),
    }
)
dataset = Dataset.from_list(data, features=features)

Sur les anciennes versions de datasets (<4.7.0) qui ne disposent pas du type Json(), vous devez stocker tools sous forme de chaîne JSON str (avec json.dumps([...])) :

dataset = Dataset.from_list(
    [{"messages": messages1, "tools": json.dumps([json_schema1])},
     {"messages": messages2, "tools": json.dumps([json_schema2])}]
)

Pour plus de détails sur l'appel d'outils, consultez la section Tool Calling de la documentation transformers et l'article de blog Tool Use, Unified.

Harmony

Le format de réponse Harmony a été introduit avec les modèles OpenAI GPT OSS. Il étend le format conversationnel en ajoutant une structure plus riche pour le raisonnement, les appels de fonctions et les métadonnées concernant le comportement du modèle. Les fonctionnalités clés incluent :

• Rôle du développeur – Fournit des instructions de haut niveau (similaires à un prompt système) et énumère les outils disponibles.

• Canaux – Séparez les différents types de sortie de l’assistant en flux distincts :

  • analysis – pour le raisonnement interne, à partir de la clé "thinking"
  • final – pour la réponse destinée à l'utilisateur, à partir de la clé "content"
  • commentary – pour les appels d’outils ou les notes de méta

• Effort de raisonnement – Indique le niveau de réflexion que le modèle doit afficher (par exemple, "low", "medium", "high").

• Identité du modèle – Définit explicitement la persona de l’assistant.

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("openai/gpt-oss-20b")

messages = [
    {"role": "developer", "content": "Use a friendly tone."},
    {"role": "user", "content": "What is the meaning of life?"},
    {"role": "assistant", "thinking": "Deep reflection...", "content": "The final answer is..."},
]

print(
    tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        reasoning_effort="low",
        model_identity="You are HuggingGPT, a large language model trained by Hugging Face.",
    )
)

Cela produit :

<|start|>system<|message|>You are HuggingGPT, a large language model trained by Hugging Face.
Knowledge cutoff: 2024-06
Current date: 2025-08-03

Reasoning: low

# Valid channels: analysis, commentary, final. Channel must be included for every message.<|end|><|start|>developer<|message|># Instructions

Use a friendly tone.<|end|><|start|>user<|message|>What is the meaning of life?<|end|><|start|>assistant<|channel|>analysis<|message|>Deep reflection...<|end|><|start|>assistant<|channel|>final<|message|>The final answer is...<|return|>

Pour tous les détails sur la structure des messages, les champs pris en charge et l'utilisation avancée, consultez la documentation Harmony.

Types

Modélisation du langage

Un jeu de données de modélisation de langage est constitué d'une colonne "text" (ou "messages" pour les jeux de données conversationnels) contenant une séquence de texte complète.

# Standard format
language_modeling_example = {"text": "The sky is blue."}
# Conversational format
language_modeling_example = {"messages": [
    {"role": "user", "content": "What color is the sky?"},
    {"role": "assistant", "content": "It is blue."}
]}

Prompt uniquement

Dans un jeu de données ne contenant que des prompts, seul le prompt initial (la question ou la phrase partielle) est fourni sous la clé "prompt". L’entraînement consiste généralement à générer une complétion à partir de ce prompt, le modèle apprenant ainsi à continuer ou à compléter l’entrée donnée.

# Standard format
prompt_only_example = {"prompt": "The sky is"}
# Conversational format
prompt_only_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}]}

Pour des exemples de jeux de données ne contenant que des prompts, reportez-vous à la collection de jeux de données ne contenant que des prompts.

Bien que les types « prompt-only » et « language modeling » soient similaires, ils diffèrent par la manière dont l'entrée est gérée. Dans le type « prompt-only », le prompt représente une entrée partielle qui s'attend à ce que le modèle la complète ou la poursuive, tandis que dans le type « language modeling », l'entrée est traitée comme une phrase ou une séquence complète. TRL traite ces deux types différemment. Voici un exemple illustrant la différence dans la sortie de la fonction apply_chat_template pour chaque type :

Copié

from transformers import AutoTokenizer
from trl import apply_chat_template

tokenizer = AutoTokenizer.from_pretrained("microsoft/Phi-3-mini-128k-instruct")

# Example for prompt-only type
prompt_only_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}]}
apply_chat_template(prompt_only_example, tokenizer)
# Output: {'prompt': '<|user|>\nWhat color is the sky?<|end|>\n<|assistant|>\n'}

# Example for language modeling type
lm_example = {"messages": [{"role": "user", "content": "What color is the sky?"}]}
apply_chat_template(lm_example, tokenizer)
# Output: {'text': '<|user|>\nWhat color is the sky?<|end|>\n<|endoftext|>'}

• La sortie uniquement du prompt inclut un '<|assistant|>\n', indiquant le début du tour de l'assistant et s'attendant à ce que le modèle génère une complétion.
• En revanche, la sortie de la modélisation du langage traite l’entrée comme une séquence complète et la termine par '<|endoftext|>', signalant la fin du texte et n’attendant aucun contenu supplémentaire.

Prompt-complétion

Un jeu de données de prompt-complétion comprend un "prompt" et un "completion".

# Standard format
prompt_completion_example = {"prompt": "The sky is", "completion": " blue."}
# Conversational format
prompt_completion_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                             "completion": [{"role": "assistant", "content": "It is blue."}]}

Pour des exemples de jeux de données de type prompt-complétion, reportez-vous à la collection de jeux de données prompt-complétion.

Préférence

Un jeu de données de préférence est utilisé pour les tâches où le modèle est entraîné à choisir entre deux ou plusieurs complétions possibles pour le même prompt. Ce jeu de données comprend un "prompt", une complétion "chosen" et une complétion "rejected". Le modèle est entraîné à sélectionner la réponse "chosen" plutôt que la réponse "rejected". Certains jeux de données peuvent ne pas inclure la colonne "prompt", auquel cas le prompt est implicite et directement inclus dans les complétions "chosen" et "rejected". Nous recommandons d'utiliser des prompts explicites chaque fois que possible.

# Standard format
## Explicit prompt (recommended)
preference_example = {"prompt": "The sky is", "chosen": " blue.", "rejected": " green."}
# Implicit prompt
preference_example = {"chosen": "The sky is blue.", "rejected": "The sky is green."}

# Conversational format
## Explicit prompt (recommended)
preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                      "chosen": [{"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "assistant", "content": "It is green."}]}
## Implicit prompt
preference_example = {"chosen": [{"role": "user", "content": "What color is the sky?"},
                                 {"role": "assistant", "content": "It is blue."}],
                      "rejected": [{"role": "user", "content": "What color is the sky?"},
                                   {"role": "assistant", "content": "It is green."}]}

Pour des exemples de jeux de données de préférence, reportez-vous à la collection de jeux de données de préférence.

Certains jeux de données de préférence peuvent être trouvés avec l’étiquette dpo sur Hugging Face Hub. Vous pouvez également explorer les collections DPO des librarian-bots pour identifier des jeux de données de préférence.

Préférence non appariée

Un jeu de données de préférences non appariées est similaire à un jeu de données de préférences, mais au lieu de disposer de complétions "chosen" et "rejected" pour le même prompt, il inclut une seule "completion" et un "label" indiquant si la complétion est préférée ou non.

# Standard format
unpaired_preference_example = {"prompt": "The sky is", "completion": " blue.", "label": True}
# Conversational format
unpaired_preference_example = {"prompt": [{"role": "user", "content": "What color is the sky?"}],
                               "completion": [{"role": "assistant", "content": "It is blue."}],
                               "label": True}

Pour des exemples de jeux de données de préférences non appariées, reportez-vous à la collection de jeux de données de préférences non appariées.

Quel type de jeu de données utiliser ?

Le choix du bon type de jeu de données dépend de la tâche sur laquelle vous travaillez et des exigences spécifiques de l'entraîneur TRL que vous utilisez. Ci-dessous, un bref aperçu des types de jeux de données pris en charge par chaque entraîneur TRL.

Utiliser n'importe quel jeu de données avec TRL : prétraitement et conversion

De nombreux jeux de données sont fournis dans des formats adaptés à des tâches spécifiques, qui ne sont pas directement compatibles avec TRL. Pour utiliser de tels jeux de données avec TRL, il est peut-être nécessaire de les prétraiter et de les convertir dans le format requis.

Pour faciliter cette tâche, nous fournissons un ensemble de scripts d'exemple couvrant les conversions de jeux de données courantes.

Exemple : jeu de données UltraFeedback

Prenons le jeu de données UltraFeedback comme exemple. Voici un aperçu du jeu de données :

Comme indiqué ci-dessus, le format du jeu de données ne correspond pas à la structure attendue. Il n’est pas au format conversationnel, les noms de colonnes diffèrent, et les résultats concernent différents modèles (par exemple, Bard, GPT-4) et différents aspects (par exemple, « helpfulness », « honesty »).

En utilisant le script de conversion fourni examples/datasets/ultrafeedback.py, vous pouvez transformer ce jeu de données en type de préférence non apparié et le publier sur le Hub :

python examples/datasets/ultrafeedback.py --push_to_hub --repo_id trl-lib/ultrafeedback-gpt-3.5-turbo-helpfulness

Une fois converti, le jeu de données aura l’aspect suivant :

Maintenant, vous pouvez utiliser ce jeu de données avec TRL !

En adaptant les scripts fournis ou en créant les vôtres, vous pouvez convertir n'importe quel jeu de données dans un format compatible avec TRL.

Utilitaires pour la conversion des types de jeu de données

Cette section fournit du code d’exemple pour vous aider à convertir entre différents types de jeux de données. Bien que certaines conversions puissent être effectuées après l’application du modèle de discussion (c’est-à-dire au format standard), nous recommandons d’effectuer la conversion avant d’appliquer le modèle de discussion afin de garantir un fonctionnement cohérent.

Pour simplifier, certains des exemples ci-dessous ne suivent pas cette recommandation et utilisent le format standard. Toutefois, les conversions peuvent être appliquées directement au format conversationnel sans modification.

De la complétion de prompt au jeu de données de modélisation de langage

Pour convertir un jeu de données de prompt-complétion en jeu de données de modélisation de langage, concaténez le prompt et la complétion.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "completion": [" blue.", " in the sky."],
})

def concat_prompt_completion(example):
    return {"text": example["prompt"] + example["completion"]}

dataset = dataset.map(concat_prompt_completion, remove_columns=["prompt", "completion"])

>>> dataset[0]
{'text': 'The sky is blue.'}

De l’ensemble de données prompt-complétion à l’ensemble de données prompt uniquement

Pour convertir un jeu de données de type prompt-complétion en un jeu de données de type prompt uniquement, supprimez la complétion.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "completion": [" blue.", " in the sky."],
})

dataset = dataset.remove_columns("completion")

>>> dataset[0]
{'prompt': 'The sky is'}

De la préférence avec prompt implicite au jeu de données de modélisation du langage

Pour convertir un jeu de données de préférence avec prompt implicite en jeu de données de modélisation du langage, supprimez les éléments rejetés et renommez la colonne "chosen" en "text".

from datasets import Dataset

dataset = Dataset.from_dict({
    "chosen": ["The sky is blue.", "The sun is in the sky."],
    "rejected": ["The sky is green.", "The sun is in the sea."],
})

dataset = dataset.rename_column("chosen", "text").remove_columns("rejected")

>>> dataset[0]
{'text': 'The sky is blue.'}

De la préférence avec prompt implicite au jeu de données prompt-complétion

Pour convertir un jeu de données de préférences avec un prompt implicite en un jeu de données prompt-complétion, extrayez le prompt avec extract_prompt(), supprimez les refusés et renommez la colonne "chosen" en "completion".

from datasets import Dataset
from trl import extract_prompt

dataset = Dataset.from_dict({
    "chosen": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sea."}],
    ],
})
dataset = dataset.map(extract_prompt).remove_columns("rejected").rename_column("chosen", "completion")

>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}], 'completion': [{'role': 'assistant', 'content': 'It is blue.'}]}

De l'ensemble de données de préférence avec prompt implicite à l'ensemble de données uniquement prompt

Pour convertir un jeu de données de préférences avec un prompt implicite en un jeu de données ne contenant que le prompt, extrayez le prompt avec extract_prompt() et supprimez les réponses rejetées et choisies.

from datasets import Dataset
from trl import extract_prompt

dataset = Dataset.from_dict({
    "chosen": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sea."}],
    ],
})
dataset = dataset.map(extract_prompt).remove_columns(["chosen", "rejected"])

>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}]}

De l'ensemble de données de préférence implicite à l'ensemble de données de préférence explicite

Pour convertir un jeu de données de préférences avec un prompt implicite en un jeu de données de préférences avec un prompt explicite, extrayez le prompt avec extract_prompt().

from datasets import Dataset
from trl import extract_prompt

dataset = Dataset.from_dict({
    "chosen": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sea."}],
    ],
})

dataset = dataset.map(extract_prompt)

>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}],
 'chosen': [{'role': 'assistant', 'content': 'It is blue.'}],
 'rejected': [{'role': 'assistant', 'content': 'It is green.'}]}

De la préférence avec prompt implicite au jeu de données de préférences non appariées

Pour convertir un jeu de données de préférences avec prompt implicite en un jeu de données de préférences non appariées, extrayez le prompt avec extract_prompt() et désappariez le jeu de données avec unpair_preference_dataset().

from datasets import Dataset
from trl import extract_prompt, unpair_preference_dataset

dataset = Dataset.from_dict({
    "chosen": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is blue."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "user", "content": "What color is the sky?"}, {"role": "assistant", "content": "It is green."}],
        [{"role": "user", "content": "Where is the sun?"}, {"role": "assistant", "content": "In the sea."}],
    ],
})

dataset = dataset.map(extract_prompt)
dataset = unpair_preference_dataset(dataset)

>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}],
 'completion': [{'role': 'assistant', 'content': 'It is blue.'}],
 'label': True}

Gardez à l’esprit que les complétions "chosen" et "rejected" d’un jeu de données de préférence peuvent être toutes deux bonnes ou mauvaises. Avant d’appliquer unpair_preference_dataset(), assurez-vous que toutes les complétions "chosen" peuvent être qualifiées de bonnes et toutes les complétions "rejected" de mauvaises. Cela peut être garanti en vérifiant la note absolue de chaque complétion, par exemple à partir d’un modèle de récompense.

De l'ensemble de données de préférence à l'ensemble de données de modélisation du langage

Pour convertir un jeu de données de préférences en jeu de données de modélisation de langage, supprimez les rejetés, puis concaténez le prompt et le choisi dans la colonne "text".

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "chosen": [" blue.", " in the sky."],
    "rejected": [" green.", " in the sea."],
})

def concat_prompt_chosen(example):
    return {"text": example["prompt"] + example["chosen"]}

dataset = dataset.map(concat_prompt_chosen, remove_columns=["prompt", "chosen", "rejected"])

>>> dataset[0]
{'text': 'The sky is blue.'}

De l'ensemble de données de préférence à l'ensemble de données de complétion de prompt

Pour convertir un jeu de données de préférences en un jeu de données de prompt-complétion, supprimez les éléments rejetés et renommez la colonne "chosen" en "completion".

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "chosen": [" blue.", " in the sky."],
    "rejected": [" green.", " in the sea."],
})

dataset = dataset.remove_columns("rejected").rename_column("chosen", "completion")

>>> dataset[0]
{'prompt': 'The sky is', 'completion': ' blue.'}

De l'ensemble de données de préférence à l'ensemble de données prompt-only

Pour convertir un jeu de données de préférences en un jeu de données ne contenant que des prompts, supprimez les éléments rejetés et choisis.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is"],
    "chosen": [" blue.", " in the sky."],
    "rejected": [" green.", " in the sea."],
})

dataset = dataset.remove_columns(["chosen", "rejected"])

>>> dataset[0]
{'prompt': 'The sky is'}

Du jeu de données de préférence de prompt explicite au jeu de données de préférence de prompt implicite

Pour convertir un jeu de données de préférences avec un prompt explicite en un jeu de données de préférences avec un prompt implicite, concaténez le prompt aux champs chosen et rejected, puis supprimez le prompt.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": [
        [{"role": "user", "content": "What color is the sky?"}],
        [{"role": "user", "content": "Where is the sun?"}],
    ],
    "chosen": [
        [{"role": "assistant", "content": "It is blue."}],
        [{"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "assistant", "content": "It is green."}],
        [{"role": "assistant", "content": "In the sea."}],
    ],
})

def concat_prompt_to_completions(example):
    return {"chosen": example["prompt"] + example["chosen"], "rejected": example["prompt"] + example["rejected"]}

dataset = dataset.map(concat_prompt_to_completions, remove_columns="prompt")

>>> dataset[0]
{'chosen': [{'role': 'user', 'content': 'What color is the sky?'}, {'role': 'assistant', 'content': 'It is blue.'}],
 'rejected': [{'role': 'user', 'content': 'What color is the sky?'}, {'role': 'assistant', 'content': 'It is green.'}]}

De la préférence au jeu de données de préférences non appariées

Pour convertir un jeu de données en jeu de données de préférences non appariées, utilisez unpair_preference_dataset() pour le désappairer.

from datasets import Dataset
from trl import unpair_preference_dataset

dataset = Dataset.from_dict({
    "prompt": [
        [{"role": "user", "content": "What color is the sky?"}],
        [{"role": "user", "content": "Where is the sun?"}],
    ],
    "chosen": [
        [{"role": "assistant", "content": "It is blue."}],
        [{"role": "assistant", "content": "In the sky."}],
    ],
    "rejected": [
        [{"role": "assistant", "content": "It is green."}],
        [{"role": "assistant", "content": "In the sea."}],
    ],
})

dataset = unpair_preference_dataset(dataset)

>>> dataset[0]
{'prompt': [{'role': 'user', 'content': 'What color is the sky?'}],
 'completion': [{'role': 'assistant', 'content': 'It is blue.'}],
 'label': True}

Gardez à l’esprit que les complétions "chosen" et "rejected" d’un jeu de données de préférence peuvent être toutes deux bonnes ou mauvaises. Avant d’appliquer unpair_preference_dataset(), assurez-vous que toutes les complétions "chosen" peuvent être qualifiées de bonnes et toutes les complétions "rejected" de mauvaises. Cela peut être garanti en vérifiant la note absolue de chaque complétion, par exemple à partir d’un modèle de récompense.

De l'ensemble de données de préférences non appariées à l'ensemble de données de modélisation du langage

Pour convertir un jeu de données de préférences non appariées en jeu de données de modélisation de langage, concaténez les prompts avec les bonnes complétions dans la colonne "text", et supprimez les colonnes prompt, completion et label.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is", "The sky is", "The sun is"],
    "completion": [" blue.", " in the sky.", " green.", " in the sea."],
    "label": [True, True, False, False],
})

def concatenate_prompt_completion(example):
    return {"text": example["prompt"] + example["completion"]}

dataset = dataset.filter(lambda x: x["label"]).map(concatenate_prompt_completion).remove_columns(["prompt", "completion", "label"])

>>> dataset[0]
{'text': 'The sky is blue.'}

De l'ensemble de données de préférences non appariées à l'ensemble de données prompt-complétion

Pour convertir un jeu de données de préférences non appariées en un jeu de données prompt-complétion, filtrez sur les bons étiquettes, puis supprimez les colonnes d'étiquettes.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is", "The sky is", "The sun is"],
    "completion": [" blue.", " in the sky.", " green.", " in the sea."],
    "label": [True, True, False, False],
})

dataset = dataset.filter(lambda x: x["label"]).remove_columns(["label"])

>>> dataset[0]
{'prompt': 'The sky is', 'completion': ' blue.'}

De l'ensemble de données de préférences non appariées à l'ensemble de données de prompts uniquement

Pour convertir un jeu de données de préférences non appariées en un jeu de données ne contenant que des prompts, supprimez les colonnes de complétion et d'étiquette.

from datasets import Dataset

dataset = Dataset.from_dict({
    "prompt": ["The sky is", "The sun is", "The sky is", "The sun is"],
    "completion": [" blue.", " in the sky.", " green.", " in the sea."],
    "label": [True, True, False, False],
})

dataset = dataset.remove_columns(["completion", "label"])

>>> dataset[0]
{'prompt': 'The sky is'}

Jeux de données de vision

Certains formateurs prennent également en charge l’ajustement fin des modèles vision-langage (VLM) à l’aide de paires image-texte. Dans ce scénario, il est recommandé d’utiliser un format conversationnel, car chaque modèle gère les espaces réservés pour les images dans le texte de manière différente.

Un jeu de données visuel conversationnel diffère d'un jeu de données conversationnel standard à deux égards essentiels :

1. The dataset must contain the key images with the image data (as lists of PIL images) or image with a single PIL image.
2. Le champ "content" des messages doit être une liste de dictionnaires, où chaque dictionnaire spécifie le type de données : "image" ou "text".

Exemple :

# Textual dataset:
"content": "What color is the sky?"

# Vision dataset:
"content": [
    {"type": "image"},
    {"type": "text", "text": "What color is the sky in the image?"}
]

Un exemple de jeu de données visuel conversationnel est le openbmb/RLAIF-V-Dataset. Ci-dessous, une vue intégrée des données d’entraînement du jeu de données, vous permettant de l’explorer directement :

Il est possible de mélanger des données textuelles et des données vision-langage dans le jeu de données, mais cela nécessite la version 4.57.0 ou ultérieure de transformers. Exemple :

Copié

dataset = Dataset.from_dict({
    "prompt": [
        [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": "What color is the sky in the image?"}]}],
        [{"role": "user", "content": [{"type": "text", "text": "What is the capital of France?"}]}],
    ],
    "completion": [
        [{"role": "assistant", "content": [{"type": "text", "text": "It is blue."}]}],
        [{"role": "assistant", "content": [{"type": "text", "text": "Paris."}]}],
    ],
    "images": [
        [PIL.Image.open("path/to/sky_image1.png")],
        [],
    ],
})