# Modélisation de la récompense

[![model badge](https://img.shields.io/badge/All_models-Reward_Trainer-blue)](https://huggingface.co/models?other=reward-trainer,trl)

## 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](https://huggingface.co/ybelkada).

## Démarrage rapide

Cet exemple montre comment entraîner un modèle de récompense à l'aide de [RewardTrainer](/docs/trl/v1.18.0/fr/reward_trainer#trl.RewardTrainer) de TRL. Nous entraînons un modèle [Qwen 3 0.6B](https://huggingface.co/Qwen/Qwen3-0.6B) sur le [UltraFeedback dataset](https://huggingface.co/datasets/trl-lib/ultrafeedback_binarized), un jeu de données de préférences à grande échelle, fin et diversifié.

```python
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](/docs/trl/v1.18.0/fr/reward_trainer#trl.RewardTrainer) prend en charge le type de jeu de données [preference](dataset_formats#preference) (avec des prompts implicites et explicites). Le [RewardTrainer](/docs/trl/v1.18.0/fr/reward_trainer#trl.RewardTrainer) est compatible avec les formats de jeu de données [standard](dataset_formats#standard) et [conversational](dataset_formats#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.

```python
# 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](https://huggingface.co/datasets/lmarena-ai/arena-human-preference-55k) :

```python
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"])))
```

```json
{
    "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](dataset_formats#preference). Le [RewardTrainer](/docs/trl/v1.18.0/fr/reward_trainer#trl.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](https://www.jstor.org/stable/2334029)), 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]. $$

> [!TIP]
> 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](https://huggingface.co/papers/2312.09244) 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](/docs/trl/v1.18.0/fr/reward_trainer#trl.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](/docs/trl/v1.18.0/fr/reward_trainer#trl.RewardConfig). Par exemple, si vous souhaitez charger un modèle dans une précision différente, de manière analogue à

```python
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](/docs/trl/v1.18.0/fr/reward_trainer#trl.RewardConfig).

```python
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.

```python
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](/docs/trl/v1.18.0/fr/reward_trainer#trl.RewardTrainer) et transmettez-le directement à l’entraîneur sans passer l’argument `peft_config`.

```python
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()
```

> [!TIP]
> 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.
>
> ```python
> RewardConfig(learning_rate=1e-3, ...)
> ```

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

Le [RewardTrainer](/docs/trl/v1.18.0/fr/reward_trainer#trl.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](dataset_formats#tool-calling).

## RewardTrainer[[trl.RewardTrainer]]

#### trl.RewardTrainer[[trl.RewardTrainer]]

```python
trl.RewardTrainer(model: str | PreTrainedModel | PeftModel, args: trl.trainer.reward_config.RewardConfig | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: datasets.arrow_dataset.Dataset | datasets.iterable_dataset.IterableDataset | None = None, eval_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 = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: 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 = None, preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None, quantization_config: BitsAndBytesConfig | None = None, peft_config: PeftConfig | None = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/trainer/reward_trainer.py#L233)

**Paramètres :**

model (`str` ou [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) ou `PeftModel`) : Modèle à entraîner. Peut être :  - 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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.save_pretrained), par exemple `'./my_model_directory/'`. Le modèle est chargé à l'aide de `AutoModelForSequenceClassification.from_pretrained` avec les arguments par mot-clé 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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel.from_pretrained), où (depuis Transformers v5) le type de données est déduit de la configuration du modèle. - Un objet [PreTrainedModel](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/model#transformers.PreTrainedModel) de classification de séquences. - Un objet `PeftModel` de classification de séquences.

args ([RewardConfig](/docs/trl/v1.18.0/fr/reward_trainer#trl.RewardConfig), *facultatif*) : Configuration pour cet entraîneur. 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 du `eval_dataset` traités. La valeur par défaut est `DataCollatorForPreference`.

train_dataset ([Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset) ou [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset)) : Jeu de données à utiliser pour l’entraînement. Cet entraîneur prend en charge le type [preference](#preference) (à la fois les prompts implicites et explicites). Le format des échantillons peut être : - [Standard](dataset_formats#standard) : chaque échantillon contient du texte brut. - [Conversational](dataset_formats#conversational) : chaque échantillon contient des messages structurés (par exemple, rôle et contenu). L’entraîneur prend également en charge les jeux de données prétraités (tokenisés), à condition qu’ils contiennent les champs `chosen_ids` et `rejected_ids`. Lorsque `train_dataset` est un [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.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](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), [IterableDataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.IterableDataset), [DatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.DatasetDict), [IterableDatasetDict](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.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](https://huggingface.co/docs/transformers/v5.23.0/en/internal/tokenization_utils#transformers.PreTrainedTokenizerBase), *facultatif*) : Tokenizer utilisé pour traiter les données. Si `None`, le tokenizer est chargé à partir du nom du modèle avec [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.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 qui sera utilisée pour calculer les métriques lors de l'évaluation. Elle doit prendre un [EvalPrediction](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.EvalPrediction) en entrée et retourner un dictionnaire associant des chaînes de caractères aux valeurs des métriques. Lors du passage de [RewardConfig](/docs/trl/v1.18.0/fr/reward_trainer#trl.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 retourner les statistiques globales de synthèse plutôt que d'accumuler les statistiques au niveau du lot.

callbacks (liste de [TrainerCallback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/callback#transformers.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](https://huggingface.co/docs/transformers/main_classes/callback). Si vous souhaitez supprimer l'un des callbacks par défaut utilisés, utilisez la méthode [remove_callback](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer.remove_callback).

optimizers (`tuple[torch.optim.Optimizer | None, torch.optim.lr_scheduler.LambdaLR | None]`, *facultatif*, valeur par défaut `(None, None)`) : Un tuple contenant l'optimiseur et le planificateur à utiliser. Par défaut, une instance de `AdamW` est appliquée à votre modèle, ainsi qu'un planificateur défini par [get_linear_schedule_with_warmup](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/optimizer_schedules#transformers.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`. 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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/quantization#transformers.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ée 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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.Trainer) et hérite de tous ses attributs et méthodes.

Exemple :

```python
>>> 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[[trl.RewardTrainer.train]]

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L1450)

**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* tel qu'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[[trl.RewardTrainer.save_model]]

```python
save_model(output_dir: str | None = None, _internal_call: bool = False)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4077)

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[[trl.RewardTrainer.push_to_hub]]

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/transformers/trainer.py#L4337)

**Paramètres :**

commit_message (`str`, *facultatif*, par défaut `"End of training"`) : Message à commiter lors de la poussée.

blocking (`bool`, *facultatif*, par défaut `True`) : Indique si la fonction doit ne renvoyer un résultat qu'une fois le `git push` terminé.

token (`str`, *facultatif*, valeur par défaut `None`) : Jeton avec permission d'écriture pour écraser les arguments d'origine du Trainer.

revision (`str`, *facultatif*) : La révision git à partir de laquelle effectuer le commit. Par défaut, il s'agit de la tête de la branche "main".

private (`bool`, *facultatif*) : Indique s'il faut rendre le dépôt privé lors de sa création. La valeur par défaut est `args.hub_private_repo`. N'a aucun effet si le dépôt existe déjà.

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires passés à `~Trainer.create_model_card`.

**Retourne :**

L'URL du dépôt où le modèle a été poussé si `blocking=False`, ou un objet `Future` suivant la progression de l'engagement si `blocking=True`.

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[[trl.RewardConfig]]

#### trl.RewardConfig[[trl.RewardConfig]]

```python
trl.RewardConfig(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 0.0001, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool | None = None, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool = True, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 10, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: accelerate.parallelism_config.ParallelismConfig | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, model_init_kwargs: dict[str, typing.Any] | str | None = None, trust_remote_code: bool = False, chat_template_path: str | None = None, disable_dropout: bool = True, dataset_num_proc: int | None = None, eos_token: str | None = None, max_length: int | None = 1024, pad_to_multiple_of: int | str | None = 'auto', center_rewards_coefficient: float | None = None, activation_offloading: bool = False, pad_token: str | None = None)
```

[Source](https://github.com/huggingface/trl/blob/v1.18.0/trl/trainer/reward_config.py#L23)

**Paramètres qui contrôlent le modèle :**

model_init_kwargs (`dict[str, Any]`, *facultatif*) : Arguments nommés pour [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForSequenceClassification.from_pretrained), utilisés lorsque l'argument `model` du [RewardTrainer](/docs/trl/v1.18.0/fr/reward_trainer#trl.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*, 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](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoModelForSequenceClassification.from_pretrained) et [from_pretrained](https://huggingface.co/docs/transformers/v5.23.0/en/model_doc/auto#transformers.AutoTokenizer.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*, par défaut `True`) : Indique s'il faut désactiver le dropout dans le modèle.

**Paramètres qui contrôlent le 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*, valeur 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 [cet article](https://huggingface.co/papers/2312.09244), Éq. 2). Valeur recommandée : `0.01`.

activation_offloading (`bool`, *facultatif*, 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](/docs/trl/v1.18.0/fr/reward_trainer#trl.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](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments). Notez que les valeurs par défaut de cette classe peuvent différer de celles de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.TrainingArguments).

À l’aide de [HfArgumentParser](https://huggingface.co/docs/transformers/v5.23.0/en/internal/trainer_utils#transformers.HfArgumentParser), nous pouvons transformer cette classe en arguments [argparse](https://docs.python.org/3/library/argparse#module-argparse) qui peuvent être spécifiés sur la ligne de commande.

> [!NOTE]
> Ces paramètres ont des valeurs par défaut différentes de [TrainingArguments](https://huggingface.co/docs/transformers/v5.23.0/en/main_classes/trainer#transformers.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` : la valeur par défaut est `True` 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`.

