TRL documentation

A2PO

Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

A2PO

model badge

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

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

Paramètres

  • model (PreTrainedModel ou str) — Modèle à entraîner, ou un identifiant de modèle (chaîne de caractères) transmis à 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, facultatif) — Configuration pour ce formateur. Si None, une configuration par défaut est utilisée.
  • train_dataset (Dataset, facultatif) — Jeu de données d’entraînement. Doit contenir une colonne "prompt".
  • eval_dataset (Dataset, facultatif) — Jeu de données d'évaluation.
  • processing_class (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.
  • 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.

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

< >

( *args**kwargs )

save_model

< >

( output_dir: str | None = None_internal_call: bool = False )

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

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

Paramètres

  • commit_message (str, facultatif, par défaut "End of training") — Message à committer lors de la poussée.
  • blocking (bool, facultatif, par défaut True) — Indique si la fonction doit ne renvoyer que lorsque le git push est terminé.
  • token (str, facultatif, par défaut None) — Jeton avec permission d’écriture pour écraser les arguments originaux 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.

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

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 )

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

  • model_init_kwargs (dict[str, Any], facultatif) — Arguments par mot-clé pour from_pretrained, utilisés lorsque l'argument model du 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, valeur 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 et from_pretrained.

Paramètres qui contrôlent la prétraitement des données

  • remove_unused_columns (bool, facultatif, valeur par défaut False) — Indique s'il faut ne conserver que 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, par défaut 1.0) — Flottant qui contrôle la probabilité cumulée des jetons de tête à prendre en compte. Doit être dans (0, 1]. Définissez-le à 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, 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, 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.

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. Notez que les valeurs par défaut de cette classe peuvent différer de celles de TrainingArguments.

Update on GitHub