Formatos e tipos de dataset

Este guia fornece uma visão geral dos formatos e tipos de conjuntos de dados suportados por cada treinador no TRL.

Visão geral dos formatos e tipos de conjuntos de dados

• O format de um conjunto de dados refere-se à forma como os dados são estruturados, tipicamente categorizados como standard ou conversational.
• O type está associado à tarefa específica para a qual o conjunto de dados foi projetado, como prompt-only ou preference. Cada tipo é caracterizado por suas colunas, que variam de acordo com a tarefa, conforme mostrado na tabela.

{"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}

Formatos

Padrão

O formato padrão de conjunto de dados geralmente consiste em strings de texto simples. As colunas no conjunto de dados variam dependendo da tarefa. Este é o formato esperado pelos treinadores do TRL. Abaixo estão exemplos de formatos padrão de conjunto de dados para diferentes tarefas:

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

Conversacional

Conjuntos de dados conversacionais são usados para tarefas que envolvem diálogos ou interações de chat entre usuários e assistentes. Diferentemente dos formatos padrão de conjuntos de dados, esses contêm sequências de mensagens em que cada mensagem possui um role (por exemplo, "user" ou "assistant") e content (o texto da mensagem).

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!"},
]

Assim como nos conjuntos de dados padrão, as colunas em conjuntos de dados conversacionais variam de acordo com a tarefa. Abaixo estão exemplos de formatos de conjuntos de dados conversacionais para diferentes tarefas:

# 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."}],
}

Chamada de Ferramentas

Alguns modelos de chat suportam chamadas de ferramentas, o que permite que o modelo interaja com funções externas — referidas como ferramentas — durante a geração. Isso estende as capacidades conversacionais do modelo, permitindo que ele outpute um campo "tool_calls" em vez de uma mensagem padrão de "content" sempre que decidir invocar uma ferramenta.

Após o assistente iniciar uma chamada de ferramenta, a ferramenta é executada e retorna sua saída. O assistente pode, então, processar essa saída e continuar a conversa de acordo.

Aqui está um exemplo simples de uma interação de chamada de ferramenta:

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!"}
]

Ao preparar conjuntos de dados para Supervised Fine-Tuning (SFT) com tool calling, é importante que seu conjunto de dados inclua uma coluna adicional chamada tools. Essa coluna contém a lista de ferramentas disponíveis para o modelo, que geralmente é usada pelo chat template para construir o system prompt.

As ferramentas devem ser especificadas em um formato de esquema JSON codificado. Você pode gerar automaticamente esse esquema a partir das assinaturas de funções Python usando a utilidade 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)

O esquema gerado ficaria assim:

{"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."}}}

Uma entrada completa de conjunto de dados para SFT pode ser assim:

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

Para obter um Dataset, é necessário usar o tipo Json() para os argumentos da ferramenta, pois eles são objetos JSON arbitrários e não dicionários com campos e tipos fixos:

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)

Em versões mais antigas do datasets (<4.7.0) que não possuem o tipo Json(), você deve armazenar tools como uma str JSON (com json.dumps([...])):

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

Para mais informações detalhadas sobre tool calling, consulte a seção de Tool Calling na documentação do transformers e o post no blog Tool Use, Unified.

Harmony

O formato de resposta Harmony foi introduzido com os modelos OpenAI GPT OSS. Ele estende o formato conversacional adicionando uma estrutura mais rica para raciocínio, chamadas de função e metadados sobre o comportamento do modelo. Os recursos principais incluem:

• Papel de desenvolvedor – Fornece instruções de alto nível (semelhantes a um prompt de sistema) e lista as ferramentas disponíveis.

• Canais – Separe os tipos de saída do assistente em streams distintos:

  • analysis – para raciocínio interno, a partir da chave "thinking"
  • final – para a resposta voltada ao usuário, da chave "content"
  • commentary – para chamadas de ferramentas ou notas de metadados

• Nível de raciocínio – Indica o quanto de raciocínio o modelo deve demonstrar (por exemplo, "low", "medium", "high").

• Identidade do modelo – Define explicitamente a persona do assistente.

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.",
    )
)

Isso produz:

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

Para obter todos os detalhes sobre a estrutura de mensagens, campos suportados e uso avançado, consulte a documentação do Harmony.

Tipos

Modelagem de linguagem

Um conjunto de dados de modelagem de linguagem consiste em uma coluna "text" (ou "messages" para conjuntos de dados conversacionais) contendo uma sequência completa de texto.

# 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."}
]}

Somente prompt

Em um conjunto de dados apenas com prompt, apenas o prompt inicial (a pergunta ou a frase parcial) é fornecido sob a chave "prompt". O treinamento geralmente envolve a geração de uma continuação com base nesse prompt, onde o modelo aprende a continuar ou completar a entrada fornecida.

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

Para exemplos de conjuntos de dados apenas com prompts, consulte a coleção de conjuntos de dados apenas com prompts.

Embora os tipos apenas-prompt e modelagem de linguagem sejam semelhantes, eles diferem em como a entrada é processada. No tipo apenas-prompt, o prompt representa uma entrada parcial que espera que o modelo a complete ou continue, enquanto no tipo modelagem de linguagem, a entrada é tratada como uma frase ou sequência completa. Esses dois tipos são processados de maneira diferente pelo TRL. Abaixo está um exemplo mostrando a diferença na saída da função apply_chat_template para cada tipo:

Copiado

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|>'}

• A saída apenas do prompt inclui um '<|assistant|>\n', indicando o início da vez do assistente e esperando que o modelo gere uma continuação.
• Em contraste, a saída de modelagem de linguagem trata a entrada como uma sequência completa e a encerra com '<|endoftext|>', sinalizando o fim do texto e não esperando nenhum conteúdo adicional.

Prompt-completion

Um conjunto de dados de prompt-completion inclui um "prompt" e um "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."}]}

Para exemplos de conjuntos de dados de prompt-completion, consulte a coleção de conjuntos de dados de prompt-completion.

Preferência

Um conjunto de dados de preferências é usado para tarefas em que o modelo é treinado para escolher entre duas ou mais possíveis conclusões para o mesmo prompt. Este conjunto de dados inclui um "prompt", uma conclusão "chosen" e uma conclusão "rejected". O modelo é treinado para selecionar a resposta "chosen" em vez da resposta "rejected". Alguns conjuntos de dados podem não incluir a coluna "prompt", caso em que o prompt é implícito e incluído diretamente nas conclusões "chosen" e "rejected". Recomendamos o uso de prompts explícitos sempre que possível.

# 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."}]}

Para exemplos de conjuntos de dados de preferência, consulte a coleção de conjuntos de dados de preferência.

Alguns conjuntos de dados de preferências podem ser encontrados com a tag dpo no Hugging Face Hub. Você também pode explorar as Coleções DPO dos librarian-bots para identificar conjuntos de dados de preferências.

Preferência não pareada

Um conjunto de dados de preferências não pareado é semelhante a um conjunto de dados de preferências, mas, em vez de ter conclusões "chosen" e "rejected" para o mesmo prompt, ele inclui uma única "completion" e um "label" indicando se a conclusão é preferida ou não.

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

Para exemplos de conjuntos de dados de preferências não pareadas, consulte a coleção de conjuntos de dados de preferências não pareadas.

Qual tipo de conjunto de dados usar?

A escolha do tipo de dataset adequado depende da tarefa em que você está trabalhando e dos requisitos específicos do treinador do TRL que você está usando. Abaixo, há uma breve visão geral dos tipos de dataset suportados por cada treinador do TRL.

Usando qualquer conjunto de dados com TRL: pré-processamento e conversão

Muitos conjuntos de dados vêm em formatos adaptados a tarefas específicas, que podem não ser diretamente compatíveis com o TRL. Para usar esses conjuntos de dados com o TRL, você pode precisar pré-processá-los e convertê-los para o formato necessário.

Para facilitar isso, fornecemos um conjunto de scripts de exemplo que cobrem conversões comuns de conjuntos de dados.

Exemplo: conjunto de dados UltraFeedback

Vamos usar o conjunto de dados UltraFeedback como exemplo. Aqui está uma prévia do conjunto de dados:

Como mostrado acima, o formato do conjunto de dados não corresponde à estrutura esperada. Ele não está em um formato conversacional, os nomes das colunas diferem e os resultados se referem a modelos diferentes (por exemplo, Bard, GPT-4) e aspectos (por exemplo, “helpfulness”, “honesty”).

Ao usar o script de conversão fornecido examples/datasets/ultrafeedback.py, você pode transformar este conjunto de dados em um tipo de preferência não pareado e enviá-lo para o Hub:

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

Uma vez convertido, o conjunto de dados ficará assim:

Agora, você pode usar esse conjunto de dados com o TRL!

Ao adaptar os scripts fornecidos ou criar os seus próprios, você pode converter qualquer conjunto de dados para um formato compatível com o TRL.

Utilitários para conversão de tipos de conjunto de dados

Esta seção fornece código de exemplo para ajudar você a converter entre diferentes tipos de conjunto de dados. Embora algumas conversões possam ser realizadas após a aplicação do modelo de chat (ou seja, no formato padrão), recomendamos realizar a conversão antes de aplicar o modelo de chat para garantir que funcione de forma consistente.

Por simplicidade, alguns dos exemplos abaixo não seguem essa recomendação e usam o formato padrão. No entanto, as conversões podem ser aplicadas diretamente ao formato conversacional sem modificação.

De prompt-completion para dataset de modelagem de linguagem

Para converter um conjunto de dados de prompt-complemento em um conjunto de dados de modelagem de linguagem, concatene o prompt e o complemento.

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 dataset de prompt-completion para dataset apenas de prompt

Para converter um conjunto de dados de prompt-complemento em um conjunto de dados apenas de prompt, remova o complemento.

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 preferência com prompt implícito para conjunto de dados de modelagem de linguagem

Para converter um conjunto de dados de preferências com prompt implícito em um conjunto de dados de modelagem de linguagem, remova o rejeitado e renomeie a coluna "chosen" para "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 preferência com prompt implícito para conjunto de dados de prompt-complemento

Para converter um conjunto de dados de preferências com prompt implícito em um conjunto de dados de prompt-completion, extraia o prompt com extract_prompt(), remova o rejeitado e renomeie a coluna "chosen" para "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 preferência com prompt implícito para dataset apenas com prompt

Para converter um conjunto de dados de preferências com prompt implícito em um conjunto de dados apenas com prompt, extraia o prompt com extract_prompt() e remova os rejeitados e os escolhidos.

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 preferência de prompt implícita a explícita

Para converter um conjunto de dados de preferências com prompt implícito em um conjunto de dados de preferências com prompt explícito, extraia o prompt com 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 preferência com prompt implícito para conjunto de dados de preferência não pareado

Para converter um conjunto de dados de preferências com prompt implícito em um conjunto de dados de preferências não pareado, extraia o prompt com extract_prompt() e despareie o conjunto de dados com 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}

Lembre-se de que as conclusões "chosen" e "rejected" em um conjunto de dados de preferências podem ser ambas boas ou ruins. Antes de aplicar unpair_preference_dataset(), verifique se todas as conclusões "chosen" podem ser classificadas como boas e todas as conclusões "rejected" como ruins. Isso pode ser garantido verificando a avaliação absoluta de cada conclusão, por exemplo, a partir de um modelo de recompensa.

De dataset de preferência para dataset de modelagem de linguagem

Para converter um conjunto de dados de preferências em um conjunto de dados de modelagem de linguagem, remova o rejeitado e concatene o prompt e o escolhido na coluna "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 dados de preferência a dados de prompt-completion

Para converter um conjunto de dados de preferências em um conjunto de dados de prompt-completion, remova o rejeitado e renomeie a coluna "chosen" para "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 preferência para dataset apenas com prompt

Para converter um conjunto de dados de preferências em um conjunto de dados apenas com prompts, remova os rejeitados e os escolhidos.

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'}

De preferência de prompt explícita para preferência de prompt implícita

Para converter um conjunto de dados de preferências com prompt explícito em um conjunto de dados de preferências com prompt implícito, concatene o prompt tanto ao escolhido quanto ao rejeitado e remova o 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 preferência para conjunto de dados de preferência não pareado

Para converter um dataset em um dataset de preferências não pareadas, despareie o dataset com unpair_preference_dataset().

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}

Lembre-se de que as conclusões "chosen" e "rejected" em um conjunto de dados de preferências podem ser ambas boas ou ruins. Antes de aplicar unpair_preference_dataset(), verifique se todas as conclusões "chosen" podem ser classificadas como boas e todas as conclusões "rejected" como ruins. Isso pode ser garantido verificando a avaliação absoluta de cada conclusão, por exemplo, a partir de um modelo de recompensa.

De conjunto de dados de preferências não pareadas a conjunto de dados de modelagem de linguagem

Para converter um conjunto de dados de preferências não pareado em um conjunto de dados de modelagem de linguagem, concatene os prompts com as boas conclusões na coluna "text" e remova as colunas de prompt, conclusão e rótulo.

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 preferências não pareadas para um conjunto de dados de prompt-complemento

Para converter um conjunto de dados de preferências não pareado em um conjunto de dados de prompt-completion, filtre pelos bons rótulos e, em seguida, remova as colunas de rótulos.

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 um conjunto de dados de preferências não pareadas para um conjunto de dados apenas com prompts

Para converter um conjunto de dados de preferências não pareado em um conjunto de dados apenas com prompts, remova as colunas de conclusão e rótulo.

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'}

Conjuntos de dados de visão

Alguns treinadores também suportam o ajuste fino de modelos de visão-linguagem (VLMs) usando pares de imagem-texto. Nesse cenário, é recomendado usar um formato conversacional, pois cada modelo trata os marcadores de posição de imagem no texto de maneira diferente.

Um conjunto de dados de visão conversacional difere de um conjunto de dados conversacional padrão em duas maneiras principais:

1. O conjunto de dados deve conter a chave images com os dados das imagens (como listas de imagens PIL) ou image com uma única imagem PIL.
2. O campo "content" nas mensagens deve ser uma lista de dicionários, em que cada dicionário especifica o tipo de dados: "image" ou "text".

Exemplo:

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

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

Um exemplo de um conjunto de dados de visão conversacional é o openbmb/RLAIF-V-Dataset. Abaixo está uma visualização incorporada dos dados de treinamento do conjunto de dados, permitindo que você o explore diretamente:

Misturar dados apenas de texto e dados de visão-linguagem no conjunto de dados é possível, mas requer a versão 4.57.0 ou posterior do transformers. Exemplo:

Copiado

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")],
        [],
    ],
})