TRL documentation

A2PO

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.18.0).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

A2PO

model badge

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:

  1. Estimação de valor offline. Antes do treinamento, num_value_samples conclusões são amostradas da política de referência para cada prompt e pontuadas com reward_funcs. O valor ótimo V*(x) = β₁·log(mean_i exp(r(x, yᵢ)/β₁)) é estimado e armazenado em cache por prompt.
  2. 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 ótima r(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

< >

( 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 (PreTrainedModel ou str) — Modelo a ser treinado, ou um identificador de modelo (string) passado para from_pretrained.
  • reward_funcs (Callable ou list[Callable]) — Função(ões) de recompensa. Cada uma recebe prompts e completions (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 (veja A2POConfig.reward_weights) é a recompensa escalar r, 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:

  1. Estimação de valor offline. Antes do treinamento, num_value_samples conclusões são amostradas da política de referência para cada prompt de treinamento e pontuadas com reward_funcs. O valor ótimo é estimado como V*(x) = beta1 * log(mean_i exp(r(x, y_i) / beta1)) e armazenado em cache por prompt.
  2. 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 vantagem r(x, y) - V*(x).

treino

< >

( *args**kwargs )

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.

A2POConfig

classe trl.experimental.a2po.A2POConfig

< >

( 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 argumento model do experimental.a2po.A2POTrainer é fornecido como uma string. O valor de revision também é usado ao carregar a classe de processamento.
  • 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.

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

  • remove_unused_columns (bool, opcional, padrão False) — 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 como False.

Parâmetros que controlam a geração

  • max_prompt_length (int ou None, opcional, padrão 512) — Comprimento máximo do prompt. Se o prompt for mais longo que isso, ele será truncado pela esquerda.
  • max_completion_length (int ou None, opcional, padrão 256) — Comprimento máximo da conclusão gerada.
  • temperature (float, opcional, padrão 1.0) — Temperatura de amostragem, usada na geração das Etapas 1 e 2.
  • top_p (float, opcional, padrão 1.0) — Float que controla a probabilidade cumulativa dos tokens principais a serem considerados. Deve estar em (0, 1]. Defina como 1.0 para considerar todos os tokens.
  • top_k (int ou None, opcional) — Número de tokens do vocabulário com maior probabilidade a serem mantidos. Se None, o filtro top-k é desativado.

Parâmetros que controlam a Etapa 1 (estimativa offline do valor ótimo)

  • num_value_samples (int, opcional, padrão 8) — Número de amostras extraídas da política de referência por prompt para estimar V*.
  • beta1 (float, opcional, padrão 0.5) — Temperatura de KL usada para estimar V* na Etapa 1.
  • filter_all_incorrect (bool, opcional, padrão True) — 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)

  • beta2 (float, opcional, padrão 1e-3) — Temperatura de KL usada no alvo de regressão da Etapa 2.
  • reward_weights (list[float], opcional) — Pesos para cada função de recompensa. Deve corresponder ao número de funções de recompensa. Se None, todas as recompensas são ponderadas igualmente com peso 1.0.

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.

Update on GitHub