TRL documentation
A2PO
A2PO
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 :
- Estimation de la valeur hors ligne. Avant l'entraînement,
num_value_samplescomplétions sont échantillonnées à partir de la politique de référence pour chaque invite et évaluées avecreward_funcs. La valeur optimaleV*(x) = β₁·log(mean_i exp(r(x, yᵢ)/β₁))est estimée et mise en cache pour chaque invite. - 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 optimalr(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
< source >( 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 (
PreTrainedModeloustr) — Modèle à entraîner, ou un identifiant de modèle (chaîne de caractères) transmis à from_pretrained. - reward_funcs (
Callableoulist[Callable]) — Fonction(s) de récompense. Chacune reçoitpromptsetcompletions(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 (voirA2POConfig.reward_weights) constitue la récompense scalairer, 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 :
- Estimation de la valeur hors ligne. Avant l'entraînement,
num_value_samplescomplétions sont échantillonnées à partir de la politique de référence pour chaque invite d'entraînement et évaluées avecreward_funcs. La valeur optimale est estimée parV*(x) = beta1 * log(mean_i exp(r(x, y_i) / beta1))et mise en cache par invite. - 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'avantager(x, y) - V*(x).
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
< source >( 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éfautTrue) — Indique si la fonction doit ne renvoyer que lorsque legit pushest terminé. - token (
str, facultatif, par défautNone) — 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 estargs.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
< source >( 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'argumentmodeldu experimental.a2po.A2POTrainer est fourni sous forme de chaîne de caractères. La valeur derevisionest également utilisée lors du chargement de la classe de traitement. - trust_remote_code (
bool, facultatif, valeur par défautFalse) — 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éfautFalse) — 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 (
intouNone, facultatif, par défaut512) — Longueur maximale du prompt. Si le prompt est plus long que cela, il est tronqué à gauche. - max_completion_length (
intouNone, facultatif, par défaut256) — Longueur maximale de la complétion générée. - temperature (
float, facultatif, valeur par défaut1.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éfaut1.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.0pour prendre en compte tous les jetons. - top_k (
intouNone, facultatif) — Nombre de jetons du vocabulaire ayant la plus haute probabilité à conserver. SiNone, 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éfaut8) — Nombre d'échantillons tirés de la politique de référence par invite pour estimerV*. - beta1 (
float, facultatif, par défaut0.5) — Température KL utilisée pour estimerV*à l’étape 1. - filter_all_incorrect (
bool, facultatif, par défautTrue) — 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éfaut1e-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. SiNone, toutes les récompenses sont pondérées également avec un poids de1.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.