# A2PO

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

TRL prend en charge A\*-PO (Optimal Advantage Regression) tel que décrit dans l'article [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 et Xuezhou Zhang.

L'abstract de l'article est le suivant :

> L'apprentissage par renforcement (RL) s'est imposé comme un outil puissant pour l'ajustement fin des grands modèles de langage (LLM) afin d'améliorer leurs capacités de raisonnement complexe. Toutefois, les méthodes d'optimisation de politique de pointe souffrent souvent d'une surcharge computationnelle et d'une consommation mémoire élevées, principalement en raison de la nécessité de plusieurs générations par invite et de la dépendance aux réseaux critiques ou aux estimations d'avantage de la politique actuelle. Dans cet article, nous proposons A\*-PO, un nouveau cadre d'optimisation de politique en deux étapes qui approxime directement la fonction d'avantage optimale et permet un entraînement efficace des LLM pour les tâches de raisonnement. À la première étape, nous exploitons un échantillonnage hors ligne à partir d'une politique de référence pour estimer la fonction de valeur optimale V\*, éliminant ainsi le besoin d'estimations de valeur en ligne coûteuses. À la seconde étape, nous effectuons des mises à jour en ligne (on-policy) en utilisant une simple perte de régression des moindres carrés avec une seule génération par invite. Sur le plan théorique, nous établissons des garanties de performance et démontrons que l'objectif RL régularisé par KL peut être optimisé sans nécessiter de stratégies d'exploration complexes. Sur le plan empirique, A\*-PO atteint des performances compétitives sur une large gamme de benchmarks de raisonnement mathématique, tout en réduisant le temps d'entraînement de jusqu'à 2× et l'utilisation mémoire de pointe de plus de 30 % par rapport à PPO, GRPO et REBEL.

## Utilisation

A\*-PO suppose une **récompense binaire et vérifiable** (`r ∈ {0, 1}`) et s’exécute en deux étapes :

1. **Estimation de la valeur hors ligne.** Avant l'entraînement, `num_value_samples` complétions sont échantillonnées à partir de la politique de référence pour chaque invite et évaluées avec `reward_funcs`. La valeur optimale `V*(x) = β₁·log(mean_i exp(r(x, yᵢ)/β₁))` est estimée et mise en cache pour chaque invite.
2. **Régression on-policy.** Lors de l'entraînement, une seule complétion est générée par invite à partir de la politique actuelle. La perte est l'erreur quadratique entre la récompense implicite `β₂·log(π(y|x)/π_ref(y|x))` et l'avantage optimal `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()
```

Comme `V*` est estimé entièrement à partir d'échantillons de la politique de référence, A\*-PO ne peut pas dépasser le Pass@K de la politique de référence. L'implémentation officielle est disponible sur [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))
```

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

**Paramètres :**

model (`PreTrainedModel` ou `str`) : Modèle à entraîner, ou un identifiant de modèle (chaîne de caractères) transmis à [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained).

reward_funcs (`Callable` ou `list[Callable]`) : Fonction(s) de récompense. Chacune reçoit `prompts` et `completions` (ainsi que les colonnes du jeu de données en arguments nommés) et renvoie une liste de récompenses flottantes. Si plusieurs sont fournies, leur somme pondérée (voir `A2POConfig.reward_weights`) constitue la récompense scalaire `r`, que A*-PO suppose binaire (dans `{0, 1}`).

args ([experimental.a2po.A2POConfig](/docs/trl/v1.18.2/fr/a2po_trainer#trl.experimental.a2po.A2POConfig), *facultatif*) : Configuration pour ce formateur. Si `None`, une configuration par défaut est utilisée.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), *facultatif*) : Jeu de données d'entraînement. Doit contenir une colonne `"prompt"`.

eval_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), *facultatif*) : Jeu de données d'évaluation.

processing_class ([PreTrainedTokenizerBase](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), *facultatif*) : Classe de traitement utilisée pour traiter les données. Si `None`, elle est chargée à partir du nom du modèle avec [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained).

callbacks (`list[~transformers.TrainerCallback]`, *facultatif*) : Liste de callbacks pour personnaliser la boucle d'entraînement.

optimizers (`tuple[~torch.optim.Optimizer, ~torch.optim.lr_scheduler.LambdaLR]`, *facultatif*, par défaut `(None, None)`) : Tuple contenant l'optimiseur et le planificateur de taux d'apprentissage.

Trainer pour la méthode A*-PO (Optimal Advantage Regression), introduite dans [Accelerating RL for LLM Reasoning with Optimal Advantage Regression](https://huggingface.co/papers/2505.20686).

A*-PO s'exécute en deux étapes :

1. **Estimation de la valeur hors ligne.** Avant l'entraînement, `num_value_samples` complétions sont échantillonnées à partir de la politique de référence pour chaque invite d'entraînement et évaluées avec `reward_funcs`. La valeur optimale est estimée par `V*(x) = beta1 * log(mean_i exp(r(x, y_i) / beta1))` et mise en cache par invite.
2. **Régression on-policy.** Lors de l'entraînement, une seule complétion est générée par invite à partir de la politique actuelle. La perte est l'erreur au carré entre la récompense implicite `beta2 * log(pi(y|x) / pi_ref(y|x))` et l'estimation optimale de l'avantage `r(x, y) - V*(x)`.

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

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

[Source](https://github.com/huggingface/trl/blob/v1.18.2/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)
```

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

Enregistrera le modèle, ce qui vous permettra de le recharger à l'aide de `from_pretrained()`.

N'enregistrera que depuis le processus 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)
```

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

**Paramètres :**

commit_message (`str`, *facultatif*, par défaut `"End of training"`) : Message à commiter lors de la poussée.

blocking (`bool`, *facultatif*, par défaut `True`) : Indique si la fonction doit ne renvoyer un résultat qu'une fois le `git push` terminé.

token (`str`, *facultatif*, valeur par défaut `None`) : Jeton avec permission d'écriture pour écraser les arguments d'origine du Trainer.

revision (`str`, *facultatif*) : La révision git à partir de laquelle effectuer le commit. Par défaut, il s'agit de la tête de la branche "main".

private (`bool`, *facultatif*) : Indique s'il faut rendre le dépôt privé lors de sa création. La valeur par défaut est `args.hub_private_repo`. N'a aucun effet si le dépôt existe déjà.

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires passés à `~Trainer.create_model_card`.

**Retourne :**

L'URL du dépôt où le modèle a été poussé si `blocking=False`, ou un objet `Future` suivant la progression de l'engagement si `blocking=True`.

Téléchargez `self.model` et `self.processing_class` sur le hub de modèles 🤗 dans le dépôt `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)
```

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

**Paramètres qui contrôlent le modèle et le modèle de référence :**

model_init_kwargs (`dict[str, Any]`, *facultatif*) : Arguments nommés pour [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained), utilisés lorsque l'argument `model` du [experimental.a2po.A2POTrainer](/docs/trl/v1.18.2/fr/a2po_trainer#trl.experimental.a2po.A2POTrainer) est fourni sous forme de chaîne de caractères. La valeur de `revision` est également utilisée lors du chargement de la classe de traitement.

trust_remote_code (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut autoriser le chargement de modèles et de tokenizers qui incluent du code Python personnalisé depuis le Hub. Transmis à [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForCausalLM.from_pretrained) et [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.from_pretrained).

**Paramètres qui contrôlent le prétraitement des données :**

remove_unused_columns (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut conserver uniquement la colonne `"prompt"` dans le jeu de données. Si vous utilisez une fonction de récompense personnalisée qui nécessite une colonne autre que `"prompts"` et `"completions"`, vous devez laisser cette valeur à `False`.

**Paramètres qui contrôlent la génération :**

max_prompt_length (`int` ou `None`, *facultatif*, par défaut `512`) : Longueur maximale du prompt. Si le prompt est plus long que cela, il est tronqué à gauche.

max_completion_length (`int` ou `None`, *facultatif*, par défaut `256`) : Longueur maximale de la complétion générée.

temperature (`float`, *facultatif*, valeur par défaut `1.0`) : Température d'échantillonnage, utilisée à la fois pour la génération de l'étape 1 et de l'étape 2.

top_p (`float`, *facultatif*, valeur par défaut `1.0`) : Flottant qui contrôle la probabilité cumulée des jetons de tête à prendre en compte. Doit être dans l'intervalle (0, 1]. Définissez-le sur `1.0` pour prendre en compte tous les jetons.

top_k (`int` ou `None`, *facultatif*) : Nombre de jetons du vocabulaire ayant la plus haute probabilité à conserver. Si `None`, le filtrage top-k est désactivé.

**Paramètres qui contrôlent l’étape 1 (estimation hors ligne de la valeur optimale) :**

num_value_samples (`int`, *facultatif*, valeur par défaut `8`) : Nombre d'échantillons tirés de la politique de référence par invite pour estimer `V*`.

beta1 (`float`, *facultatif*, valeur par défaut `0.5`) : température KL utilisée pour estimer `V*` à l'étape 1.

filter_all_incorrect (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut supprimer les prompts pour lesquels tous les échantillons de référence sont incorrects.

**Paramètres qui contrôlent l’étape 2 (régression on-policy) :**

beta2 (`float`, *facultatif*, valeur par défaut `1e-3`) : température KL utilisée dans la cible de régression de l'étape 2.

reward_weights (`list[float]`, *facultatif*) : Poids pour chaque fonction de récompense. Doit correspondre au nombre de fonctions de récompense. Si `None`, toutes les récompenses sont pondérées également avec un poids de `1.0`.

Classe de configuration pour le [experimental.a2po.A2POTrainer](/docs/trl/v1.18.2/fr/a2po_trainer#trl.experimental.a2po.A2POTrainer).

Cette classe ne contient que les paramètres spécifiques à l’entraînement A2PO. Pour la liste complète des arguments d’entraînement, veuillez consulter la documentation de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments). Notez que les valeurs par défaut de cette classe peuvent différer de celles de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments).

