# A2PO

[![model badge](https://img.shields.io/badge/All_models-A2PO-blue)](https://huggingface.co/models?other=a2po,trl)

TRL admite A\*-PO (Optimal Advantage Regression) tal como se describe en el artículo [Accelerating RL for LLM Reasoning with Optimal Advantage Regression](https://huggingface.co/papers/2505.20686) 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 (LLM) 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 LLM 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)`.

```python
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](https://github.com/ZhaolinGao/A-PO).

## A2POTrainer[[trl.experimental.a2po.A2POTrainer]]

#### trl.experimental.a2po.A2POTrainer[[trl.experimental.a2po.A2POTrainer]]

```python
trl.experimental.a2po.A2POTrainer(model: transformers.modeling_utils.PreTrainedModel | str, reward_funcs: collections.abc.Callable[..., list[float]] | list[collections.abc.Callable[..., list[float]]], args: trl.experimental.a2po.a2po_config.A2POConfig | None = None, train_dataset = None, eval_dataset = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | None = None, callbacks = None, optimizers = (None, None))
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.1/trl/experimental/a2po/a2po_trainer.py#L48)

**Parámetros:**

model (`PreTrainedModel` o `str`) : Modelo a entrenar, o un identificador de modelo (cadena) pasado a [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.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](/docs/trl/v1.18.1/es/a2po_trainer#trl.experimental.a2po.A2POConfig), *opcional*) : Configuración para este entrenador. Si es `None`, se utiliza una configuración predeterminada.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), *opcional*) : Conjunto de datos de entrenamiento. Debe contener una columna `"prompt"`.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), *opcional*) : Conjunto de datos de evaluación.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), *opcional*) : Clase de procesamiento utilizada para procesar los datos. Si es `None`, se carga desde el nombre del modelo con [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.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 la tasa de aprendizaje.

Trainer para el método A*-PO (Optimal Advantage Regression), introducido en [Accelerating RL for LLM Reasoning with Optimal Advantage Regression](https://huggingface.co/papers/2505.20686).

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)`.

#### train[[trl.experimental.a2po.A2POTrainer.train]]

```python
train(*args, **kwargs)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.1/trl/experimental/a2po/a2po_trainer.py#L371)

#### save_model[[trl.experimental.a2po.A2POTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L4077)

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

Solo se guardará desde el proceso principal.

#### push_to_hub[[trl.experimental.a2po.A2POTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.1/transformers/trainer.py#L4337)

**Parámetros:**

commit_message (`str`, *opcional*, por defecto `"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 privada la repositorio cuando se crea. El valor predeterminado es `args.hub_private_repo`. No tiene efecto si la repositorio ya existe.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan a `~Trainer.create_model_card`.

**Devuelve:**

La URL del repositorio donde se subió el modelo si `blocking=False`, o un objeto `Future` que rastrea el progreso del commit si `blocking=True`.

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

## A2POConfig[[trl.experimental.a2po.A2POConfig]]

#### trl.experimental.a2po.A2POConfig[[trl.experimental.a2po.A2POConfig]]

```python
trl.experimental.a2po.A2POConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 5e-05, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = False, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict | None = None, trust_remote_code: bool = False, max_prompt_length: int | None = 512, max_completion_length: int | None = 256, temperature: float = 1.0, top_p: float = 1.0, top_k: int | None = None, num_value_samples: int = 8, beta1: float = 0.5, filter_all_incorrect: bool = True, beta2: float = 0.001, reward_weights: list[float] | None = None)
```

[Fuente](https://github.com/huggingface/trl/blob/v1.18.1/trl/experimental/a2po/a2po_config.py#L21)

**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](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained), utilizados cuando el argumento `model` de [experimental.a2po.A2POTrainer](/docs/trl/v1.18.1/es/a2po_trainer#trl.experimental.a2po.A2POTrainer) se proporciona como una cadena de caracteres. El valor de `revision` también se utiliza al cargar la clase de procesamiento.

trust_remote_code (`bool`, *opcional*, por defecto `False`) : Si se permite cargar modelos y tokenizadores que incluyen código Python personalizado desde el Hub. Se reenvía a [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) y [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained).

**Parámetros que controlan el preprocesamiento de datos:**

remove_unused_columns (`bool`, *opcional*, por defecto `False`) : Si se debe conservar únicamente la columna `"prompt"` en el conjunto de datos. Si utiliza una función de recompensa personalizada que requiera 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 tanto en la generación de la Etapa 1 como en la de 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]. Establezca `1.0` para considerar todos los tokens.

top_k (`int` o `None`, *opcional*) : Número de tokens del vocabulario con mayor probabilidad que se deben conservar. 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 indicación 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. Deben 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](/docs/trl/v1.18.1/es/a2po_trainer#trl.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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments). Tenga en cuenta que los valores predeterminados de esta clase pueden diferir de los de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments).

