TRL documentation
CPO Trainer
CPO Trainer
Aperçu
L’Optimisation Préférentielle Contrastive (CPO), telle qu’introduite dans l’article Contrastive Preference Optimization: Pushing the Boundaries of LLM Performance in Machine Translation de Haoran Xu, Amr Sharaf, Yunmo Chen, Weiting Tan, Lingfeng Shen, Benjamin Van Durme, Kenton Murray et Young Jin Kim. De manière générale, CPO entraîne les modèles à éviter de générer des traductions adéquates mais imparfaites dans les tâches de traduction automatique (MT). Toutefois, CPO constitue une approximation générale de la perte DPO et peut être appliquée à d’autres domaines, tels que le chat.
CPO vise à atténuer deux lacunes fondamentales du SFT. Premièrement, la méthodologie du SFT, qui consiste à minimiser l'écart entre les sorties prédites et les références de référence, limite intrinsèquement les performances du modèle au niveau de qualité des données d'entraînement. Deuxièmement, le SFT ne dispose d'aucun mécanisme pour empêcher le modèle de rejeter les erreurs dans les traductions. L'objectif de CPO est dérivé de l'objectif de DPO.
Démarrage rapide
Cet exemple montre comment entraîner un modèle à l'aide de la méthode CPO. Nous utilisons le modèle Qwen 0.5B comme modèle de base. Nous utilisons les données de préférence issues du jeu de données UltraFeedback. Vous pouvez consulter les données du jeu de données ici :
Voici le script pour entraîner le modèle :
# train_cpo.py
from datasets import load_dataset
from trl.experimental.cpo import CPOConfig, CPOTrainer
from transformers import AutoModelForCausalLM, AutoTokenizer
model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen2-0.5B-Instruct")
train_dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")
training_args = CPOConfig(output_dir="Qwen2-0.5B-CPO")
trainer = CPOTrainer(model=model, args=training_args, processing_class=tokenizer, train_dataset=train_dataset)
trainer.train()Exécutez le script à l'aide de la commande suivante :
torchrun --nproc_per_node 8 train_cpo.py
Type de jeu de données attendu
CPO nécessite un jeu de données de préférence. Le experimental.cpo.CPOTrainer prend en charge les formats de jeu de données conversationnel et standard. Lorsqu’un jeu de données conversationnel est fourni, l’entraîneur applique automatiquement le modèle de chat au jeu de données.
Métriques journalisées
Lors de l'entraînement et de l'évaluation, nous enregistrons les métriques suivantes :
rewards/chosen: les probabilités logiques moyennes du modèle de politique pour les réponses choisies, mises à l'échelle par betarewards/rejected: les probabilités logiques moyennes du modèle de politique pour les réponses rejetées, mises à l'échelle par betarewards/accuracies: moyenne de la fréquence à laquelle les récompenses choisies sont > que les récompenses rejetées correspondantesrewards/margins: la différence moyenne entre les récompenses choisies et les récompenses rejetées correspondantesnll_loss: la perte moyenne de log-vraisemblance négative du modèle de politique pour les réponses choisies
Variantes de CPO
Optimisation de préférences simple (SimPO)
Simple Preference Optimization (SimPO) de Yu Meng, Mengzhou Xia et Danqi Chen propose un algorithme d'optimisation des préférences plus simple et plus efficace que DPO, sans utiliser de modèle de référence. Les conceptions clés de SimPO consistent à (1) utiliser la log-vraisemblance normalisée par la longueur comme récompense implicite, et (2) à intégrer une marge de récompense cible dans l'objectif de classement de Bradley-Terry. Le code officiel est disponible sur princeton-nlp/SimPO.
L'abstract de l'article est le suivant :
L’optimisation de préférences directes (DPO) est un algorithme d’optimisation hors ligne des préférences largement utilisé, qui reparamétrise les fonctions de récompense dans l’apprentissage par renforcement à partir des retours humains (RLHF) afin d’améliorer la simplicité et la stabilité de l’entraînement. Dans ce travail, nous proposons SimPO, une approche plus simple mais plus efficace. L’efficacité de SimPO est attribuée à un élément de conception clé : l’utilisation de la probabilité logarithmique moyenne d’une séquence comme récompense implicite. Cette formulation de la récompense s’aligne mieux sur la génération du modèle et élimine le besoin d’un modèle de référence, ce qui le rend plus efficace en termes de calcul et de mémoire. De plus, nous introduisons une marge de récompense cible dans l’objectif de Bradley-Terry pour encourager une marge plus importante entre les réponses gagnantes et perdantes, améliorant ainsi davantage les performances de l’algorithme. Nous comparons SimPO à DPO et à ses variantes les plus récentes à travers divers configurations d’entraînement de pointe, incluant à la fois des modèles de base et des modèles ajustés par instructions comme Mistral et Llama3. Nous avons évalué sur des benchmarks d’instruction-following étendus, y compris AlpacaEval 2, MT-Bench et le récent benchmark difficile Arena-Hard. Nos résultats démontrent que SimPO surpasse de manière constante et significative les approches existantes sans augmenter substantiellement la longueur des réponses. Plus précisément, SimPO surpasse DPO de jusqu’à 6,4 points sur AlpacaEval 2 et de jusqu’à 7,5 points sur Arena-Hard. Notre modèle le plus performant, construit sur Llama3-8B-Instruct, atteint un taux de victoire contrôlé par la longueur remarquable de 44,7 sur AlpacaEval 2 — dépassant Claude 3 Opus sur le classement — et un taux de victoire de 33,8 sur Arena-Hard — ce qui en fait le modèle open-source 8B le plus puissant.
La perte SimPO est intégrée dans le experimental.cpo.CPOTrainer, car il s’agit d’une perte alternative qui ajoute une marge de récompense, permet une normalisation de la longueur et n’utilise pas de régularisation BC. Pour utiliser cette perte, il suffit d’activer loss_type="simpo" et cpo_alpha=0.0 dans le experimental.cpo.CPOConfig et de définir simpo_gamma à une valeur recommandée.
CPO-SimPO
Nous proposons également l'utilisation combinée de CPO et SimPO, qui permet un entraînement plus stable et de meilleures performances. Pour en savoir plus, consultez CPO-SimPO GitHub. Pour utiliser cette méthode, il suffit d'activer SimPO en définissant loss_type="simpo" et une valeur non nulle pour cpo_alpha dans experimental.cpo.CPOConfig.
AlphaPO
La méthode AlphaPO — Reward shape matters for LLM alignment (AlphaPO) d’Aman Gupta, Shao Tang, Qingquan Song, Sirou Zhu, Jiwoo Hong, Ankan Saha, Viral Gupta, Noah Lee, Eunki Kim, Jason Zhu, Natesh Pillai et S. Sathiya Keerthi est également implémentée dans experimental.cpo.CPOTrainer. AlphaPO est une méthode alternative qui applique une transformation à la forme de la fonction de récompense dans le contexte de la perte SimPO. L’abstract de l’article est le suivant :
Le Reinforcement Learning with Human Feedback (RLHF) et ses variantes ont réalisé des progrès considérables vers l'alignement efficace des grands modèles de langage (LLM) afin qu'ils suivent des instructions et reflètent les valeurs humaines. Plus récemment, des Algorithmes d'Alignement Direct (DAA) sont apparus, dans lesquels l'étape de modélisation de la récompense du RLHF est contournée en caractérisant directement la récompense comme une fonction de la politique apprise. Certains exemples populaires de DAA incluent la Direct Preference Optimization (DPO) et la Simple Preference Optimization (SimPO). Ces méthodes souffrent souvent du déplacement de vraisemblance (likelihood displacement), un phénomène par lequel les probabilités des réponses préférées sont souvent réduites de manière indésirable. Dans cet article, nous soutenons que, pour les DAA, la forme de la fonction de récompense est importante. Nous introduisons AlphaPO, une nouvelle méthode DAA qui exploite un paramètre α pour aider à modifier la forme de la fonction de récompense au-delà de la récompense logarithmique standard. AlphaPO aide à maintenir un contrôle fin sur le déplacement de vraisemblance et la sur-optimisation. Par rapport à SimPO, l'un des DAA les plus performants, AlphaPO entraîne une amélioration relative d'environ 7 % à 10 % des performances d'alignement pour les versions instruct de Mistral-7B et Llama3-8B, tout en atteignant une amélioration relative de 15 % à 50 % par rapport à DPO sur les mêmes modèles. L'analyse et les résultats présentés soulignent l'importance de la forme de la récompense et comment on peut la modifier systématiquement pour affecter la dynamique d'entraînement, ainsi que pour améliorer les performances d'alignement.
Pour utiliser cette perte telle que décrite dans l’article, nous pouvons définir loss_type="alphapo", ce qui configure automatiquement loss_type="simpo" et cpo_alpha=0.0, ainsi que alpha et simpo_gamma aux valeurs recommandées dans experimental.cpo.CPOConfig. Sinon, vous pouvez définir manuellement loss_type="simpo", cpo_alpha=0.0, ainsi que alpha et simpo_gamma aux valeurs recommandées. D’autres variantes de cette méthode sont également possibles, par exemple en définissant loss_type="ipo" et alpha à n’importe quelle valeur non nulle.
Fonctions de perte
L'algorithme CPO prend en charge plusieurs fonctions de perte. La fonction de perte peut être définie à l'aide du paramètre loss_type dans experimental.cpo.CPOConfig. Les fonctions de perte suivantes sont prises en charge :
loss_type= | Description |
|---|---|
"sigmoid" (par défaut) | À partir des données de préférence, nous pouvons entraîner un classifieur binaire selon le modèle de Bradley-Terry, et en effet, les auteurs de DPO proposent la perte sigmoïde sur la vraisemblance normalisée via logsigmoid pour ajuster une régression logistique. |
"hinge" | Les auteurs de RSO proposent d'utiliser une perte à charnière sur la vraisemblance normalisée issue de l'article SLiC. Dans ce cas, le beta est l'inverse de la marge. |
"ipo" | Les auteurs de IPO offrent une compréhension théorique plus approfondie des algorithmes DPO et identifient un problème de surapprentissage, en proposant une perte alternative. Dans ce cas, le beta est l'inverse de l'écart entre les rapports de log-vraisemblance de la paire de complétions choisie et rejetée, et donc plus le beta est petit, plus cet écart est grand. Conformément à l'article, la perte est moyennée sur les log-vraisemblances de la complétion (contrairement à DPO, qui ne fait que les sommer). |
"simpo" | La méthode SimPO est également implémentée dans experimental.cpo.CPOTrainer. SimPO est une perte alternative qui ajoute une marge de récompense, permet la normalisation de la longueur et n'utilise pas de régularisation BC. Pour utiliser cette perte, il suffit de définir loss_type="simpo" et cpo_alpha=0.0 dans experimental.cpo.CPOConfig et simpo_gamma à une valeur recommandée. |
"alphapo" | La méthode AlphaPO est également implémentée dans le experimental.cpo.CPOTrainer. Il s’agit d’un sucre syntaxique qui définit automatiquement loss_type="simpo" et cpo_alpha=0.0. AlphaPO applique une transformation à la forme de la fonction de récompense dans le contexte de la perte SimPO lorsque le paramètre alpha est non nul. |
Pour les modèles Mixture of Experts : Activer la perte auxiliaire
Les MOEs sont les plus efficaces lorsque la charge est répartie de manière à peu près égale entre les experts.
Pour nous assurer d’entraîner les MOEs de manière similaire lors de l’ajustement par préférence, il est bénéfique d’ajouter la perte auxiliaire du répartiteur de charge à la perte finale.
Cette option est activée en définissant output_router_logits=True dans la configuration du modèle (par exemple, MixtralConfig).
Pour ajuster la contribution de la perte auxiliaire à la perte totale, utilisez l'hyperparamètre router_aux_loss_coef=... (valeur par défaut : 0.001) dans la configuration du modèle.
CPOTrainer
classe trl.experimental.cpo.CPOTrainer
< source >( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, str, NoneType] = Noneargs: trl.experimental.cpo.cpo_config.CPOConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | dict[str, datasets.arrow_dataset.Dataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = Nonemodel_init: collections.abc.Callable[[], transformers.modeling_utils.PreTrainedModel] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR] = (None, None)preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonepeft_config: PeftConfig | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalLoopOutput], dict] | None = None )
Paramètres
- model (PreTrainedModel) — Le modèle à entraîner, de préférence un AutoModelForSequenceClassification.
- args (experimental.cpo.CPOConfig) — Les arguments de configuration CPO à utiliser pour l’entraînement.
- data_collator (
DataCollator) — Le collateur de données à utiliser pour l’entraînement. Si None est spécifié, le collateur de données par défaut (experimental.utils.DPODataCollatorWithPadding) sera utilisé, ce qui rembourra les séquences jusqu’à la longueur maximale des séquences du lot, étant donné un jeu de données de séquences appariées. - train_dataset (Dataset) — Le jeu de données à utiliser pour l’entraînement.
- eval_dataset (Dataset) — Le jeu de données à utiliser pour l'évaluation.
- processing_class (PreTrainedTokenizerBase, BaseImageProcessor, FeatureExtractionMixin ou ProcessorMixin, facultatif) — Classe de traitement utilisée pour traiter les données. Si fournie, elle sera utilisée pour traiter automatiquement les entrées du modèle et sera enregistrée avec le modèle afin de faciliter la reprise d'une formation interrompue ou la réutilisation du modèle affiné.
- model_init (
Callable[[], transformers.PreTrainedModel]) — L'initialiseur de modèle à utiliser pour l'entraînement. Si None est spécifié, l'initialiseur de modèle par défaut sera utilisé. - callbacks (
list[transformers.TrainerCallback]) — Les callbacks à utiliser pour l'entraînement. - optimizers (
tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]) — L’optimiseur et le planificateur à utiliser pour l’entraînement. - preprocess_logits_for_metrics (
Callable[[torch.Tensor, torch.Tensor], torch.Tensor]) — La fonction à utiliser pour prétraiter les logits avant de calculer les métriques. - peft_config (PeftConfig, facultatif) — La configuration PEFT à utiliser pour l’entraînement. Si vous passez une configuration PEFT, le modèle sera encapsulé dans un modèle PEFT.
- compute_metrics (
Callable[[EvalPrediction], dict], facultatif) — La fonction à utiliser pour calculer les métriques. Elle doit prendre unEvalPredictionet renvoyer un dictionnaire de chaînes vers les valeurs des métriques.
Initialiser CPOTrainer.
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.
CPOConfig
classe trl.experimental.cpo.CPOConfig
< source >( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 1e-06lr_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 = Truelabel_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 = -1max_length: int | None = 1024max_completion_length: int | None = Nonebeta: float = 0.1label_smoothing: float = 0.0loss_type: str = 'sigmoid'disable_dropout: bool = Truecpo_alpha: float = 1.0simpo_gamma: float = 0.5alpha: float = 0.0generate_during_eval: bool = Falseis_encoder_decoder: bool | None = Nonemodel_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falsedataset_num_proc: int | None = None )
Paramètres
- max_length (
intouNone, facultatif, par défaut1024) — Longueur maximale des séquences (invite + complétion) dans le lot. Cet argument est requis si vous souhaitez utiliser le collateur de données par défaut. - max_completion_length (
int, facultatif) — Longueur maximale de la complétion. Cet argument est requis si vous souhaitez utiliser le collateur de données par défaut et que votre modèle est un encodeur-décodeur. - beta (
float, facultatif, par défaut0.1) — Paramètre contrôlant l'écart par rapport au modèle de référence. Plus β est élevé, moins l'écart par rapport au modèle de référence est important. Pour la perte IPO (loss_type="ipo"), β est le paramètre de régularisation noté τ dans l'article. - label_smoothing (
float, facultatif, par défaut0.0) — Facteur de lissage des étiquettes. Cet argument est requis si vous souhaitez utiliser le collateur de données par défaut. - loss_type (
str, facultatif, par défaut"sigmoid") — Type de perte à utiliser. Les valeurs possibles sont :"sigmoid": perte sigmoïde issue de l’article original DPO."hinge": perte hinge sur la vraisemblance normalisée issue de l’article SLiC."ipo": perte IPO issue de l’article IPO."simpo": perte SimPO issue de l’article SimPO."alphapo": perte AlphaPO issue de l’article AlphaPO. Cela définit automatiquementloss_type="simpo"etcpo_alpha=0.0.
- disable_dropout (
bool, facultatif, valeur par défautTrue) — Indique s'il faut désactiver le dropout dans le modèle. - cpo_alpha (
float, facultatif, par défaut1.0) — Poids du régulariseur BC dans l'entraînement CPO. - simpo_gamma (
float, facultatif, par défaut0.5) — Marge de récompense cible pour la perte SimPO, utilisée uniquement lorsqueloss_type="simpo". - alpha (
float, facultatif, valeur par défaut0.0) — Paramètre qui contrôle la forme de la fonction de récompense pour tous les types de perte. Lorsque alpha=0 (par défaut), les récompenses de probabilité logarithmique standard sont utilisées. Lorsquealpha != 0, la transformation AlphaPO est appliquée :r = (1 - p^(-alpha)) / alpha, issue de l'article AlphaPO. Ce paramètre fonctionne avec tous les types de perte. - generate_during_eval (
bool, facultatif, valeur par défautFalse) — SiTrue, génère et journalise les complétions du modèle vers W&B ou Comet pendant l'évaluation. - is_encoder_decoder (
bool, facultatif) — Lorsque vous utilisez l'argumentmodel_init(appelable) pour instancier le modèle au lieu de l'argumentmodel, vous devez spécifier si le modèle renvoyé par l'appelable est un modèle encoder-decoder. - model_init_kwargs (
dict[str, Any], facultatif) — Arguments par mot-clé à passer àAutoModelForCausalLM.from_pretrainedlors de l’instanciation du modèle à partir d’une 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 qui incluent du code Python personnalisé depuis le Hub. Transmis à from_pretrained. - dataset_num_proc (
int, facultatif) — Nombre de processus à utiliser pour le traitement du jeu de données.
Classe de configuration pour le experimental.cpo.CPOTrainer.
Cette classe ne contient que les paramètres spécifiques à l’entraînement CPO. 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.
À l’aide de HfArgumentParser, nous pouvons transformer cette classe en arguments argparse qui peuvent être spécifiés sur la ligne de commande.
Ces paramètres ont des valeurs par défaut différentes de TrainingArguments :
logging_steps: la valeur par défaut est10au lieu de500.gradient_checkpointing: la valeur par défaut estTrueau lieu deFalse.bf16: passe àTruepar défaut sifp16n’est pas défini, au lieu deFalse.learning_rate: la valeur par défaut est1e-6au lieu de5e-5.