TRL documentation

Modelagem de Recompensa

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Modelagem de Recompensa

model badge

Visão geral

O TRL oferece suporte ao Treinador de Modelagem de Recompensas Supervisionada por Resultado (ORM) para treinar modelos de recompensa.

Este método de pós-treinamento foi contribuído por Younes Belkada.

Início rápido

Este exemplo demonstra como treinar um modelo de recompensa usando o RewardTrainer do TRL. Treinamos um modelo Qwen 3 0.6B no UltraFeedback dataset, um conjunto de dados de preferências em larga escala, com granularidade fina e diversificado.

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 e formato de dataset esperados

O RewardTrainer suporta o tipo de dataset de preference (tanto com prompt implícito quanto explícito). O RewardTrainer é compatível com os formatos de dataset standard e conversational. Quando fornecido com um dataset conversacional, o trainer aplica automaticamente o chat template ao dataset.

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

Se o seu conjunto de dados não estiver em um desses formatos, você pode pré-processá-lo para convertê-lo no formato esperado. Aqui está um exemplo com o conjunto de dados 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, ..."},
    ],
}

Olhando mais a fundo para o método de treinamento

Os Modelos de Recompensa (RMs) são tipicamente treinados usando aprendizado supervisionado em conjuntos de dados que contêm pares de respostas preferidas e não preferidas. O objetivo é aprender uma função que atribua pontuações mais altas às respostas preferidas, permitindo que o modelo classifique as saídas com base nas preferências.

Esta seção detalha como a modelagem de recompensas funciona na prática, abordando as etapas principais: pré-processamento e cálculo da perda.

Pré-processamento e tokenização

Durante o treinamento, espera-se que cada exemplo contenha um campo chosen e um campo rejected. Para mais detalhes sobre os formatos esperados, consulte Dataset formats - Preference. O RewardTrainer faz a tokenização de cada entrada usando o tokenizer do modelo. Se os prompts e as conclusões (chosen e rejected) forem fornecidos separadamente (caso de prompt explícito), eles são concatenados antes da tokenização.

Calculando a perda

Seja x x a sequência de entrada (prompt) e y+ y^+ e y− y^- as sequências escolhida e rejeitada, respectivamente. Sob o modelo de Bradley-Terry (Bradley & Terry, 1952), a probabilidade de que y+ y^+ seja preferida a y− y^- dada uma função de recompensa r r é p(y+≻y−∣x)=σ(r(x,y+)−r(x,y−)) p(y^+ ≻ y^- |x) = \sigma(r(x, y^+)−r(x, y^-)) , onde σ σ é a função sigmoide.

O modelo de recompensa rθ(x,y) r_\theta(x, y) é treinado para atribuir pontuações mais altas às respostas preferidas y+ y^+ em relação às não preferidas y− y^- . A perda é então definida como a negatividade da log-verossimilhança das preferências observadas: L(θ)=−E(x,y+,y−)∼D[log⁡σ(rθ(x,y+)−rθ(x,y−))]. \mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \right].

O modelo Bradley-Terry é subdeterminado, o que significa que adicionar uma constante a todas as recompensas não altera as probabilidades de preferência. Para resolver isso, Helping or Herding? Reward Model Ensembles Mitigate but do not Eliminate Reward Hacking propõe adicionar um termo de perda auxiliar que incentiva as recompensas a ficarem centralizadas em torno de zero. Isso é controlado pelo parâmetro center_rewards_coefficient no RewardConfig. O valor recomendado é 1e-2.

Métricas registradas

Durante o treinamento e a avaliação, registramos as seguintes métricas:

  • global_step: O número total de etapas do otimizador realizadas até o momento.
  • epoch: O número do epoch atual, com base na iteração do conjunto de dados.
  • num_tokens: O número total de tokens processados até o momento.
  • loss: A perda média no último intervalo de registro.
  • accuracy: A proporção de previsões corretas (ou seja, o modelo atribuiu uma pontuação maior à resposta escolhida do que à rejeitada) média no último intervalo de registro.
  • min_reward: A pontuação mínima de recompensa atribuída pelo modelo. Este valor é a média calculada no intervalo de registro.
  • mean_reward: A pontuação média de recompensa atribuída pelo modelo no último intervalo de registro.
  • max_reward: A pontuação de recompensa máxima atribuída pelo modelo. Este valor é a média calculada no intervalo de registro.
  • margin: A margem média (diferença entre as recompensas escolhidas e rejeitadas) no último intervalo de registro.
  • learning_rate: a taxa de aprendizado atual, que pode mudar dinamicamente se um agendador for usado.
  • grad_norm: A norma L2 dos gradientes, calculada antes do recorte de gradientes.

Personalização

Inicialização do modelo

Você pode passar diretamente os kwargs do método from_pretrained() para o RewardConfig. Por exemplo, se você quiser carregar um modelo em uma precisão diferente, análogo a

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

você pode fazer isso passando o argumento model_init_kwargs={"dtype": torch.bfloat16} para o RewardConfig.

from trl import RewardConfig

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

Observe que todos os argumentos de palavra-chave de from_pretrained() são suportados, exceto num_labels, que é definido automaticamente como 1.

Treine adaptadores com PEFT

Suportamos integração estreita com a biblioteca 🤗 PEFT, permitindo que qualquer usuário treine adaptadores de forma conveniente e os compartilhe no Hub, em vez de treinar o modelo inteiro.

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

Você também pode continuar o treinamento do seu PeftModel. Para isso, primeiro carregue um PeftModel fora do RewardTrainer e passe-o diretamente para o trainer sem passar o 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()

Ao treinar adaptadores, você geralmente usa uma taxa de aprendizado mais alta (≈1e‑3), pois apenas novos parâmetros estão sendo aprendidos.

RewardConfig(learning_rate=1e-3, ...)

Chamada de Ferramentas com Modelagem de Recompensa

O RewardTrainer oferece suporte completo ao ajuste fino de modelos com capacidades de tool calling. Nesse caso, cada exemplo do conjunto de dados deve incluir:

  • As mensagens da conversa, incluindo qualquer chamada de ferramenta (tool_calls) e respostas de ferramenta (mensagens com o papel tool)
  • A lista de ferramentas disponíveis na coluna tools, geralmente fornecida como esquemas JSON

Para mais detalhes sobre a estrutura esperada do conjunto de dados, consulte a seção Formato do Conjunto de Dados — Chamada de Ferramenta.

RewardTrainer

classe trl.RewardTrainer

< >

( 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 ou PreTrainedModel ou PeftModel) — Modelo a ser treinado. Pode ser:
    • Uma string, sendo o model id de um modelo pré-treinado hospedado em um repositório de modelos no huggingface.co, ou um caminho para um diretório contendo pesos de modelo salvos usando save_pretrained, por exemplo, './my_model_directory/'. O modelo é carregado usando AutoModelForSequenceClassification.from_pretrained com os argumentos de palavra-chave em args.model_init_kwargs. Se dtype não for especificado em args.model_init_kwargs, o padrão é float32. Isso difere de from_pretrained, onde (desde a versão 5 do Transformers) o dtype é inferido a partir da configuração do modelo.
    • Um objeto PreTrainedModel de classificação de sequência.
    • Um objeto PeftModel de classificação de sequência.
  • args (RewardConfig, opcional) — Configuração para este treinador. Se None, uma configuração padrão é usada.
  • data_collator (DataCollator, opcional) — Função a ser usada para formar um lote a partir de uma lista de elementos do train_dataset ou eval_dataset processado. O padrão será DataCollatorForPreference.
  • train_dataset (Dataset ou IterableDataset) — Dataset a ser usado para o treinamento. Este trainer suporta preference tipo (tanto prompt implícito quanto explícito). O formato das amostras pode ser:
    • Padrão: Cada amostra contém texto simples.
    • Conversacional: cada amostra contém mensagens estruturadas (por exemplo, papel e conteúdo).

    O trainer também suporta datasets processados (tokenizados), desde que contenham os campos chosen_ids e rejected_ids.

    Quando train_dataset é um IterableDataset (por exemplo, um dataset em streaming), max_steps deve ser definido nos argumentos de treinamento, pois seu comprimento não pode ser inferido e o número total de etapas de treinamento é necessário para limitar o loop de treinamento e configurar o agendador de taxa de aprendizado.

  • eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict ou dict[str, Dataset | IterableDataset]) — Dataset a ser usado para avaliação. Ele deve atender aos mesmos requisitos que train_dataset.
  • processing_class (PreTrainedTokenizerBase, opcional) — Tokenizer usado para processar os dados. Se None, o tokenizer é carregado a partir do nome do modelo com from_pretrained. Um token de padding, processing_class.pad_token, deve ser definido. Se a classe de processamento não tiver definido um token de padding, processing_class.eos_token será usado como padrão.
  • compute_metrics (Callable[[EvalPrediction], dict], opcional) — A função que será usada para calcular métricas na avaliação. Deve receber um EvalPrediction e retornar um dicionário de strings para valores de métricas. Ao passar RewardConfig com batch_eval_metrics definido como True, sua função compute_metrics deve receber um argumento booleano compute_result. Isso será acionado após o último lote de avaliação para sinalizar que a função precisa calcular e retornar as estatísticas de resumo globais, em vez de acumular as estatísticas de nível de lote.
  • callbacks (lista de TrainerCallback, opcional) — Lista de callbacks para personalizar o loop de treinamento. Adicionará esses à lista de callbacks padrão detalhada aqui.

    Se você deseja remover um dos callbacks padrão utilizados, use o método remove_callback.

  • optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], opcional, padrão (None, None)) — Uma tupla contendo o otimizador e o agendador a serem usados. Por padrão, será uma instância de AdamW no seu modelo e um agendador dado por get_linear_schedule_with_warmup controlado por args.
  • optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], opcional) — Uma tupla contendo a classe do otimizador e os argumentos de palavra-chave a serem usados. Sobrescreve optim e optim_args em args. Incompatível com o argumento optimizers argumento.

    Diferentemente de optimizers, este argumento evita a necessidade de colocar os parâmetros do modelo nos dispositivos corretos antes de inicializar o Trainer.

  • preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], opcional) — Uma função que pré-processa os logits logo antes de armazená-los em cache em cada etapa de avaliação. Deve receber dois tensores, os logits e os rótulos, e retornar os logits após o processamento desejado. As modificações feitas por esta função serão refletidas nas previsões recebidas por compute_metrics.

    Observe que os rótulos (segundo parâmetro) serão None se o conjunto de dados não os possuir.

  • quantization_config (BitsAndBytesConfig, opcional) — Configuração de quantização usada ao carregar o modelo a partir de um identificador de modelo. Combine com peft_config para treinamento QLoRA. Ignorado se o modelo já estiver instanciado, ou se quantization_config também estiver definido em args.model_init_kwargs.
  • peft_config (PeftConfig, opcional) — Configuração PEFT usada para envolver o modelo. Se for None, o modelo não será envolvido. Observe que, se o modelo carregado for um LM causal, é altamente recomendável definir modules_to_save=["score"] na configuração PEFT para garantir que a cabeça de recompensa seja treinada corretamente.

Trainer para Modelos de Recompensa supervisionados por Resultado (ORM).

Esta classe é um wrapper em torno da classe Trainer e herda todos os seus atributos e métodos.

Exemplo:

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

treino

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput

Parâmetros

  • resume_from_checkpoint (str ou bool, opcional) — Se for um str, caminho local para um checkpoint salvo por uma instância anterior de Trainer. Se for um bool e for igual a True, carrega o último checkpoint em args.output_dir salvo por uma instância anterior de Trainer. Se presente, o treinamento será retomado a partir dos estados do modelo/otimizador/agendador carregados aqui.
  • trial (optuna.Trial ou dict[str, Any], opcional) — A execução do trial ou o dicionário de hiperparâmetros para a busca de hiperparâmetros.
  • ignore_keys_for_eval (list[str], opcional) — Uma lista de chaves na saída do seu modelo (se for um dicionário) que devem ser ignoradas ao coletar previsões para avaliação durante o treinamento.

Retorna

~trainer_utils.TrainOutput

Objeto contendo a contagem de etapas globais, a perda de treinamento e as métricas.

Ponto de entrada principal do treinamento.

save_model

< >

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

Salvará o modelo, para que você possa recarregá-lo usando from_pretrained().

Salvará apenas a partir do processo principal.

push_to_hub

< >

( 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, padrão "End of training") — Mensagem a ser commitada durante o push.
  • blocking (bool, opcional, padrão True) — Se a função deve retornar apenas quando o git push tiver terminado.
  • token (str, opcional, padrão None) — Token com permissão de escrita para sobrescrever os argumentos originais do Trainer.
  • revision (str, opcional) — A revisão git de onde o commit será feito. O padrão é o topo do ramo “main”.
  • private (bool, opcional) — Se o repositório deve ser privado quando for criado. O padrão é args.hub_private_repo. Não tem efeito se o repositório já existir.
  • kwargs (dict[str, Any], opcional) — Argumentos de palavra-chave adicionais passados para ~Trainer.create_model_card.

Envie self.model e self.processing_class para o hub de modelos do 🤗 no repositório self.args.hub_model_id.

RewardConfig

classe trl.RewardConfig

< >

( 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 | None = Nonegradient_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 controlam o modelo

  • model_init_kwargs (dict[str, Any], opcional) — Argumentos de palavra-chave para from_pretrained, usados quando o argumento model do RewardTrainer é fornecido como uma string. O valor de revision também é usado ao carregar o tokenizer.
  • trust_remote_code (bool, opcional, padrão False) — Se permite carregar modelos e tokenizers que incluem código Python personalizado do Hub. Encaminhado para from_pretrained e from_pretrained.
  • chat_template_path (str, opcional) — Se especificado, define o modelo de chat do modelo. Isso pode ser o caminho para um tokenizer (diretório local ou modelo do Hugging Face Hub) ou um caminho direto para um arquivo de template Jinja. Ao usar um arquivo Jinja, você deve garantir que quaisquer tokens especiais referenciados no template sejam adicionados ao tokenizer e que a camada de incorporação do modelo seja redimensionada de acordo.
  • disable_dropout (bool, opcional, padrão True) — Se deve desabilitar o dropout no modelo.

Parâmetros que controlam o pré-processamento dos dados

  • dataset_num_proc (int, opcional) — Número de processos a serem usados para processar o conjunto de dados.
  • eos_token (str, opcional) — Token usado para indicar o fim de uma rodada ou sequência. Se None, o valor padrão é processing_class.eos_token.
  • max_length (int ou None, opcional, padrão 1024) — Comprimento máximo da sequência tokenizada. As amostras são filtradas se a sequência escolhida ou rejeitada exceder esse valor. Se None, nenhum filtro é aplicado.
  • pad_to_multiple_of (int ou str, opcional, padrão "auto") — Se definido, as sequências serão preenchidas até um múltiplo deste valor. "auto" preenche até um múltiplo de 128 no Neuron (AWS Trainium), que compila uma vez por forma de entrada, e não preenche em outros ambientes.

Parâmetros que controlam o treinamento

  • center_rewards_coefficient (float, opcional) — Coeficiente para incentivar o modelo de recompensa a gerar recompensas com média zero (proposto por este artigo, Eq. 2). Valor recomendado: 0.01.
  • activation_offloading (bool, opcional, padrão False) — Se as ativações devem ser transferidas para a CPU.

Parâmetros obsoletos

  • pad_token —

    O parâmetro pad_token está obsoleto e será removido na versão v2.0.0. Defina tokenizer.pad_token diretamente e passe-o como processing_class para o trainer.

Classe de configuração para o RewardTrainer.

Esta classe inclui apenas os parâmetros específicos para o treinamento de Reward. Para a lista completa de argumentos de treinamento, consulte a documentação de TrainingArguments. Observe que os valores padrão nesta classe podem diferir daqueles em TrainingArguments.

Usando HfArgumentParser, podemos transformar essa classe em argumentos argparse que podem ser especificados na linha de comando.

Esses parâmetros possuem valores padrão diferentes de TrainingArguments:

  • logging_steps: O valor padrão é 10 em vez de 500.
  • gradient_checkpointing: O padrão é True em vez de False.
  • bf16: Padrão é True se fp16 não estiver definido, em vez de False.
  • learning_rate: O valor padrão é 1e-4 em vez de 5e-5.
Update on GitHub