Formatos y tipos de conjuntos de datos

Esta guía ofrece una visión general de los formatos y tipos de conjuntos de datos admitidos por cada entrenador en TRL.

Resumen de los formatos y tipos de conjuntos de datos

• El formato de un conjunto de datos se refiere a cómo se estructura la información, y generalmente se clasifica como estándar o conversacional.
• El type está asociado con la tarea específica para la que está diseñado el conjunto de datos, como prompt-only o preference. Cada tipo se caracteriza por sus columnas, que varían según la tarea, como se muestra en la tabla.

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

Estándar

El formato estándar de los conjuntos de datos suele consistir en cadenas de texto plano. Las columnas del conjunto de datos varían según la tarea. Este es el formato que esperan los entrenadores de TRL. A continuación se muestran ejemplos de formatos estándar de conjuntos de datos para diferentes tareas:

# 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

Los conjuntos de datos conversacionales se utilizan para tareas que implican diálogos o interacciones de chat entre usuarios y asistentes. A diferencia de los formatos estándar de conjuntos de datos, estos contienen secuencias de mensajes en los que cada mensaje tiene un role (p. ej., "user" o "assistant") y content (el texto del mensaje).

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

Al igual que en los conjuntos de datos estándar, las columnas en los conjuntos de datos conversacionales varían según la tarea. A continuación se muestran ejemplos de formatos de conjuntos de datos conversacionales para diferentes tareas:

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

Llamada a herramientas

Algunas plantillas de chat admiten llamadas a herramientas, lo que permite que el modelo interactúe con funciones externas, denominadas herramientas, durante la generación. Esto amplía las capacidades conversacionales del modelo al permitirle emitir un campo "tool_calls" en lugar de un mensaje estándar de "content" siempre que decida invocar una herramienta.

Después de que el asistente inicie una llamada a una herramienta, la herramienta se ejecuta y devuelve su salida. A continuación, el asistente puede procesar esta salida y continuar la conversación en consecuencia.

Aquí hay un ejemplo sencillo de una interacción de llamada a herramientas:

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

Al preparar conjuntos de datos para el ajuste fino supervisado (SFT) con llamadas a herramientas, es importante que el conjunto de datos incluya una columna adicional llamada tools. Esta columna contiene la lista de herramientas disponibles para el modelo, que normalmente se utiliza en la plantilla de chat para construir el prompt del sistema.

Las herramientas deben especificarse en un formato de esquema JSON codificado. Puede generar automáticamente este esquema a partir de las firmas de funciones de Python utilizando la utilidad 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)

El esquema generado tendría el siguiente aspecto:

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

Una entrada completa del conjunto de datos para SFT podría verse así:

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

Para obtener un Dataset es necesario usar el tipo Json() para los argumentos de la herramienta, ya que son objetos JSON arbitrarios y no diccionarios con campos y tipos fijos:

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)

En versiones anteriores de datasets (<4.7.0) que no tienen el tipo Json(), debes almacenar tools como un str JSON (con json.dumps([...])):

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

Para obtener información más detallada sobre la invocación de herramientas, consulte la sección de Tool Calling en la documentación de transformers y la publicación de blog Tool Use, Unified.

Harmony

El formato de respuesta Harmony se introdujo con los modelos OpenAI GPT OSS. Extiende el formato conversacional añadiendo una estructura más rica para el razonamiento, las llamadas a funciones y los metadatos sobre el comportamiento del modelo. Sus características principales incluyen:

• Rol de desarrollador – Proporciona instrucciones de alto nivel (similares a un prompt de sistema) y enumera las herramientas disponibles.

• Canales – Separa los distintos tipos de salida del asistente en flujos independientes:

  • analysis – para el razonamiento interno, desde la clave "thinking"
  • final – para la respuesta dirigida al usuario, desde la clave "content"
  • commentary – para llamadas a herramientas o notas meta

• Esfuerzo de razonamiento – Indica cuánto razonamiento debe mostrar el modelo (p. ej., "low", "medium", "high").

• Identidad del modelo – Define explícitamente la persona del asistente.

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

Esto produce:

<|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 obtener todos los detalles sobre la estructura de los mensajes, los campos admitidos y el uso avanzado, consulte la documentación de Harmony.

Tipos

Modelado de lenguaje

Un conjunto de datos de modelado de lenguaje consiste en una columna "text" (o "messages" para conjuntos de datos conversacionales) que contiene una secuencia 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."}
]}

Solo prompt

En un conjunto de datos solo de prompts, solo se proporciona el prompt inicial (la pregunta o la oración parcial) bajo la clave "prompt". El entrenamiento suele implicar generar una finalización basada en este prompt, donde el modelo aprende a continuar o completar la entrada dada.

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

Para ver ejemplos de conjuntos de datos solo de prompts, consulte la colección de conjuntos de datos solo de prompts.

Aunque los tipos solo de prompt y de modelado de lenguaje son similares, difieren en cómo se maneja la entrada. En el tipo solo de prompt, el prompt representa una entrada parcial que espera que el modelo la complete o continúe, mientras que en el tipo de modelado de lenguaje, la entrada se trata como una oración o secuencia completa. TRL procesa estos dos tipos de manera diferente. A continuación se muestra un ejemplo que ilustra la diferencia en la salida de la función 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|>'}

• La salida solo de prompt incluye un '<|assistant|>\n', que indica el inicio del turno del asistente y espera que el modelo genere una continuación.
• En cambio, la salida de modelado de lenguaje trata la entrada como una secuencia completa y la termina con '<|endoftext|>', señalando el final del texto y sin esperar contenido adicional.

Prompt-completación

Un conjunto de datos de prompt-completación incluye un "prompt" y una "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 ver ejemplos de conjuntos de datos de prompt-completado, consulte la colección de conjuntos de datos de prompt-completado.

Preferencia

Un conjunto de datos de preferencias se utiliza para tareas en las que el modelo se entrena para elegir entre dos o más posibles finalizaciones para el mismo prompt. Este conjunto de datos incluye un "prompt", una finalización "chosen" y una finalización "rejected". El modelo se entrena para seleccionar la respuesta "chosen" sobre la respuesta "rejected". Algunos conjuntos de datos pueden no incluir la columna "prompt", en cuyo caso el prompt es implícito y se incluye directamente en las finalizaciones "chosen" y "rejected". Recomendamos usar prompts explícitos siempre que sea posible.

# 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 ver ejemplos de conjuntos de datos de preferencias, consulte la colección de conjuntos de datos de preferencias.

Algunos conjuntos de datos de preferencias se pueden encontrar con la etiqueta dpo en Hugging Face Hub. También puedes explorar las colecciones DPO de los librarian-bots para identificar conjuntos de datos de preferencias.

Preferencia no emparejada

Un conjunto de datos de preferencias no emparejadas es similar a un conjunto de datos de preferencias, pero en lugar de tener completados "chosen" y "rejected" para el mismo prompt, incluye un único "completion" y una "label" que indica si el completado es preferido o no.

# 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 ver ejemplos de conjuntos de datos de preferencias no emparejadas, consulte la colección de conjuntos de datos de preferencias no emparejadas.

¿Qué tipo de conjunto de datos usar?

La elección del tipo de dataset adecuado depende de la tarea en la que esté trabajando y de los requisitos específicos del entrenador de TRL que utilice. A continuación se presenta un breve resumen de los tipos de dataset admitidos por cada entrenador de TRL.

Uso de cualquier conjunto de datos con TRL: preprocesamiento y conversión

Muchos conjuntos de datos vienen en formatos adaptados a tareas específicas, que podrían no ser directamente compatibles con TRL. Para usar dichos conjuntos de datos con TRL, es posible que necesites preprocesarlos y convertirlos al formato requerido.

Para facilitar esto, proporcionamos un conjunto de scripts de ejemplo que cubren conversiones de conjuntos de datos comunes.

Ejemplo: conjunto de datos UltraFeedback

Tomemos el conjunto de datos UltraFeedback como ejemplo. Aquí hay una vista previa del conjunto de datos:

Como se muestra arriba, el formato del conjunto de datos no coincide con la estructura esperada. No está en un formato conversacional, los nombres de las columnas son diferentes y los resultados corresponden a modelos distintos (p. ej., Bard, GPT-4) y aspectos (p. ej., “helpfulness”, “honesty”).

Al utilizar el script de conversión proporcionado examples/datasets/ultrafeedback.py, puede transformar este conjunto de datos en un tipo de preferencia no emparejada y publicarlo en el Hub:

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

Una vez convertido, el conjunto de datos se verá así:

Ahora, ¡puedes usar este conjunto de datos con TRL!

Adaptando los scripts proporcionados o creando los propios, se puede convertir cualquier conjunto de datos en un formato compatible con TRL.

Utilidades para convertir tipos de conjunto de datos

Esta sección proporciona código de ejemplo para ayudarte a convertir entre diferentes tipos de conjuntos de datos. Si bien algunas conversiones se pueden realizar después de aplicar la plantilla de chat (es decir, en el formato estándar), recomendamos realizar la conversión antes de aplicar la plantilla de chat para garantizar que funcione de manera consistente.

Por simplicidad, algunos de los ejemplos a continuación no siguen esta recomendación y utilizan el formato estándar. Sin embargo, las conversiones pueden aplicarse directamente al formato conversacional sin modificación.

De prompt-completion a dataset de modelado de lenguaje

Para convertir un conjunto de datos de prompt-completado en un conjunto de datos de modelado de lenguaje, concatene el prompt y el completado.

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 un conjunto de datos de prompt-completado a un conjunto de datos solo de prompts

Para convertir un conjunto de datos de prompt-completado en un conjunto de datos solo de prompt, elimine el completado.

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 preferencia con prompt implícito a conjunto de datos de modelado de lenguaje

Para convertir un conjunto de datos de preferencias con prompt implícito en un conjunto de datos de modelado de lenguaje, elimine el rechazado y cambie el nombre de la columna "chosen" a "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 preferencia con prompt implícito a dataset de prompt-completado

Para convertir un conjunto de datos de preferencias con un prompt implícito en un conjunto de datos de prompt-completion, extraiga el prompt con extract_prompt(), elimine el rechazado y cambie el nombre de la columna "chosen" a "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 preferencia con prompt implícito a dataset solo de prompts

Para convertir un conjunto de datos de preferencias con un prompt implícito en un conjunto de datos solo de prompts, extraiga el prompt con extract_prompt() y elimine los rechazados y los elegidos.

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 un conjunto de datos de preferencia de prompts implícito a uno explícito

Para convertir un conjunto de datos de preferencias con un prompt implícito en un conjunto de datos de preferencias con un prompt explícito, extraiga el prompt con 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 preferencia con prompt implícito a conjunto de datos de preferencia no emparejado

Para convertir un conjunto de datos de preferencias con un prompt implícito en un conjunto de datos de preferencias no emparejadas, extraiga el prompt con extract_prompt() y despareje el conjunto de datos con 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}

Tenga en cuenta que las completaciones "chosen" y "rejected" en un conjunto de datos de preferencias pueden ser ambas buenas o malas. Antes de aplicar unpair_preference_dataset(), asegúrese de que todas las completaciones "chosen" puedan etiquetarse como buenas y todas las completaciones "rejected" como malas. Esto puede garantizarse comprobando la calificación absoluta de cada completación, por ejemplo, a partir de un modelo de recompensa.

De conjunto de datos de preferencias a conjunto de datos de modelado de lenguaje

Para convertir un conjunto de datos de preferencias en un conjunto de datos de modelado de lenguaje, elimine los rechazados y concatene el prompt y el elegido en la columna "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 conjunto de datos de preferencias a conjunto de datos de completado de prompts

Para convertir un conjunto de datos de preferencias en un conjunto de datos de prompt-completion, elimine los rechazados y cambie el nombre de la columna "chosen" a "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 preferencia a solo dataset de prompts

Para convertir un conjunto de datos de preferencias en un conjunto de datos solo de prompts, elimine los rechazados y los elegidos.

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 un conjunto de datos de preferencia de prompts explícitos a uno implícito

Para convertir un conjunto de datos de preferencias con explícito en un conjunto de datos de preferencias con implícito, concatene el prompt tanto a chosen como a rejected y elimine el 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 preferencia a conjunto de datos de preferencia no emparejada

Para convertir un dataset en un dataset de preferencias no emparejadas, desempareje el dataset con 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}

Tenga en cuenta que las completaciones "chosen" y "rejected" en un conjunto de datos de preferencias pueden ser ambas buenas o malas. Antes de aplicar unpair_preference_dataset(), asegúrese de que todas las completaciones "chosen" puedan etiquetarse como buenas y todas las completaciones "rejected" como malas. Esto puede garantizarse comprobando la calificación absoluta de cada completación, por ejemplo, a partir de un modelo de recompensa.

De un conjunto de datos de preferencias no emparejadas a un conjunto de datos de modelado de lenguaje

Para convertir un conjunto de datos de preferencias no emparejadas en un conjunto de datos de modelado de lenguaje, concatene los prompts con las finalizaciones buenas en la columna "text" y elimine las columnas de prompt, finalización y etiqueta.

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 un conjunto de datos de preferencias no emparejadas a un conjunto de datos de prompt-completado

Para convertir un conjunto de datos de preferencias no emparejadas en un conjunto de datos de prompt-completion, filtre por etiquetas buenas y luego elimine las columnas de etiquetas.

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 un conjunto de datos de preferencias no emparejadas a un conjunto de datos solo de indicaciones

Para convertir un conjunto de datos de preferencias no emparejadas en un conjunto de datos solo de prompts, elimine las columnas de completion y 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],
})

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

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

Conjuntos de datos de visión

Algunos entrenadores también admiten el ajuste fino de modelos de visión-lenguaje (VLM) mediante pares de imagen-texto. En este escenario, se recomienda utilizar un formato conversacional, ya que cada modelo maneja los marcadores de posición de imagen en el texto de manera diferente.

Un conjunto de datos conversacional de visión difiere de un conjunto de datos conversacional estándar en dos aspectos clave:

1. El conjunto de datos debe contener la clave images con los datos de las imágenes (como listas de imágenes PIL) o image con una única imagen PIL.
2. El campo "content" en los mensajes debe ser una lista de diccionarios, donde cada diccionario especifica el tipo de datos: "image" o "text".

Ejemplo:

# 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 ejemplo de un conjunto de datos de visión conversacional es openbmb/RLAIF-V-Dataset. A continuación se muestra una vista integrada de los datos de entrenamiento del conjunto de datos, lo que le permite explorarlos directamente:

Es posible mezclar datos solo de texto y datos de visión-lenguaje en el conjunto de datos, pero se requiere la versión 4.57.0 o posterior de transformers. Ejemplo:

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