TRL documentation
SDPO
SDPO
Self-Distillation Policy Optimization (SDPO) a été introduit dans Reinforcement Learning via Self-Distillation par Jonas Hübotter, Frederike Lübeck, Lejs Behric, Anton Baumann, Marco Bagatella, Daniel Marta, Ido Hakimi, Idan Shenfeld, Thomas Kleine Buening, Carlos Guestrin et Andreas Krause.
Les grands modèles de langage sont de plus en plus affinés par apprentissage par renforcement dans des domaines vérifiables tels que le code et les mathématiques. Cependant, les méthodes actuelles d'apprentissage par renforcement avec récompenses vérifiables (RLVR) n'apprennent que d'une récompense de résultat scalaire par tentative, créant un goulot d'étranglement majeur dans l'attribution du mérite. De nombreux environnements vérifiables fournissent en réalité un retour textuel riche, tel que des erreurs d'exécution ou des évaluations d'un juge, qui expliquent pourquoi une tentative a échoué. Nous formalisons ce cadre comme l'apprentissage par renforcement avec retour riche et introduisons l'Optimisation de la politique par auto-distillation (SDPO), qui convertit le retour tokenisé en un signal d'apprentissage dense sans aucun enseignant externe ni modèle de récompense explicite. SDPO traite le modèle actuel conditionné par le retour comme un auto-enseignant et distille ses prédictions de jeton suivant informées par le retour vers la politique. De cette manière, SDPO exploite la capacité du modèle à identifier rétrospectivement ses propres erreurs dans le contexte. Dans le raisonnement scientifique, l'utilisation d'outils et la programmation compétitive sur LiveCodeBench v6, SDPO améliore l'efficacité par échantillon et la précision finale par rapport à des lignes de base RLVR solides. Notamment, SDPO surpasse également les lignes de base dans les environnements RLVR standard qui ne renvoient qu'un retour scalaire en utilisant les déroulements réussis comme retour implicite pour les tentatives échouées. Enfin, l'application de SDPO à des questions individuelles au moment du test accélère la découverte sur des tâches à récompense binaire difficiles, atteignant la même probabilité de découverte que l'échantillonnage best-of-k ou les conversations multi-tours avec 3 fois moins de tentatives.
Fonctionnement
SDPO cible l’apprentissage par renforcement avec des récompenses vérifiables (RLVR), où chaque tentative ne produit qu’une récompense scalaire creuse. Il en fait un signal dense au niveau des jetons : pour chaque invite, la politique échantillonne num_generations complétions notées par reward_funcs, un déroulement réussi (plus un retour d’information facultatif de privileged_context) devient une nouvelle invite pour l’enseignant, et la distribution de l’enseignant, informée par ce retour, sur un complément est distillée à nouveau dans la politique. L’enseignant et l’élève sont le même réseau, de sorte qu’aucun enseignant externe ou modèle de récompense n’est nécessaire au-delà du vérificateur.
Modes de perte et l'enseignant
distillation_weight contrôle la manière dont les deux signaux sont combinés en une combinaison convexe : la perte est (1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss. 1.0 (la valeur par défaut) entraîne le modèle uniquement sur la perte d’auto-distillation, 0.0 revient à la politique de gradient de type GRPO standard, et les valeurs intermédiaires mélangent les deux. L’objectif de distillation lui-même est défini par distillation_mode — "sampled_token" (la valeur par défaut) utilise une KL inverse au niveau des jetons et exige distillation_alpha=1.0, tandis que "full_logits" et "topk_logits" distillent sur le vocabulaire complet ou sur les distillation_topk premiers jetons.
teacher_model_kind sélectionne les poids de l’enseignant : "ema" (par défaut) suit l’étudiant via une moyenne mobile exponentielle synchronisée toutes les teacher_sync_steps étapes avec un taux de teacher_update_rate, "live" réutilise directement l’étudiant actuel, et "base" fige les poids initiaux. Le reprompting est régi par use_successful_as_teacher, success_reward_threshold, dont_reprompt_on_self_success et les chaînes reprompt_template / solution_template / feedback_template. La génération passe par défaut par transformers, ou par vLLM (mode colocate ou serveur) lorsque use_vllm=True.
Colonnes de jeu de données attendues
Chaque exemple doit fournir :
prompt: le prompt destiné à l'étudiantprivileged_context: texte privilégié facultatif, tel que des retours d'environnement, utilisé lorsqueinclude_environment_feedback=True
Utilisation
from datasets import Dataset
from trl.experimental.sdpo import SDPOConfig, SDPOTrainer
dataset = Dataset.from_dict(
{
"prompt": [[{"role": "user", "content": "Solve 2+2."}]],
"privileged_context": ["Your earlier answer used the wrong format."],
}
)
training_args = SDPOConfig(
output_dir="sdpo-model",
distillation_mode="topk_logits", # Explicitly select top-K logit distillation
distillation_topk=100, # Required when using top-K logit distillation
include_environment_feedback=True, # Use dataset privileged_context for teacher reprompts
)
trainer = SDPOTrainer(
model="Qwen/Qwen2.5-1.5B-Instruct",
reward_funcs=reward_func,
args=training_args,
train_dataset=dataset,
)
trainer.train()SDPO nécessite toujours une colonne prompt. Pour utiliser les retours de l’environnement, incluez également une colonne privileged_context et définissez include_environment_feedback=True. SDPO utilisera les déroulements réussis et, si activé, ce texte pour construire des requêtes d’enseignant pour l’auto-distillation.
Servir le modèle enseignant depuis le serveur vLLM
Avec teacher_model_kind="live", l’enseignant est l’étudiant actuel, dont les poids sont déjà détenus par le serveur vLLM (ils sont synchronisés à chaque étape pour la génération). Définissez use_teacher_server=True pour évaluer les log-probabilités de l’enseignant sur ce même serveur plutôt que d’exécuter un passage avant local séparé de l’enseignant, ce qui supprime l’enseignant de l’étape d’entraînement :
training_args = SDPOConfig(
output_dir="sdpo-model",
use_vllm=True,
vllm_mode="server",
teacher_model_kind="live",
use_teacher_server=True,
distillation_weight=1.0,
distillation_mode="sampled_token",
)Lors de l'utilisation du serveur enseignant :
use_vllm=Trueetvllm_mode="server"sont requisteacher_model_kinddoit être"live"(le serveur détient les poids actuels de l'étudiant)distillation_weightdoit être1.0(distillation pure ; un mélange convexe avec la perte de politique nécessite les logits du vocabulaire complet)distillation_modedoit être"sampled_token"(KL inverse sur le token réalisé) ou"topk_logits". Le serveur renvoie les log-probs top-k du teacher, de sorte quetopk_logitsdistille sur le support top-k du teacher (il ne peut pas utiliser celui de l’étudiant, contrairement à l’objectif local) ; avec un teacher"live", les deux supports coïncident presque.full_logitsn’est pas disponible.
Callbacks
Le formateur émet un petit ensemble de points d’ancrage de rappel (callback hooks) utiles pour le débogage, l’observabilité et les tests. Ces points d’ancrage sont conçus comme des points d’intégration pratiques pour les flux de travail expérimentaux d’auto-distillation.
Crochets d'auto-distillation partagés :
on_self_distillation_batch_prepared: déclenché lorsqu'un lot d'auto-distillation est prêt. La charge utile inclutprompt_ids,completion_idsetold_per_token_logpslorsque les entrées de rognage par échantillonnage d'importance sont disponibles.on_generation_batch_built: déclenché lorsqu'un nouveau lot de génération tamponné est créé. La charge utile inclutgenerate_everyetsteps_per_generation.
Accroche spécifique à SDPO :
on_teacher_context_built: déclenché après que SDPO a construit les entrées conditionnées par l’enseignant. La charge utile inclutteacher_input_ids,teacher_attention_mask,completion_masketself_distillation_mask.
Exemple de script
Utilisez examples/sdpo_math/sdpo_math.py pour lancer l’entraînement SDPO depuis la ligne de commande. Le script prend en charge les récompenses mathématiques vérifiables, les retours d’environnement via --feedback_column et PEFT/LoRA via les drapeaux standard de ModelConfig.
python examples/sdpo_math/sdpo_math.py \
--model_name_or_path Qwen/Qwen2.5-Math-1.5B-Instruct \
--dataset_name openai/gsm8k \
--dataset_config main \
--output_dir outputs/sdpo-qwen35-2b-gsm8k \
--learning_rate 5e-5 \
--dtype bfloat16 \
--bf16 true \
--max_completion_length 128 \
--use_peft \
--lora_target_modules q_proj k_proj v_proj o_proj gate_proj up_proj down_proj \
--per_device_train_batch_size 1 \
--gradient_accumulation_steps 2 \
--num_generations 8 \
--generation_batch_size 32 \
--distillation_alpha 1.0 \
--distillation_mode sampled_token \
--distillation_weight 0.5 \
--report_to none \
--eval_strategy steps \
--eval_steps 1000 \
--save_strategy noSDPOConfig
classe trl.experimental.sdpo.SDPOConfig
< 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 = 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[str, typing.Any] | None = Nonetrust_remote_code: bool = Falsedisable_dropout: bool = Truemax_prompt_length: int | None = 512num_generations: int = 8num_generations_eval: int | None = Nonemax_completion_length: int | None = 256ds3_gather_for_generation: bool = Trueshuffle_dataset: bool = Truegeneration_batch_size: int | None = Nonesteps_per_generation: int | None = Nonetemperature: float = 1.0top_p: float = 1.0top_k: int = 0min_p: float | None = Nonegeneration_kwargs: dict[str, typing.Any] | None = Nonechat_template_kwargs: dict[str, typing.Any] | None = Nonerepetition_penalty: float = 1.0cache_implementation: str | None = Noneuse_vllm: bool = Falseuse_teacher_server: bool = Falsevllm_mode: str = 'colocate'vllm_model_impl: str = 'vllm'vllm_enable_sleep_mode: bool = Falsevllm_server_base_url: str | None = Nonevllm_server_host: str = '0.0.0.0'vllm_server_port: int = 8000vllm_group_port: int = 51216vllm_server_timeout: float = 240.0vllm_tensor_parallel_size: int = 1vllm_gpu_memory_utilization: float = 0.3vllm_max_model_length: int | None = Nonenum_iterations: int = 1loss_type: str = 'dapo'mask_truncated_completions: bool = Falsedont_reprompt_on_self_success: bool = Truebeta: float = 0.0epsilon: float = 0.2epsilon_high: float | None = Noneimportance_sampling_level: str = 'token'reward_weights: list[float] | None = Nonescale_rewards: str = 'group'distillation_alpha: float = 1.0distillation_mode: typing.Literal['sampled_token', 'full_logits', 'topk_logits'] = 'sampled_token'distillation_topk: int | None = Nonedistillation_is_clip: float | None = 2.0distillation_add_tail: bool = Falsedistillation_weight: float = 1.0teacher_model_kind: str = 'ema'teacher_update_rate: float = 0.05teacher_sync_steps: int = 1max_reprompt_len: int = 10240use_successful_as_teacher: bool = Truesuccess_reward_threshold: float = 1.0reprompt_template: str = '{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n'solution_template: str = '\nCorrect solution:\n\n{successful_previous_attempt}\n\n'feedback_template: str = '\nThe following is feedback from your unsuccessful earlier attempt:\n\n{feedback_raw}\n\n'include_environment_feedback: bool = Falseenvironment_feedback_only_without_solution: bool = Falseremove_thinking_from_demonstration: bool = Falsediagnostics_warning_interval: int = 10diagnostics_flat_tolerance: float = 1e-08 )
Paramètres qui contrôlent l'objectif de la politique en ligne
- beta (
float, facultatif, par défaut0.0) — Coefficient KL. Si0.0(par défaut), le modèle de référence n’est pas chargé, ce qui réduit l’utilisation de la mémoire et améliore la vitesse d’entraînement. DeepSeek-R1 incentivizes reasoning in LLMs through reinforcement learning utilise une valeur de0.001. - epsilon (
float, facultatif, valeur par défaut0.2) — Valeur pour le clipping. - epsilon_high (
float, facultatif) — Valeur epsilon supérieure pour le rognage. Si elle n'est pas spécifiée, elle prend par défaut la même valeur que la borne inférieure spécifiée dans l'argumentepsilon. L'article DAPO recommande0.28. - importance_sampling_level (
str, facultatif, valeur par défaut"token") — Contrôle si les ratios d’échantillonnage d’importance sont calculés au niveau'token'ou'sequence'.'token'conserve les ratios bruts de log-probabilités par jeton (un poids par jeton).'sequence'moyenne les ratios de log-probabilités sur les jetons valides pour produire un ratio unique par séquence. L’article GSPO montre que l’échantillonnage au niveau séquence donne souvent un entraînement plus stable et une meilleure adéquation avec les récompenses au niveau séquence. - 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. - scale_rewards (
stroubool, facultatif, par défaut"group") — Spécifie la stratégie de mise à l’échelle des récompenses. Les valeurs prises en charge sont :Trueou'group'(par défaut) : les récompenses sont mises à l’échelle par l’écart-type au sein de chaque groupe, garantissant une variance unitaire au sein d’un groupe.'batch': les récompenses sont mises à l’échelle par l’écart-type sur l’ensemble du lot, comme recommandé dans le papier PPO Lite.Falseou'none': aucune mise à l’échelle n’est appliquée. Le papier Dr. GRPO recommande de ne pas mettre à l’échelle les récompenses, car la mise à l’échelle par l’écart-type introduit un biais de difficulté au niveau de la question.
Paramètres qui contrôlent la perte SDPO
- distillation_weight (
float, facultatif, valeur par défaut1.0) — Poids de la combinaison convexe entre les objectifs de politique et d'auto-distillation. La perte est(1 - distillation_weight) * policy_loss + distillation_weight * distillation_loss. Doit être compris dans[0, 1].1.0(valeur par défaut) entraîne purement sur l'auto-distillation,0.0revient à la politique de gradient standard de type GRPO, et les valeurs intermédiaires mélangent les deux. - distillation_alpha (
float, facultatif, valeur par défaut1.0) — Coefficient d’interpolation de divergence. Le SDPO par échantillonnage de jetons nécessite le réglage officiel reverse-KLdistillation_alpha=1.0. - distillation_mode (
Literal["sampled_token", "full_logits", "topk_logits"], facultatif, par défaut"sampled_token") — Mode de l'objectif de distillation.sampled_tokenest le mode SDPO par défaut et nécessitedistillation_alpha=1.0. - distillation_topk (
int, facultatif) — Approximation top-k pour le SDPO au niveau des logits. Doit être défini lorsquedistillation_mode=topk_logitset laissé non défini sinon. - distillation_is_clip (
float, facultatif, valeur par défaut2.0) — Coefficient de rognage pour l'échantillonnage d'importance dans l'auto-distillation.Nonedésactive la rognage. - distillation_add_tail (
bool, facultatif, valeur par défautFalse) — Indique s'il faut ajouter un seau de queue pour la masse de probabilité non-top-k.
Paramètres qui contrôlent l'enseignant
- teacher_model_kind (
str, facultatif, par défaut"ema") — Choix sémantique de l’enseignant.baseutilise l’étudiant initial,liveutilise l’étudiant actuel etemautilise un enseignant moyenné exponentiellement. - teacher_update_rate (
float, facultatif, valeur par défaut0.05) — Taux de mise à jour de l'enseignant utilisé pour la synchronisation de l'enseignant EMA. - teacher_sync_steps (
int, facultatif, par défaut1) — Fréquence de synchronisation du modèle enseignant EMA.
Paramètres qui contrôlent la re-demande
- use_successful_as_teacher (
bool, facultatif, valeur par défautTrue) — Utiliser les déroulements réussis comme retour d'information implicite pour l'auto-distillation. - success_reward_threshold (
float, facultatif, valeur par défaut1.0) — Récompense minimale pour qu'un déroulement soit considéré comme une démonstration réussie. - dont_reprompt_on_self_success (
bool, facultatif, valeur par défautTrue) — Ignorer la nouvelle sollicitation lorsque le modèle génère une réponse correcte. - max_reprompt_len (
int, facultatif, par défaut10240) — Longueur maximale pour le reprompting en auto-distillation. - reprompt_template (
str, facultatif, par défaut"{prompt}{solution}{feedback}\n\nCorrectly solve the original question.\n") — Modèle pour relancer l’enseignant avec une démonstration réussie. - solution_template (
str, facultatif, par défaut"\nCorrect solution -- \n\n{successful_previous_attempt}\n\n") : Modèle pour formater le texte de la démonstration réussie. - feedback_template (
str, facultatif, par défaut"\nThe following is feedback from your unsuccessful earlier attempt -- \n\n{feedback_raw}\n\n") : Modèle pour formater les retours de l’environnement lors d’une nouvelle tentative. - include_environment_feedback (
bool, facultatif, valeur par défautFalse) — Indique s'il faut inclure les retours de l'environnement dans les relances de l'enseignant lorsque ceux-ci sont disponibles. - environment_feedback_only_without_solution (
bool, facultatif, par défautFalse) — Indique s'il faut utiliser le feedback uniquement lorsqu'aucune solution réussie n'est disponible. - remove_thinking_from_demonstration (
bool, facultatif, valeur par défautFalse) — Indique s'il faut supprimer les blocs <think>…</think> du texte de démonstration.
Paramètres qui contrôlent les diagnostics
- diagnostics_warning_interval (
int, facultatif, valeur par défaut10) — Émettre des diagnostics répétés de l’entraîneur toutes les N étapes dégénérées consécutives. Définir à 0 pour désactiver. - diagnostics_flat_tolerance (
float, facultatif, par défaut1e-8) — Tolérance utilisée pour déterminer si la variance de la récompense ou l'activité de réinterrogation est effectivement nulle.
Paramètres qui contrôlent le modèle
- model_init_kwargs (
dict[str, Any], facultatif) — Arguments par mot-clé pourtransformers.AutoModelForCausalLM.from_pretrained, utilisés lorsque l’argumentmodelduSDPOTrainerest fourni sous forme de chaîne de caractères. La valeur derevisionest également utilisée lors du chargement des classes 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. S'applique également au chargement des modèles de récompense et des tokenizers de récompense. - disable_dropout (
bool, facultatif, valeur par défautTrue) — Indique s'il faut désactiver le dropout dans le modèle. Cela est utile pour l'entraînement avec un modèle de référence, car cela empêche le modèle de générer des logprobs différents pour la même entrée.
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. - max_prompt_length (
int, facultatif, par défaut512) — Longueur maximale du prompt. Les prompts plus longs sont tronqués à gauche. - shuffle_dataset (
bool, facultatif, par défautTrue) — Indique s'il faut mélanger le jeu de données d'entraînement.
Paramètres qui contrôlent la génération
- num_generations (
int, facultatif, par défaut8) — Nombre de générations à échantillonner. La taille de lot effective (num_processes per_device_batch_size gradient_accumulation_steps) doit être divisible par cette valeur. - num_generations_eval (
int, facultatif) — Nombre de générations à échantillonner lors de l'évaluation. Cela permet d'utiliser moins de générations pendant l'évaluation afin d'économiser des calculs. SiNone, utilise la valeur denum_generations. - max_completion_length (
int, facultatif, par défaut256) — Longueur maximale de la complétion générée. - temperature (
float, facultatif, par défaut1.0) — Température pour l'échantillonnage. Plus la température est élevée, plus les complétions sont aléatoires. - 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 compris dans (0, 1]. Définissez-le à 1.0 pour prendre en compte tous les jetons. - top_k (
int, facultatif, par défaut0) — Nombre de jetons du vocabulaire ayant la plus haute probabilité à conserver pour le filtrage top-k. Si la valeur est0, le filtrage top-k est désactivé et tous les jetons sont pris en compte. - min_p (
float, facultatif) — Probabilité minimale du jeton, qui sera mise à l'échelle par la probabilité du jeton le plus probable. Elle doit être une valeur comprise entre 0.0 et 1.0. Les valeurs typiques se situent dans la plage 0.01-0.2. - repetition_penalty (
float, facultatif, valeur par défaut1.0) — Flottant qui pénalise les nouveaux jetons en fonction de leur présence dans le prompt et dans le texte généré jusqu’à présent. Les valeurs > 1.0 encouragent le modèle à utiliser de nouveaux jetons, tandis que les valeurs < 1.0 encouragent le modèle à répéter les jetons. - cache_implementation (
str, facultatif) — Implémentation de la méthode de cache pour une génération plus rapide lorsque use_vllm est défini sur False. - generation_kwargs (
dict[str, Any], facultatif) — Arguments supplémentaires à passer àGenerationConfig(si vous utilisez transformers) ou àSamplingParams(si vous utilisez vLLM) lors de l’échantillonnage des complétions. Cela permet de personnaliser davantage le comportement de génération, par exemple en définissantsuppress_tokens,num_beams, etc. S’il contient des clés qui entrent en conflit avec les autres paramètres de génération (commemin_p,top_p, etc.), ils les remplaceront. - chat_template_kwargs (
dict[str, Any], facultatif) — Arguments supplémentaires à passer à la fonctionapply_chat_templatelors de la génération des complétions. - ds3_gather_for_generation (
bool, facultatif, valeur par défautTrue) — Ce paramètre s’applique à DeepSpeed ZeRO-3. S’il est activé, les poids du modèle de politique sont regroupés pour la génération, ce qui améliore la vitesse de génération. Toutefois, désactiver cette option permet d’entraîner des modèles dont la taille dépasse la capacité VRAM d’une seule GPU, au prix d’une génération plus lente. La désactivation de cette option n’est pas compatible avec la génération vLLM.
Paramètres qui contrôlent l'accélération de la génération propulsée par vLLM
- use_vllm (
bool, facultatif, valeur par défautFalse) — Indique s'il faut utiliser vLLM pour générer des complétions. Si défini surTrue, l'entraîneur utilisera vLLM pour la génération au lieu de model.generate() par défaut. Nécessite l'installation devllm. - use_teacher_server (
bool, facultatif, valeur par défautFalse) — Calcule les logprobs de l’enseignant à partir du serveur de génération vLLM en cours d’exécution plutôt que d’un passage avant local de l’enseignant. Uniquement pris en charge pourteacher_model_kind='live'avecuse_vllm=True,vllm_mode='server',distillation_weight=1.0(distillation pure), etdistillation_modedans {‘sampled_token’, ‘topk_logits’} (le serveur renvoie les logprobs top-k de l’enseignant, et non le vocabulaire complet ;topk_logitsdistille sur le support top-k propre à l’enseignant). - vllm_mode (
str, facultatif, par défaut"colocate") — Mode à utiliser pour l’intégration vLLM lorsqueuse_vllmest défini surTrue. Doit être l’un des'server'ou'colocate'.'server': l’entraîneur enverra les requêtes de génération à un serveur vLLM distinct. Assurez-vous qu’un serveur vLLM est en cours d’exécution (à démarrer avecvllm serve).'colocate': vLLM s’exécutera dans le même processus et partagera les GPU d’entraînement. Cela évite le besoin d’un serveur distinct, mais peut provoquer une concurrence pour les ressources avec l’entraînement. - vllm_model_impl (
str, facultatif, par défaut"vllm") — Implémentation du modèle à utiliser pour vLLM. Doit êtretransformersouvllm.transformers: utiliser le backendtransformerspour l’implémentation du modèle.vllm: utiliser la bibliothèquevllmpour l’implémentation du modèle. - vllm_enable_sleep_mode (
bool, facultatif, valeur par défautFalse) — Active le mode veille de vLLM pour décharger les poids et le cache pendant l'étape d'optimisation. Cela maintient l'utilisation de la mémoire GPU au plus bas, mais le réveil du moteur ajoute une latence de transfert hôte-appareil. - vllm_server_base_url (
str, facultatif) — URL de base du serveur vLLM (par exemple, ‘http://localhost:8000’). Si fournie,vllm_server_hostetvllm_server_portsont ignorés. - vllm_server_host (
str, facultatif, par défaut"0.0.0.0") — Hôte du serveur vLLM auquel se connecter. Ignoré si vllm_server_base_url est fourni. - vllm_server_port (
int, facultatif, par défaut8000) — Port du serveur vLLM auquel se connecter. Ignoré si vllm_server_base_url est fourni. - vllm_group_port (
int, facultatif, valeur par défaut51216) — Numéro de port du groupe de mise à jour des poids. Il est utilisé pour communiquer avec le serveur vLLM. Sauf si le port est occupé, il n'est pas nécessaire de le modifier. - vllm_server_timeout (
float, facultatif, valeur par défaut240.0) — Durée totale de temporisation, en secondes, à attendre pour que le serveur vLLM soit opérationnel. Si le serveur n'est pas opérationnel après le dépassement de ce délai, uneConnectionErrorest levée. - vllm_tensor_parallel_size (
int, facultatif, valeur par défaut1) — Contrôle la taille du parallélisme de tenseurs pour vLLM. Ce paramètre ne s’applique que lorsquevllm_modeest défini sur'colocate'. Si vous utilisezvllm_mode='server', ce paramètre doit être transmis séparément lors du démarrage du serveur vLLM via le drapeau--vllm_tensor_parallel_size. - vllm_gpu_memory_utilization (
float, facultatif, valeur par défaut0.3) — Contrôle l'utilisation de la mémoire GPU pour vLLM. Ce paramètre ne s'applique que lorsquevllm_modeest défini sur'colocate'. Si vous utilisezvllm_mode='server', ce paramètre doit être transmis séparément lors du démarrage du serveur vLLM via le drapeau--vllm_gpu_memory_utilization. - vllm_max_model_length (
int, facultatif) — Fenêtre de contexte pour vLLM. Réglez-la sur au moins la longueur maximale des prompts dans le jeu de données plusmax_completion_length; si elle est omise, elle est déduite de la configuration du modèle.
Paramètres qui contrôlent l'entraînement
- loss_type (
str, facultatif, par défaut"dapo") — Spécifie la formulation de la perte à utiliser. Les valeurs prises en charge sont ‘grpo’, ‘bnpo’, ‘dr_grpo’ et ‘dapo’. ‘grpo’ : Agrège les pertes au niveau des jetons en normalisant par la longueur de la séquence. Non recommandé en raison du biais de longueur — cette approche a tendance à favoriser les complétions plus courtes avec des avantages positifs et les plus longues avec des avantages négatifs. ‘dapo’ (par défaut) : Agrège les pertes au niveau des jetons en normalisant par le nombre de jetons actifs dans le lot global accumulé. Cette méthode a été introduite dans l’article DAPO pour éliminer le biais de longueur. ‘dr_grpo’ : Agrège les pertes au niveau des jetons en normalisant par une constante globale. Cette méthode a été introduite dans l’article Dr. GRPO pour éliminer le biais de longueur. La valeur de la constante correspond àmax_completion_length. ‘bnpo’ : Agrège les pertes au niveau des jetons en normalisant par le nombre de jetons actifs dans le lot local. Notez que la normalisation est effectuée uniquement sur le lot local, de sorte que les résultats peuvent varier légèrement en fonction de la taille du lot local, malgré une taille de lot effective constante. Lors de l’utilisation deper_device_train_batch_size==1, la perte est équivalente à la perte GRPO. - num_iterations (
int, facultatif, par défaut1) — Nombre d'itérations par lot (noté μ dans l'algorithme). - generation_batch_size (
int, facultatif) — Taille de lot à utiliser pour la génération. SiNone, la valeur par défaut est la taille de lot effective d'entraînement :per_device_train_batch_size * num_processes * steps_per_generation. - steps_per_generation (
int, facultatif) — Nombre d'étapes par génération. SiNone, la valeur par défaut estgradient_accumulation_steps. - mask_truncated_completions (
bool, facultatif, valeur par défautFalse) — Lorsqu’il est activé, les complétions tronquées sont exclues du calcul de la perte, ce qui empêche qu’elles soient pénalisées à tort et introduisent du bruit pendant l’entraînement. Selon l’article DAPO, il s’agit d’une bonne pratique pour la stabilité de l’entraînement.
Classe de configuration pour le experimental.sdpo.SDPOTrainer.
SDPOTrainer
classe trl.experimental.sdpo.SDPOTrainer
< source >( model: typing.Union[str, transformers.modeling_utils.PreTrainedModel, torch.nn.Module]reward_funcs: typing.Any | list[typing.Any] | None = Noneargs: trl.experimental.sdpo.sdpo_config.SDPOConfig | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.processing_utils.ProcessorMixin | None = Nonereward_processing_classes: transformers.tokenization_utils_base.PreTrainedTokenizerBase | list[transformers.tokenization_utils_base.PreTrainedTokenizerBase] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)peft_config = None )
Trainer pour l'Optimisation de la Politique par Auto-Distillation (SDPO).
SDPO enrichit l’optimisation on-policy par une auto-distillation à partir des trajectoires à haute récompense du modèle lui-même. Il convertit les retours tokenisés en un signal d’apprentissage dense, sans aucun enseignant externe ni modèle de récompense explicite. SDPO considère le modèle actuel, conditionné par les retours, comme un auto-enseignant et distille ses prédictions de jeton suivant, informées par les retours, dans la politique.
train
< source >( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → ~trainer_utils.TrainOutput
Paramètres
- resume_from_checkpoint (
stroubool, facultatif) — Si c'est unestr, chemin local d'un point de contrôle enregistré par une instance précédente deTrainer. Si c'est unboolet vautTrue, charge le dernier point de contrôle dans args.output_dir enregistré par une instance précédente deTrainer. S'il est présent, l'entraînement reprendra à partir des états du modèle/optimiseur/planificateur chargés ici. - trial (
optuna.Trialoudict[str, Any], facultatif) — L’exécution de l’essai ou le dictionnaire d’hyperparamètres pour la recherche d’hyperparamètres. - ignore_keys_for_eval (
list[str], facultatif) — Une liste de clés dans la sortie de votre modèle (s’il s’agit d’un dictionnaire) qui doivent être ignorées lors de la collecte des prédictions pour l’évaluation pendant l’entraînement.
Retourne
~trainer_utils.TrainOutput
Objet contenant le nombre d'étapes globales, la perte d'entraînement et les métriques.
Point d'entrée principal de l'entraînement.
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.