TRL documentation
A2PO
A2PO
O TRL oferece suporte ao A*-PO (Optimal Advantage Regression), conforme descrito no artigo Accelerating RL for LLM Reasoning with Optimal Advantage Regression, de Kianté Brantley, Mingyu Chen, Zhaolin Gao, Jason D. Lee, Wen Sun, Wenhao Zhan e Xuezhou Zhang.
O resumo do artigo é o seguinte:
O aprendizado por reforço (RL) emergiu como uma ferramenta poderosa para o ajuste fino de grandes modelos de linguagem (LLMs) a fim de melhorar as capacidades de raciocínio complexo. No entanto, os métodos de otimização de política do estado da arte frequentemente sofrem com alto sobrecarga computacional e consumo de memória, principalmente devido à necessidade de múltiplas gerações por prompt e à dependência de redes críticas ou estimativas de vantagem da política atual. Neste artigo, propomos o A*-PO, um novo framework de otimização de política em duas etapas que aproxima diretamente a função de vantagem ótima e permite o treinamento eficiente de LLMs para tarefas de raciocínio. Na primeira etapa, utilizamos amostragem offline de uma política de referência para estimar a função de valor ótima V*, eliminando a necessidade de estimativa de valor online custosa. Na segunda etapa, realizamos atualizações on-policy usando uma perda simples de regressão dos mínimos quadrados com apenas uma geração por prompt. Teoricamente, estabelecemos garantias de desempenho e provamos que o objetivo de RL regularizado por KL pode ser otimizado sem exigir estratégias de exploração complexas. Empiricamente, o A*-PO alcança desempenho competitivo em uma ampla variedade de benchmarks de raciocínio matemático, reduzindo o tempo de treinamento em até 2× e o uso de memória de pico em mais de 30% em comparação com PPO, GRPO e REBEL.
Uso
A*-PO pressupõe uma recompensa binária e verificável (r ∈ {0, 1}) e é executado em duas etapas:
- Estimação de valor offline. Antes do treinamento,
num_value_samplesconclusões são amostradas da política de referência para cada prompt e pontuadas comreward_funcs. O valor ótimoV*(x) = β₁·log(mean_i exp(r(x, yᵢ)/β₁))é estimado e armazenado em cache por prompt. - Regressão on-policy. Durante o treinamento, uma única conclusão é gerada por prompt a partir da política atual. A perda é o erro quadrático entre a recompensa implícita
β₂·log(π(y|x)/π_ref(y|x))e a vantagem ótimar(x, y) − V*(x).
from trl.experimental.a2po import A2POConfig, A2POTrainer
# A*-PO assumes a binary, verifiable reward in {0, 1}.
def reward_correct(completions, ground_truth, **kwargs):
return [float(completion.strip() == truth) for completion, truth in zip(completions, ground_truth)]
training_args = A2POConfig(
output_dir="Qwen2.5-0.5B-A2PO",
num_value_samples=8, # Stage 1: samples per prompt from the reference policy to estimate V*
beta1=0.5, # Stage 1: KL temperature for the V* estimate
beta2=1e-3, # Stage 2: KL temperature for the regression target
)
trainer = A2POTrainer(
model="Qwen/Qwen2.5-0.5B",
reward_funcs=reward_correct,
args=training_args,
train_dataset=...,
)
trainer.train()Como V* é estimado inteiramente a partir de amostras da política de referência, o A*-PO não pode exceder o Pass@K da política de referência. A implementação oficial pode ser encontrada em ZhaolinGao/A-PO.
A2POTrainer
classe trl.experimental.a2po.A2POTrainer
< source >( model: transformers.modeling_utils.PreTrainedModel | strreward_funcs: collections.abc.Callable[..., list[float]] | list[collections.abc.Callable[..., list[float]]]args: trl.experimental.a2po.a2po_config.A2POConfig | None = Nonetrain_dataset = Noneeval_dataset = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | None = Nonecallbacks = Noneoptimizers = (None, None) )
Parâmetros
- model (
PreTrainedModeloustr) — Modelo a ser treinado, ou um identificador de modelo (string) passado para from_pretrained. - reward_funcs (
Callableoulist[Callable]) — Função(ões) de recompensa. Cada uma recebepromptsecompletions(além das colunas do conjunto de dados como argumentos de palavra-chave) e retorna uma lista de recompensas em ponto flutuante. Quando várias são fornecidas, sua soma ponderada (vejaA2POConfig.reward_weights) é a recompensa escalarr, que o A*-PO assume ser binária (em{0, 1}). - args (experimental.a2po.A2POConfig, opcional) —
Configuração para este treinador. Se
None, uma configuração padrão é usada. - train_dataset (Dataset, opcional) —
Conjunto de dados de treinamento. Deve conter uma coluna
"prompt". - eval_dataset (Dataset, opcional) — Conjunto de dados de avaliação.
- processing_class (PreTrainedTokenizerBase, opcional) —
Classe de processamento usada para processar os dados. Se
None, ela é carregada a partir do nome do modelo com from_pretrained. - callbacks (
list[~transformers.TrainerCallback], opcional) — Lista de callbacks para personalizar o loop de treinamento. - optimizers (
tuple[~torch.optim.Optimizer, ~torch.optim.lr_scheduler.LambdaLR], opcional, padrão(None, None)) — Tupla contendo o otimizador e o agendador de taxa de aprendizado.
Trainer para o método A*-PO (Optimal Advantage Regression), introduzido em Accelerating RL for LLM Reasoning with Optimal Advantage Regression.
A*-PO é executado em duas etapas:
- Estimação de valor offline. Antes do treinamento,
num_value_samplesconclusões são amostradas da política de referência para cada prompt de treinamento e pontuadas comreward_funcs. O valor ótimo é estimado comoV*(x) = beta1 * log(mean_i exp(r(x, y_i) / beta1))e armazenado em cache por prompt. - Regressão on-policy. Durante o treinamento, uma única conclusão é gerada por prompt a partir da política atual.
A perda é o erro quadrático entre a recompensa implícita
beta2 * log(pi(y|x) / pi_ref(y|x))e a estimativa ótima de vantagemr(x, y) - V*(x).
Salvará o modelo, para que você possa recarregá-lo usando from_pretrained().
Salvará apenas a partir do processo 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, padrão"End of training") — Mensagem a ser commitada durante o push. - blocking (
bool, opcional, padrãoTrue) — Se a função deve retornar apenas quando ogit pushtiver terminado. - token (
str, opcional, padrãoNone) — 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.
A2POConfig
classe trl.experimental.a2po.A2POConfig
< source >( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 5e-05lr_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 = Falselabel_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 | None = Nonetrust_remote_code: bool = Falsemax_prompt_length: int | None = 512max_completion_length: int | None = 256temperature: float = 1.0top_p: float = 1.0top_k: int | None = Nonenum_value_samples: int = 8beta1: float = 0.5filter_all_incorrect: bool = Truebeta2: float = 0.001reward_weights: list[float] | None = None )
Parâmetros que controlam o modelo e o modelo de referência
- model_init_kwargs (
dict[str, Any], opcional) — Argumentos de palavra-chave para from_pretrained, usados quando o argumentomodeldo experimental.a2po.A2POTrainer é fornecido como uma string. O valor derevisiontambém é usado ao carregar a classe de processamento. - trust_remote_code (
bool, opcional, padrãoFalse) — Se permite carregar modelos e tokenizers que incluem código Python personalizado do Hub. Encaminhado para from_pretrained e from_pretrained.
Parâmetros que controlam o pré-processamento dos dados
- remove_unused_columns (
bool, opcional, padrãoFalse) — Se deve manter apenas a coluna"prompt"no conjunto de dados. Se você usar uma função de recompensa personalizada que requer qualquer coluna além de"prompts"e"completions", deve manter isso comoFalse.
Parâmetros que controlam a geração
- max_prompt_length (
intouNone, opcional, padrão512) — Comprimento máximo do prompt. Se o prompt for mais longo que isso, ele será truncado pela esquerda. - max_completion_length (
intouNone, opcional, padrão256) — Comprimento máximo da conclusão gerada. - temperature (
float, opcional, padrão1.0) — Temperatura de amostragem, usada na geração das Etapas 1 e 2. - top_p (
float, opcional, padrão1.0) — Float que controla a probabilidade cumulativa dos tokens principais a serem considerados. Deve estar em (0, 1]. Defina como1.0para considerar todos os tokens. - top_k (
intouNone, opcional) — Número de tokens do vocabulário com maior probabilidade a serem mantidos. SeNone, o filtro top-k é desativado.
Parâmetros que controlam a Etapa 1 (estimativa offline do valor ótimo)
- num_value_samples (
int, opcional, padrão8) — Número de amostras extraídas da política de referência por prompt para estimarV*. - beta1 (
float, opcional, padrão0.5) — Temperatura de KL usada para estimarV*na Etapa 1. - filter_all_incorrect (
bool, opcional, padrãoTrue) — Se deve descartar prompts para os quais todas as amostras de referência estão incorretas.
Parâmetros que controlam a Etapa 2 (regressão on-policy)
Classe de configuração para o experimental.a2po.A2POTrainer.
Esta classe inclui apenas os parâmetros específicos para o treinamento A2PO. Para a lista completa de argumentos de treinamento, consulte a documentação de TrainingArguments. Observe que os valores padrão nesta classe podem diferir dos presentes em TrainingArguments.