Modelado de recompensas

Resumen

TRL admite el Trainer de modelado de recompensas supervisado por resultados (ORM) para entrenar modelos de recompensa.

Este método de post-entrenamiento fue aportado por Younes Belkada.

Inicio rápido

Este ejemplo muestra cómo entrenar un modelo de recompensa utilizando RewardTrainer de TRL. Entrenamos un modelo Qwen 3 0.6B en el UltraFeedback dataset, un conjunto de datos de preferencias a gran escala, de gran granularidad y diverso.

from trl import RewardTrainer
from datasets import load_dataset

trainer = RewardTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/ultrafeedback_binarized", split="train"),
)
trainer.train()

Tipo y formato de datos esperados

RewardTrainer admite el tipo de conjunto de datos preference (tanto con indicaciones implícitas como explícitas). RewardTrainer es compatible con los formatos de conjunto de datos standard y conversational. Cuando se proporciona un conjunto de datos conversacional, el entrenador aplica automáticamente la plantilla de chat al conjunto de datos.

# Standard preference (implicit prompt)
{"chosen": "The sky is blue.",
 "rejected": "The sky is green."}

# Conversational preference (implicit prompt)
{"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."}]}

# Standard preference (explicit prompt)
{"prompt": "The sky is",
 "chosen": " blue.",
 "rejected": " green."}

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

Si tu conjunto de datos no está en uno de estos formatos, puedes preprocesarlo para convertirlo al formato esperado. Aquí tienes un ejemplo con el conjunto de datos lmarena-ai/arena-human-preference-55k:

from datasets import load_dataset
import json

dataset = load_dataset("lmarena-ai/arena-human-preference-55k")

# Filter out ties
dataset = dataset.filter(lambda example: example["winner_tie"] == 0)

# Create 'chosen' and 'rejected' fields based on the winner column
def response_a_b_to_chosen_rejected(example):
    if example["winner_model_a"] == 1:
        example["chosen"] = example["response_a"]
        example["rejected"] = example["response_b"]
    else:
        example["chosen"] = example["response_b"]
        example["rejected"] = example["response_a"]
    return example

dataset = dataset.map(response_a_b_to_chosen_rejected)

# Convert to conversational format
def make_conversation(example):
    prompt = json.loads(example["prompt"])[0]  # '["What color is the sky?"]' -> "What color is the sky?"
    chosen = json.loads(example["chosen"])[0]
    rejected = json.loads(example["rejected"])[0]
    return {
        "chosen": [{"role": "user", "content": prompt}, {"role": "assistant", "content": chosen}],
        "rejected": [{"role": "user", "content": prompt}, {"role": "assistant", "content": rejected}],
    }


dataset = dataset.map(make_conversation)

# Keep only necessary columns
dataset = dataset.select_columns(["chosen", "rejected"])

print(next(iter(dataset["train"])))

{
    "chosen": [
        {"role": "user", "content": "Is it morally right to try to have a certain percentage of females on managerial positions?"},
        {"role": "assistant", "content": "The question of whether it is morally right to aim for a certain percentage of females..."},
    ],
    "rejected": [
        {"role": "user", "content": "Is it morally right to try to have a certain percentage of females on managerial positions?"},
        {"role": "assistant", "content": "As an AI, I don't have personal beliefs or opinions. However, ..."},
    ],
}

Mirando más a fondo el método de entrenamiento

Los modelos de recompensa (RMs) suelen entrenarse mediante aprendizaje supervisado en conjuntos de datos que contienen pares de respuestas preferidas y no preferidas. El objetivo es aprender una función que asigne puntuaciones más altas a las respuestas preferidas, lo que permite al modelo clasificar las salidas en función de las preferencias.

Esta sección detalla cómo funciona la modelización de recompensas en la práctica, cubriendo los pasos clave: preprocesamiento y cálculo de la pérdida.

Preprocesamiento y tokenización

Durante el entrenamiento, se espera que cada ejemplo contenga un campo chosen y un campo rejected. Para más detalles sobre los formatos esperados, consulte Dataset formats - Preference. El RewardTrainer tokeniza cada entrada utilizando el tokenizador del modelo. Si los prompts y las completions (chosen y rejected) se proporcionan por separado (caso de prompt explícito), se concatenan antes de la tokenización.

Cálculo de la pérdida

Sea $x$ la secuencia de entrada (prompt) y $y^+$ y $y^-$ las secuencias elegida y rechazada, respectivamente. Bajo el modelo de Bradley-Terry (Bradley & Terry, 1952), la probabilidad de que $y^+$ sea preferida a $y^-$ dada una función de recompensa $r$ es $p(y^+ ≻ y^- |x) = \sigma(r(x, y^+)−r(x, y^-))$ , donde $σ$ es la función sigmoide.

El modelo de recompensa $r_\theta(x, y)$ se entrena para asignar puntuaciones más altas a las respuestas preferidas $y^+$ que a las no preferidas $y^-$ . La pérdida se define entonces como la verosimilitud negativa de las preferencias observadas: $\mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \right].$

El modelo Bradley-Terry está subdeterminado, lo que significa que añadir una constante a todas las recompensas no cambia las probabilidades de preferencia. Para abordar esto, Helping or Herding? Reward Model Ensembles Mitigate but do not Eliminate Reward Hacking propone añadir un término de pérdida auxiliar que anima a que las recompensas se centren en torno a cero. Esto se controla mediante el parámetro center_rewards_coefficient en RewardConfig. El valor recomendado es 1e-2.

Métricas registradas

Durante el entrenamiento y la evaluación, registramos las siguientes métricas:

global_step: El número total de pasos del optimizador realizados hasta el momento.
epoch: El número de época actual, basado en la iteración del conjunto de datos.
num_tokens: El número total de tokens procesados hasta el momento.
loss: La pérdida promedio durante el último intervalo de registro.
accuracy: La proporción de predicciones correctas (es decir, el modelo asignó una puntuación más alta a la respuesta elegida que a la rechazada) promediada en el último intervalo de registro.
min_reward: La puntuación mínima de recompensa asignada por el modelo. Este valor se promedia durante el intervalo de registro.
mean_reward: La puntuación de recompedia promedio asignada por el modelo durante el último intervalo de registro.
max_reward: La puntuación de recompensa máxima asignada por el modelo. Este valor se promedia durante el intervalo de registro.
margin: el margen medio (diferencia entre las recompensas elegidas y rechazadas) durante el último intervalo de registro.
learning_rate: la tasa de aprendizaje actual, que puede cambiar dinámicamente si se utiliza un programador.
grad_norm: La norma L2 de los gradientes, calculada antes del recorte de gradientes.

Personalización

Inicialización del modelo

Puede pasar directamente los kwargs del método from_pretrained() a RewardConfig. Por ejemplo, si desea cargar un modelo en una precisión diferente, de manera análoga a

model = AutoModelForSequenceClassification.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)

puede hacerlo pasando el argumento model_init_kwargs={"dtype": torch.bfloat16} a RewardConfig.

from trl import RewardConfig

training_args = RewardConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)

Tenga en cuenta que se admiten todos los argumentos de palabra clave de from_pretrained(), excepto num_labels, que se establece automáticamente en 1.

Entrenar adaptadores con PEFT

Soportamos una integración estrecha con la biblioteca 🤗 PEFT, lo que permite a cualquier usuario entrenar adaptadores de manera conveniente y compartirlos en el Hub, en lugar de entrenar el modelo completo.

from datasets import load_dataset
from trl import RewardTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = RewardTrainer(
    "Qwen/Qwen3-4B",
    train_dataset=dataset,
    peft_config=LoraConfig(modules_to_save=["score"])  # important to include the score head when base model is not a sequence classification model
)

trainer.train()

También puedes continuar entrenando tu PeftModel. Para ello, primero carga un PeftModel fuera de RewardTrainer y pásalo directamente al trainer sin pasar el argumento peft_config.

from datasets import load_dataset
from trl import RewardTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-Reward-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = RewardTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()

Al entrenar adaptadores, normalmente se utiliza una tasa de aprendizaje más alta (≈1e‑3) ya que solo se están aprendiendo parámetros nuevos.
RewardConfig(learning_rate=1e-3, ...)

Llamadas a herramientas con modelado de recompensas

El RewardTrainer admite por completo el ajuste fino de modelos con capacidades de tool calling. En este caso, cada ejemplo del conjunto de datos debe incluir:

Los mensajes de la conversación, incluidos los llamados a herramientas (tool_calls) y las respuestas de herramientas (mensajes con el rol tool)
La lista de herramientas disponibles en la columna tools, generalmente proporcionada como esquemas JSON

Para obtener detalles sobre la estructura esperada del conjunto de datos, consulte la sección Formato de conjunto de datos — Llamadas a herramientas.

RewardTrainer

clase trl.RewardTrainer

< source >

( model: str | PreTrainedModel | PeftModelargs: trl.trainer.reward_config.RewardConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = Nonepreprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonequantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

Parámetros

model (str o PreTrainedModel o PeftModel) — Modelo a entrenar. Puede ser:
- Una cadena, que es el model id de un modelo preentrenado alojado en un repositorio de modelos en huggingface.co, o una ruta a un directorio que contiene los pesos del modelo guardados con save_pretrained, por ejemplo, './my_model_directory/'. El modelo se carga usando AutoModelForSequenceClassification.from_pretrained con los argumentos de palabra clave en args.model_init_kwargs. Si dtype no se especifica en args.model_init_kwargs, el valor predeterminado es float32. Esto difiere de from_pretrained, donde (desde Transformers v5) el dtype se infiere de la configuración del modelo.
- Un objeto PreTrainedModel de clasificación de secuencias.
- Un objeto PeftModel de clasificación de secuencias.
args (RewardConfig, opcional) — Configuración para este entrenador. Si es None, se utiliza una configuración predeterminada.
data_collator (DataCollator, opcional) — Función para formar un lote a partir de una lista de elementos del train_dataset o eval_dataset procesado. Por defecto, se usa DataCollatorForPreference.
train_dataset (Dataset o IterableDataset) — Conjunto de datos para usar en el entrenamiento. Este trainer admite preferencia tipo (tanto prompts implícitos como explícitos). El formato de las muestras puede ser:
- Estándar: Cada muestra contiene texto plano.
- Conversacional: Cada muestra contiene mensajes estructurados (p. ej., rol y contenido).
El trainer también admite conjuntos de datos procesados (tokenizados) siempre que contengan los campos chosen_ids y rejected_ids.

Cuando train_dataset es un IterableDataset (por ejemplo, un dataset de streaming), max_steps debe establecerse en los argumentos de entrenamiento, ya que su longitud no se puede inferir y se requiere el número total de pasos de entrenamiento para acotar el bucle de entrenamiento y configurar el programador de tasa de aprendizaje.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict o dict[str, Dataset | IterableDataset]) — Conjunto de datos para usar en la evaluación. Debe cumplir los mismos requisitos que train_dataset.
processing_class (PreTrainedTokenizerBase, opcional) — Tokenizer utilizado para procesar los datos. Si es None, el tokenizer se carga desde el nombre del modelo con from_pretrained. Debe establecerse un token de relleno, processing_class.pad_token. Si la clase de procesamiento no ha establecido un token de relleno, se utilizará processing_class.eos_token como valor predeterminado.
compute_metrics (Callable[[EvalPrediction], dict], opcional) — La función que se utilizará para calcular métricas durante la evaluación. Debe recibir un EvalPrediction y devolver un diccionario de cadenas a valores de métricas. Al pasar RewardConfig con batch_eval_metrics establecido en True, su función compute_metrics debe recibir un argumento booleano compute_result. Esto se activará después del último lote de evaluación para indicar que la función debe calcular y devolver las estadísticas de resumen globales en lugar de acumular las estadísticas a nivel de lote.
callbacks (lista de TrainerCallback, opcional) — Lista de callbacks para personalizar el bucle de entrenamiento. Se añadirán a la lista de callbacks predeterminados detallada en aquí.
Si deseas eliminar uno de los callbacks predeterminados, utiliza el método remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opcional, por defecto (None, None)) — Una tupla que contiene el optimizador y el programador a utilizar. Por defecto, se utilizará una instancia de AdamW en su modelo y un programador dado por get_linear_schedule_with_warmup controlado por args.
optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], opcional) — Una tupla que contiene la clase del optimizador y los argumentos de palabra clave a utilizar. Anula optim y optim_args en args. No es compatible con el argumento optimizers .
A diferencia de optimizers, este argumento evita la necesidad de colocar los parámetros del modelo en los dispositivos correctos antes de inicializar el Trainer.
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], opcional) — Una función que preprocesa los logits justo antes de almacenarlos en caché en cada paso de evaluación. Debe aceptar dos tensores, los logits y las etiquetas, y devolver los logits una vez procesados según se desee. Las modificaciones realizadas por esta función se reflejarán en las predicciones recibidas por compute_metrics.
Tenga en cuenta que las etiquetas (segundo parámetro) serán None si el conjunto de datos no las tiene.
quantization_config (BitsAndBytesConfig, opcional) — Configuración de cuantización utilizada al cargar el modelo desde un identificador de modelo. Combínala con peft_config para el entrenamiento QLoRA. Se ignora si el modelo ya está instanciado, o si quantization_config también está establecido en args.model_init_kwargs.
peft_config (PeftConfig, opcional) — Configuración de PEFT utilizada para envolver el modelo. Si es None, el modelo no se envuelve. Tenga en cuenta que si el modelo cargado es un LM causal, se recomienda encarecidamente establecer modules_to_save=["score"] en la configuración de PEFT para garantizar que la cabeza de recompensa se entrene correctamente.

Trainer para modelos de recompensa supervisados por resultados (ORM).

Esta clase es un envoltorio de la clase Trainer y hereda todos sus atributos y métodos.

Ejemplo:

>>> from trl import RewardTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

>>> trainer = RewardTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()

entrenar

< source >

Parámetros

resume_from_checkpoint (str o bool, opcional) — Si es una str, ruta local a un punto de control guardado por una instancia anterior de Trainer. Si es un bool y es igual a True, carga el último punto de control en args.output_dir guardado por una instancia anterior de Trainer. Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí.
trial (optuna.Trial o dict[str, Any], opcional) — La ejecución del ensayo o el diccionario de hiperparámetros para la búsqueda de hiperparámetros.
ignore_keys_for_eval (list[str], opcional) — Una lista de claves en la salida de tu modelo (si es un diccionario) que deben ignorarse al recopilar predicciones para la evaluación durante el entrenamiento.

Devuelve

~trainer_utils.TrainOutput

Objeto que contiene el número de pasos globales, la pérdida de entrenamiento y las métricas.

Punto de entrada principal del entrenamiento.

save_model

< source >

( output_dir: str | None = None_internal_call: bool = False )

Guardará el modelo, por lo que podrás recargarlo usando from_pretrained().

Solo se guardará desde el proceso principal.

push_to_hub

< source >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

Parámetros

commit_message (str, opcional, valor predeterminado "End of training") — Mensaje para el commit al hacer push.
blocking (bool, opcional, valor predeterminado True) — Si la función debe devolver el control solo cuando el git push haya terminado.
token (str, opcional, valor predeterminado None) — Token con permiso de escritura para sobrescribir los argumentos originales de Trainer.
revision (str, opcional) — La revisión de git desde la que se realizará el commit. Por defecto, es la cabecera de la rama “main”.
private (bool, opcional) — Si se debe hacer el repositorio privado cuando se crea. El valor predeterminado es args.hub_private_repo. No tiene efecto si el repositorio ya existe.
kwargs (dict[str, Any], opcional) — Argumentos de palabra clave adicionales que se pasan a ~Trainer.create_model_card.

Sube self.model y self.processing_class al hub de modelos de 🤗 en el repositorio self.args.hub_model_id.

RewardConfig

clase trl.RewardConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 0.0001lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool | None = Nonefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool = Truegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 10logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list[str] = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: accelerate.parallelism_config.ParallelismConfig | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falsechat_template_path: str | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Noneeos_token: str | None = Nonemax_length: int | None = 1024pad_to_multiple_of: int | str | None = 'auto'center_rewards_coefficient: float | None = Noneactivation_offloading: bool = Falsepad_token: str | None = None )

Parámetros que controlan el modelo

model_init_kwargs (dict[str, Any], opcional) — Argumentos de palabra clave para from_pretrained, utilizados cuando el argumento model de RewardTrainer se proporciona como una cadena de caracteres. El valor de revision también se utiliza al cargar el tokenizador.
trust_remote_code (bool, opcional, valor predeterminado False) — Si se permite cargar modelos y tokenizadores que incluyen código Python personalizado desde el Hub. Se reenvía a from_pretrained y from_pretrained.
chat_template_path (str, opcional) — Si se especifica, establece la plantilla de chat del modelo. Puede ser la ruta a un tokenizador (directorio local o modelo de Hugging Face Hub) o una ruta directa a un archivo de plantilla Jinja. Al usar un archivo Jinja, debe asegurarse de que los tokens especiales referenciados en la plantilla se añadan al tokenizador y de que la capa de incrustación del modelo se redimensione en consecuencia.
disable_dropout (bool, opcional, valor predeterminado True) — Si se debe deshabilitar el dropout en el modelo.

Parámetros que controlan el preprocesamiento de datos

dataset_num_proc (int, opcional) — Número de procesos a utilizar para procesar el conjunto de datos.
eos_token (str, opcional) — Token utilizado para indicar el final de un turno o secuencia. Si es None, el valor predeterminado es processing_class.eos_token.
max_length (int o None, opcional, valor predeterminado 1024) — Longitud máxima de la secuencia tokenizada. Las muestras se filtran si la secuencia elegida o rechazada supera este valor. Si es None, no se aplica ningún filtrado.
pad_to_multiple_of (int o str, opcional, valor predeterminado "auto") — Si se establece, las secuencias se rellenarán hasta un múltiplo de este valor. "auto" rellena hasta un múltiplo de 128 en Neuron (AWS Trainium), que compila una vez por forma de entrada, y no rellena en otros entornos.

Parámetros que controlan el entrenamiento

center_rewards_coefficient (float, opcional) — Coeficiente para incentivar al modelo de recompensa a emitir recompensas con media cero (propuesto por este artículo, Ecuación 2). Valor recomendado: 0.01.
activation_offloading (bool, opcional, valor predeterminado False) — Si se deben descargar las activaciones a la CPU.

Parámetros obsoletos

pad_token —
El parámetro pad_token está obsoleto y se eliminará en la versión v2.0.0. Establezca tokenizer.pad_token directamente y páselo como processing_class al trainer en su lugar.

Clase de configuración para RewardTrainer.

Esta clase incluye solo los parámetros específicos para el entrenamiento de Reward. Para obtener la lista completa de argumentos de entrenamiento, consulte la documentación de TrainingArguments. Tenga en cuenta que los valores predeterminados de esta clase pueden diferir de los de TrainingArguments.

Con HfArgumentParser podemos convertir esta clase en argumentos de argparse que se pueden especificar en la línea de comandos.

Estos parámetros tienen valores predeterminados diferentes de TrainingArguments:

logging_steps: El valor predeterminado es 10 en lugar de 500.

gradient_checkpointing: El valor predeterminado es True en lugar de False.

bf16: Por defecto, es True si fp16 no está establecido, en lugar de False.

learning_rate: El valor predeterminado es 1e-4 en lugar de 5e-5.

Update on GitHub