TRL documentation

A2PO

You are viewing v1.18.0 version. A newer version v1.18.1 is available.
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

A2PO

model badge

TRL admite A*-PO (Optimal Advantage Regression) tal como se describe en el artículo Accelerating RL for LLM Reasoning with Optimal Advantage Regression de Kianté Brantley, Mingyu Chen, Zhaolin Gao, Jason D. Lee, Wen Sun, Wenhao Zhan y Xuezhou Zhang.

El resumen del artículo es el siguiente:

El aprendizaje por refuerzo (RL) se ha consolidado como una herramienta poderosa para el ajuste fino de modelos de lenguaje de gran escala (LLMs) con el fin de mejorar sus capacidades de razonamiento complejo. Sin embargo, los métodos de optimización de políticas de última generación suelen sufrir de una alta sobrecarga computacional y un elevado consumo de memoria, principalmente debido a la necesidad de múltiples generaciones por prompt y a la dependencia de redes críticas o estimaciones de ventaja de la política actual. En este artículo, proponemos A*-PO, un novedoso marco de optimización de políticas en dos etapas que aproxima directamente la función de ventaja óptima y permite un entrenamiento eficiente de LLMs para tareas de razonamiento. En la primera etapa, aprovechamos la muestreo offline desde una política de referencia para estimar la función de valor óptima V*, eliminando la necesidad de una costosa estimación de valor en línea. En la segunda etapa, realizamos actualizaciones on-policy utilizando una simple pérdida de regresión de mínimos cuadrados con una única generación por prompt. Teóricamente, establecemos garantías de rendimiento y demostramos que el objetivo de RL regularizado por KL puede optimizarse sin requerir estrategias de exploración complejas. Empíricamente, A*-PO logra un rendimiento competitivo en una amplia gama de benchmarks de razonamiento matemático, reduciendo al mismo tiempo el tiempo de entrenamiento hasta en 2× y el uso de memoria pico en más del 30% en comparación con PPO, GRPO y REBEL.

Uso

A*-PO asume una recompensa binaria y verificable (r ∈ {0, 1}) y se ejecuta en dos etapas:

  1. Estimación de valor sin conexión. Antes del entrenamiento, se muestrean num_value_samples finalizaciones de la política de referencia para cada indicación y se puntúan con reward_funcs. Se estima y se almacena en caché el valor óptimo V*(x) = β₁·log(mean_i exp(r(x, yᵢ)/β₁)) para cada indicación.
  2. Regresión on-policy. Durante el entrenamiento, se genera una única finalización por prompt a partir de la política actual. La pérdida es el error cuadrado entre la recompensa implícita β₂·log(π(y|x)/π_ref(y|x)) y la ventaja óptima 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()

Dado que V* se estima por completo a partir de muestras de la política de referencia, A*-PO no puede superar el Pass@K de la política de referencia. La implementación oficial se encuentra en ZhaolinGao/A-PO.

A2POTrainer

clase 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 o str) — Modelo a entrenar, o un identificador de modelo (cadena) pasado a from_pretrained.
  • reward_funcs (Callable o list[Callable]) — Función(es) de recompensa. Cada una toma prompts y completions (además de las columnas del conjunto de datos como argumentos de palabra clave) y devuelve una lista de recompensas de tipo float. Cuando se proporcionan varias, su suma ponderada (ver A2POConfig.reward_weights) es la recompensa escalar r, que A*-PO asume que es binaria (en {0, 1}).
  • args (experimental.a2po.A2POConfig, opcional) — Configuración para este entrenador. Si es None, se utiliza una configuración predeterminada.
  • train_dataset (Dataset, opcional) — Conjunto de datos de entrenamiento. Debe contener una columna "prompt".
  • eval_dataset (Dataset, opcional) — Conjunto de datos de evaluación.
  • processing_class (PreTrainedTokenizerBase, opcional) — Clase de procesamiento utilizada para procesar los datos. Si es None, se carga desde el nombre del modelo con from_pretrained.
  • callbacks (list[~transformers.TrainerCallback], opcional) — Lista de callbacks para personalizar el bucle de entrenamiento.
  • optimizers (tuple[~torch.optim.Optimizer, ~torch.optim.lr_scheduler.LambdaLR], opcional, por defecto (None, None)) — Tupla que contiene el optimizador y el programador de tasa de aprendizaje.

Trainer para el método A*-PO (Optimal Advantage Regression), introducido en Accelerating RL for LLM Reasoning with Optimal Advantage Regression.

A*-PO se ejecuta en dos etapas:

  1. Estimación de valor sin conexión. Antes del entrenamiento, se muestrean num_value_samples finalizaciones de la política de referencia para cada prompt de entrenamiento y se puntúan con reward_funcs. El valor óptimo se estima como V*(x) = beta1 * log(mean_i exp(r(x, y_i) / beta1)) y se almacena en caché por prompt.
  2. Regresión en la política. Durante el entrenamiento, se genera una única finalización por indicación a partir de la política actual. La pérdida es el error cuadrático entre la recompensa implícita beta2 * log(pi(y|x) / pi_ref(y|x)) y la estimación óptima de la ventaja r(x, y) - V*(x).

entrenar

< >

( *args**kwargs )

save_model

< >

( 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

< >

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

A2POConfig

clase 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 = 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 = 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 controlan el modelo y el modelo de referencia

  • model_init_kwargs (dict[str, Any], opcional) — Argumentos de palabra clave para from_pretrained, utilizados cuando el argumento model de experimental.a2po.A2POTrainer se proporciona como una cadena. El valor de revision también se utiliza al cargar la clase de procesamiento.
  • 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.

Parámetros que controlan el preprocesamiento de datos

  • remove_unused_columns (bool, opcional, valor predeterminado False) — Indica si se debe conservar únicamente la columna "prompt" en el conjunto de datos. Si utiliza una función de recompensa personalizada que requiere cualquier columna distinta de "prompts" y "completions", debe mantener este valor en False.

Parámetros que controlan la generación

  • max_prompt_length (int o None, opcional, valor predeterminado 512) — Longitud máxima del prompt. Si el prompt es más largo que esto, se recorta por la izquierda.
  • max_completion_length (int o None, opcional, valor predeterminado 256) — Longitud máxima de la generación completada.
  • temperature (float, opcional, valor predeterminado 1.0) — Temperatura de muestreo, utilizada en la generación de la Etapa 1 y la Etapa 2.
  • top_p (float, opcional, valor predeterminado 1.0) — Flotante que controla la probabilidad acumulada de los tokens superiores a considerar. Debe estar en (0, 1]. Establecerlo en 1.0 para considerar todos los tokens.
  • top_k (int o None, opcional) — Número de tokens del vocabulario con mayor probabilidad que se conservan. Si es None, el filtrado top-k se desactiva.

Parámetros que controlan la Etapa 1 (estimación óptima de valor sin conexión)

  • num_value_samples (int, opcional, valor predeterminado 8) — Número de muestras extraídas de la política de referencia por prompt para estimar V*.
  • beta1 (float, opcional, valor predeterminado 0.5) — Temperatura KL utilizada para estimar V* en la Etapa 1.
  • filter_all_incorrect (bool, opcional, valor predeterminado True) — Si se descartan los prompts para los que todas las muestras de referencia son incorrectas.

Parámetros que controlan la etapa 2 (regresión on-policy)

  • beta2 (float, opcional, valor predeterminado 1e-3) — Temperatura KL utilizada en el objetivo de regresión de la etapa 2.
  • reward_weights (list[float], opcional) — Pesos para cada función de recompensa. Debe coincidir con el número de funciones de recompensa. Si es None, todas las recompensas se ponderan por igual con un peso de 1.0.

Clase de configuración para experimental.a2po.A2POTrainer.

Esta clase incluye solo los parámetros específicos para el entrenamiento con A2PO. 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.

Update on GitHub