Modélisation de la récompense

Aperçu

TRL prend en charge le formateur de modélisation de récompense supervisée par résultat (ORM) pour l’entraînement des modèles de récompense.

Cette méthode de post-entraînement a été proposée par Younes Belkada.

Démarrage rapide

Cet exemple montre comment entraîner un modèle de récompense à l'aide de RewardTrainer de TRL. Nous entraînons un modèle Qwen 3 0.6B sur le UltraFeedback dataset, un jeu de données de préférences à grande échelle, fin et diversifié.

from trl import RewardTrainer
from datasets import load_dataset

trainer = RewardTrainer(
    model="Qwen/Qwen3-0.6B",
    train_dataset=load_dataset("trl-lib/ultrafeedback_binarized", split="train"),
)
trainer.train()

Type et format de jeu de données attendus

RewardTrainer prend en charge le type de jeu de données preference (avec des prompts implicites et explicites). Le RewardTrainer est compatible avec les formats de jeu de données standard et conversational. Lorsqu’un jeu de données conversational est fourni, l’entraîneur applique automatiquement le modèle de chat au jeu de données.

# Standard preference (implicit prompt)
{"chosen": "The sky is blue.",
 "rejected": "The sky is green."}

# Conversational preference (implicit prompt)
{"chosen": [{"role": "user", "content": "What color is the sky?"},
            {"role": "assistant", "content": "It is blue."}],
 "rejected": [{"role": "user", "content": "What color is the sky?"},
              {"role": "assistant", "content": "It is green."}]}

# Standard preference (explicit prompt)
{"prompt": "The sky is",
 "chosen": " blue.",
 "rejected": " green."}

# Conversational preference (explicit prompt)
{"prompt": [{"role": "user", "content": "What color is the sky?"}],
 "chosen": [{"role": "assistant", "content": "It is blue."}],
 "rejected": [{"role": "assistant", "content": "It is green."}]}

Si votre jeu de données n'est pas dans l'un de ces formats, vous pouvez le prétraiter pour le convertir dans le format attendu. Voici un exemple avec le jeu de données lmarena-ai/arena-human-preference-55k :

from datasets import load_dataset
import json

dataset = load_dataset("lmarena-ai/arena-human-preference-55k")

# Filter out ties
dataset = dataset.filter(lambda example: example["winner_tie"] == 0)

# Create 'chosen' and 'rejected' fields based on the winner column
def response_a_b_to_chosen_rejected(example):
    if example["winner_model_a"] == 1:
        example["chosen"] = example["response_a"]
        example["rejected"] = example["response_b"]
    else:
        example["chosen"] = example["response_b"]
        example["rejected"] = example["response_a"]
    return example

dataset = dataset.map(response_a_b_to_chosen_rejected)

# Convert to conversational format
def make_conversation(example):
    prompt = json.loads(example["prompt"])[0]  # '["What color is the sky?"]' -> "What color is the sky?"
    chosen = json.loads(example["chosen"])[0]
    rejected = json.loads(example["rejected"])[0]
    return {
        "chosen": [{"role": "user", "content": prompt}, {"role": "assistant", "content": chosen}],
        "rejected": [{"role": "user", "content": prompt}, {"role": "assistant", "content": rejected}],
    }


dataset = dataset.map(make_conversation)

# Keep only necessary columns
dataset = dataset.select_columns(["chosen", "rejected"])

print(next(iter(dataset["train"])))

{
    "chosen": [
        {"role": "user", "content": "Is it morally right to try to have a certain percentage of females on managerial positions?"},
        {"role": "assistant", "content": "The question of whether it is morally right to aim for a certain percentage of females..."},
    ],
    "rejected": [
        {"role": "user", "content": "Is it morally right to try to have a certain percentage of females on managerial positions?"},
        {"role": "assistant", "content": "As an AI, I don't have personal beliefs or opinions. However, ..."},
    ],
}

Explorer plus en profondeur la méthode d'entraînement

Les modèles de récompense (RMs) sont généralement entraînés à l'aide d'un apprentissage supervisé sur des jeux de données contenant des paires de réponses préférées et non préférées. L'objectif est d'apprendre une fonction qui attribue des scores plus élevés aux réponses préférées, permettant ainsi au modèle de classer les sorties en fonction des préférences.

Cette section détaille le fonctionnement pratique du modelage de récompense, en couvrant les étapes clés : prétraitement et calcul de la perte.

Prétraitement et tokenisation

Lors de l’entraînement, chaque exemple est censé contenir un champ chosen et un champ rejected. Pour plus de détails sur les formats attendus, consultez Dataset formats - Preference. Le RewardTrainer tokenise chaque entrée à l’aide du tokenizer du modèle. Si les prompts et les complétions (chosen et rejected) sont fournis séparément (cas du prompt explicite), ils sont concaténés avant la tokenisation.

Calcul de la perte

Soit $x$ la séquence d'entrée (invite) et $y^+$ et $y^-$ les séquences choisie et rejetée respectivement. Selon le modèle de Bradley-Terry (Bradley & Terry, 1952), la probabilité que $y^+$ soit préférée à $y^-$ étant donnée une fonction de récompense $r$ est $p(y^+ ≻ y^- |x) = \sigma(r(x, y^+)−r(x, y^-))$ , où $σ$ est la fonction sigmoïde.

Le modèle de récompense $r_\theta(x, y)$ est entraîné à attribuer des scores plus élevés aux réponses préférées $y^+$ par rapport aux réponses non préférées $y^-$ . La perte est alors définie comme la négative de la log-vraisemblance des préférences observées : $\mathcal{L}(\theta) = - \mathbb{E}_{(x,y^+,y^-) \sim \mathcal{D}} \left[ \log \sigma(r_\theta(x, y^+) - r_\theta(x, y^-)) \right].$

Le modèle Bradley-Terry est sous-déterminé, ce qui signifie que l'ajout d'une constante à toutes les récompenses ne modifie pas les probabilités de préférence. Pour remédier à cela, Helping or Herding? Reward Model Ensembles Mitigate but do not Eliminate Reward Hacking propose d'ajouter un terme de perte auxiliaire qui encourage les récompenses à être centrées autour de zéro. Cela est contrôlé par le paramètre center_rewards_coefficient dans RewardConfig. La valeur recommandée est 1e-2.

Métriques journalisées

Lors de l'entraînement et de l'évaluation, nous enregistrons les métriques suivantes :

global_step : le nombre total d'étapes d'optimiseur effectuées jusqu'à présent.
epoch : numéro de l'époque en cours, basé sur l'itération du jeu de données.
num_tokens : le nombre total de jetons traités jusqu'à présent.
loss : la perte moyenne sur le dernier intervalle de journalisation.
accuracy : La proportion de prédictions correctes (c’est-à-dire que le modèle a attribué un score plus élevé à la réponse choisie qu’à la réponse rejetée), calculée en moyenne sur le dernier intervalle de journalisation.
min_reward : Le score de récompense minimal attribué par le modèle. Cette valeur est moyennée sur l'intervalle de journalisation.
mean_reward : Le score de récompense moyen attribué par le modèle au cours de la dernière période de journalisation.
max_reward : Le score de récompense maximal attribué par le modèle. Cette valeur est moyennée sur l'intervalle de journalisation.
margin : la marge moyenne (différence entre les récompenses choisies et rejetées) sur le dernier intervalle de journalisation.
learning_rate : le taux d'apprentissage actuel, susceptible de changer dynamiquement si un planificateur est utilisé.
grad_norm : la norme L2 des gradients, calculée avant le rognage des gradients.

Personnalisation

Initialisation du modèle

Vous pouvez passer directement les kwargs de la méthode from_pretrained() à RewardConfig. Par exemple, si vous souhaitez charger un modèle dans une précision différente, de manière analogue à

model = AutoModelForSequenceClassification.from_pretrained("Qwen/Qwen3-0.6B", dtype=torch.bfloat16)

vous pouvez le faire en passant l'argument model_init_kwargs={"dtype": torch.bfloat16} à RewardConfig.

from trl import RewardConfig

training_args = RewardConfig(
    model_init_kwargs={"dtype": torch.bfloat16},
)

Notez que tous les arguments par mot-clé de from_pretrained() sont pris en charge, à l'exception de num_labels, qui est automatiquement défini à 1.

Entraîner des adaptateurs avec PEFT

Nous prenons en charge une intégration étroite avec la bibliothèque 🤗 PEFT, permettant à tout utilisateur d’entraîner et de partager des adaptateurs sur le Hub de manière pratique, plutôt que d’entraîner l’ensemble du modèle.

from datasets import load_dataset
from trl import RewardTrainer
from peft import LoraConfig

dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

trainer = RewardTrainer(
    "Qwen/Qwen3-4B",
    train_dataset=dataset,
    peft_config=LoraConfig(modules_to_save=["score"])  # important to include the score head when base model is not a sequence classification model
)

trainer.train()

Vous pouvez également poursuivre l’entraînement de votre PeftModel. Pour cela, chargez d’abord un PeftModel en dehors de RewardTrainer et transmettez-le directement à l’entraîneur sans passer l’argument peft_config.

from datasets import load_dataset
from trl import RewardTrainer
from peft import AutoPeftModelForCausalLM

model = AutoPeftModelForCausalLM.from_pretrained("trl-lib/Qwen3-4B-Reward-LoRA", is_trainable=True)
dataset = load_dataset("trl-lib/Capybara", split="train")

trainer = RewardTrainer(
    model=model,
    train_dataset=dataset,
)

trainer.train()

Lors de l’entraînement d’adapters, vous utilisez généralement un taux d’apprentissage plus élevé (≈1e‑3) puisque seuls les nouveaux paramètres sont appris.
RewardConfig(learning_rate=1e-3, ...)

Appel d'outils avec modélisation de récompense

Le RewardTrainer prend entièrement en charge l’ajustement fin des modèles dotés de capacités de tool calling. Dans ce cas, chaque exemple du jeu de données doit inclure :

Les messages de la conversation, y compris les appels d'outils (tool_calls) et les réponses d'outils (messages avec le rôle tool)
La liste des outils disponibles dans la colonne tools, généralement fournie sous forme de schémas JSON

Pour plus de détails sur la structure attendue du jeu de données, consultez la section Format du jeu de données — Tool Calling.

RewardTrainer

classe trl.RewardTrainer

< source >

( model: str | PreTrainedModel | PeftModelargs: trl.trainer.reward_config.RewardConfig | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = Noneeval_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | datasets.dataset_dict.DatasetDict | datasets.dataset_dict.IterableDatasetDict | dict[str, datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset] | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None)optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = Nonepreprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = Nonequantization_config: BitsAndBytesConfig | None = Nonepeft_config: PeftConfig | None = None )

Paramètres

model (str ou PreTrainedModel ou PeftModel) — Modèle à entraîner. Peut être l'un des éléments suivants :
- Une chaîne de caractères, correspondant à l'identifiant du modèle d'un modèle pré-entraîné hébergé dans un dépôt de modèles sur huggingface.co, ou à un chemin vers un dossier contenant les poids du modèle enregistrés à l'aide de save_pretrained, par exemple './my_model_directory/'. Le modèle est chargé à l'aide de AutoModelForSequenceClassification.from_pretrained avec les arguments nommés de args.model_init_kwargs. Si dtype n'est pas spécifié dans args.model_init_kwargs, la valeur par défaut est float32. Cela diffère de from_pretrained, où (depuis Transformers v5) le type de données est déduit de la configuration du modèle.
- Un objet PreTrainedModel de classification de séquences.
- Un objet PeftModel de classification de séquences.
args (RewardConfig, facultatif) — Configuration de ce formateur. Si None, une configuration par défaut est utilisée.
data_collator (DataCollator, facultatif) — Fonction à utiliser pour former un lot à partir d'une liste d'éléments du train_dataset ou eval_dataset traité. La valeur par défaut est DataCollatorForPreference.
train_dataset (Dataset ou IterableDataset) — Jeu de données à utiliser pour l'entraînement. Cet entraîneur prend en charge le type préférence (à la fois implicite et explicite). Le format des échantillons peut être l'un des deux suivants :
- Standard : chaque échantillon contient du texte brut.
- Conversationnel : chaque échantillon contient des messages structurés (par exemple, le rôle et le contenu).
Le formateur prend également en charge les jeux de données traités (tokenisés), à condition qu’ils contiennent les champs chosen_ids et rejected_ids.

Lorsque train_dataset est un IterableDataset (par exemple un jeu de données en streaming), max_steps doit être défini dans les arguments d’entraînement, car sa longueur ne peut pas être déduite et le nombre total d’étapes d’entraînement est nécessaire pour limiter la boucle d’entraînement et configurer le planificateur de taux d’apprentissage.
eval_dataset (Dataset, IterableDataset, DatasetDict, IterableDatasetDict ou dict[str, Dataset | IterableDataset]) — Jeu de données à utiliser pour l'évaluation. Il doit répondre aux mêmes exigences que train_dataset.
processing_class (PreTrainedTokenizerBase, facultatif) — Tokenizer utilisé pour traiter les données. Si None, le tokenizer est chargé à partir du nom du modèle avec from_pretrained. Un jeton de bourrage, processing_class.pad_token, doit être défini. Si la classe de traitement n’a pas défini de jeton de bourrage, processing_class.eos_token sera utilisé par défaut.
compute_metrics (Callable[[EvalPrediction], dict], facultatif) — La fonction utilisée pour calculer les métriques lors de l'évaluation. Elle doit prendre un EvalPrediction en entrée et renvoyer un dictionnaire associant des chaînes de caractères aux valeurs des métriques. Lors du passage d'un RewardConfig avec batch_eval_metrics défini sur True, votre fonction compute_metrics doit prendre un argument booléen compute_result. Cela sera déclenché après le dernier lot d'évaluation pour indiquer que la fonction doit calculer et renvoyer les statistiques globales de synthèse plutôt que d'accumuler les statistiques au niveau du lot.
callbacks (liste de TrainerCallback, facultatif) — Liste de callbacks pour personnaliser la boucle d'entraînement. Ils seront ajoutés à la liste des callbacks par défaut détaillée ici.
Si vous souhaitez supprimer l'un des callbacks par défaut utilisés, utilisez la méthode remove_callback.
optimizers (tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None], facultatif, par défaut (None, None)) — Un tuple contenant l'optimiseur et le planificateur à utiliser. Par défaut, une instance de AdamW est utilisée sur votre modèle ainsi qu'un planificateur défini par get_linear_schedule_with_warmup et contrôlé par args.
optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], Dict[str, Any]], facultatif) — Un tuple contenant la classe d'optimiseur et les arguments nommés à utiliser. Remplace optim et optim_args dans args. Incompatible avec l'argument optimizers argument.
Contrairement à optimizers, cet argument évite d’avoir à placer les paramètres du modèle sur les bons appareils avant d’initialiser le Trainer.
preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], facultatif) — Une fonction qui prétraite les logits juste avant de les mettre en cache à chaque étape d'évaluation. Elle doit prendre deux tenseurs en entrée, les logits et les étiquettes, et renvoyer les logits une fois traités comme souhaité. Les modifications apportées par cette fonction seront reflétées dans les prédictions reçues par compute_metrics.
Notez que les étiquettes (deuxième paramètre) seront None si le jeu de données ne les contient pas.
quantization_config (BitsAndBytesConfig, facultatif) — Configuration de quantification utilisée lors du chargement du modèle à partir d'un identifiant de modèle. À combiner avec peft_config pour l'entraînement QLoRA. Ignoré si le modèle est déjà instancié, ou si quantization_config est également défini dans args.model_init_kwargs.
peft_config (PeftConfig, facultatif) — Configuration PEFT utilisée pour envelopper le modèle. Si None, le modèle n’est pas enveloppé. Notez que si le modèle chargé est un LM causal, il est fortement recommandé de définir modules_to_save=["score"] dans la configuration PEFT afin de garantir que la tête de récompense est correctement entraînée.

Trainer pour les modèles de récompense supervisés par résultat (ORM).

Cette classe est un wrapper autour de la classe Trainer et hérite de tous ses attributs et méthodes.

Exemple :

>>> from trl import RewardTrainer
>>> from datasets import load_dataset

>>> dataset = load_dataset("trl-lib/ultrafeedback_binarized", split="train")

>>> trainer = RewardTrainer(
...     model="Qwen/Qwen2.5-0.5B-Instruct",
...     train_dataset=dataset,
... )
>>> trainer.train()

train

< source >

Paramètres

resume_from_checkpoint (str ou bool, facultatif) — Si c'est une str, chemin local d'un point de contrôle enregistré par une instance précédente de Trainer. Si c'est un bool et vaut True, charge le dernier point de contrôle dans args.output_dir enregistré par une instance précédente de Trainer. S'il est présent, l'entraînement reprendra à partir des états du modèle/optimiseur/planificateur chargés ici.
trial (optuna.Trial ou dict[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.

save_model

< source >

( 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

< source >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | 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 ».
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.

RewardConfig

classe trl.RewardConfig

< source >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 0.0001lr_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 = 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 = 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 = -1model_init_kwargs: dict[str, typing.Any] | str | None = Nonetrust_remote_code: bool = Falsechat_template_path: str | None = Nonedisable_dropout: bool = Truedataset_num_proc: int | None = Noneeos_token: str | None = Nonemax_length: int | None = 1024pad_to_multiple_of: int | str | None = 'auto'center_rewards_coefficient: float | None = Noneactivation_offloading: bool = Falsepad_token: str | None = None )

Paramètres qui contrôlent le modèle

model_init_kwargs (dict[str, Any], facultatif) — Arguments par mot-clé pour from_pretrained, utilisés lorsque l’argument model du RewardTrainer est fourni sous forme de chaîne de caractères. La valeur de revision est également utilisée lors du chargement du tokenizer.
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.
chat_template_path (str, facultatif) — Si spécifié, définit le modèle de chat du modèle. Il peut s’agir du chemin vers un tokenizer (répertoire local ou modèle du Hugging Face Hub) ou d’un chemin direct vers un fichier de modèle Jinja. Lors de l’utilisation d’un fichier Jinja, vous devez vous assurer que les jetons spéciaux référencés dans le modèle sont ajoutés au tokenizer et que la couche d’incorporation du modèle est redimensionnée en conséquence.
disable_dropout (bool, facultatif, valeur par défaut True) — Indique s'il faut désactiver le dropout dans le modèle.

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

dataset_num_proc (int, facultatif) — Nombre de processus à utiliser pour le traitement du jeu de données.
eos_token (str, facultatif) — Jeton utilisé pour indiquer la fin d'un tour ou d'une séquence. Si None, la valeur par défaut est processing_class.eos_token.
max_length (int ou None, facultatif, par défaut 1024) — Longueur maximale de la séquence tokenisée. Les échantillons sont filtrés si la séquence choisie ou rejetée dépasse cette valeur. Si None, aucun filtrage n’est appliqué.
pad_to_multiple_of (int ou str, facultatif, valeur par défaut "auto") — Si défini, les séquences seront remplies jusqu'à un multiple de cette valeur. "auto" remplit jusqu'à un multiple de 128 sur Neuron (AWS Trainium), qui compile une fois par forme d'entrée, et ne remplit pas ailleurs.

Paramètres qui contrôlent l'entraînement

center_rewards_coefficient (float, facultatif) — Coefficient pour inciter le modèle de récompense à produire des récompenses de moyenne nulle (proposé par ce papier, Éq. 2). Valeur recommandée : 0.01.
activation_offloading (bool, facultatif, valeur par défaut False) — Indique s'il faut décharger les activations sur le CPU.

Paramètres obsolètes

pad_token —
Le paramètre pad_token est obsolète et sera supprimé dans la version v2.0.0. Définissez directement tokenizer.pad_token et passez-le en tant que processing_class au formateur à la place.

Classe de configuration pour le RewardTrainer.

Cette classe ne contient que les paramètres spécifiques à l’entraînement par récompense. 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 est 10 au lieu de 500.

gradient_checkpointing : la valeur par défaut est True au lieu de False.

bf16 : passe à True par défaut si fp16 n’est pas défini, au lieu de False.

learning_rate : la valeur par défaut est 1e-4 au lieu de 5e-5.

Update on GitHub