# Trainer

La classe [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) fournit une API de formation complète pour PyTorch et prend en charge l’entraînement distribué sur plusieurs GPU/TPU, la précision mixte pour les [GPU NVIDIA](https://nvidia.github.io/apex/), les [GPU AMD](https://rocm.docs.amd.com/en/latest/rocm.html) et [`torch.amp`](https://pytorch.org/docs/stable/amp.html) pour PyTorch. [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) s’utilise de pair avec la classe [TrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments), qui offre un large éventail d’options pour personnaliser la manière dont un modèle est entraîné. Ensemble, ces deux classes constituent une API d’entraînement complète.

[Seq2SeqTrainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Seq2SeqTrainer) et [Seq2SeqTrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Seq2SeqTrainingArguments) héritent des classes [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) et [TrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments) et sont adaptés à l’entraînement de modèles pour des tâches de séquence à séquence, telles que la résumation ou la traduction.

La classe [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) est optimisée pour les modèles 🤗 Transformers et peut présenter des comportements inattendus lorsqu'elle est utilisée avec d'autres modèles. Si vous l'utilisez avec votre propre modèle, assurez-vous :

- votre modèle retourne toujours des tuples ou des sous-classes de [ModelOutput](/docs/transformers/v5.23.0/fr/main_classes/output#transformers.utils.ModelOutput)
- votre modèle peut calculer la perte si un argument `labels` est fourni et que cette perte est retournée en premier élément du tuple (si votre modèle retourne des tuples)
- votre modèle peut accepter plusieurs arguments d’étiquettes (utilisez `label_names` dans [TrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments) pour indiquer leur nom au [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer)) mais aucun d’entre eux ne doit s’appeler `"label"`

## Trainer[[api-reference]][[transformers.Trainer]]

#### transformers.Trainer[[transformers.Trainer]]

```python
transformers.Trainer(model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, NoneType] = None, args: transformers.training_args.TrainingArguments | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: Dataset | IterableDataset | datasets.Dataset | None = None, eval_dataset: Dataset | dict[str, Dataset] | datasets.Dataset | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = None, model_init: collections.abc.Callable[..., transformers.modeling_utils.PreTrainedModel] | None = None, compute_loss_func: collections.abc.Callable | 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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L260)

**Paramètres :**

model ([PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel) ou `torch.nn.Module`, *facultatif*) : Le modèle à entraîner, à évaluer ou à utiliser pour les prédictions. S'il n'est pas fourni, un `model_init` doit être passé.    [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) est optimisé pour fonctionner avec le [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel) fourni par la bibliothèque. Vous pouvez tout de même utiliser vos propres modèles définis en tant que `torch.nn.Module`, à condition qu'ils fonctionnent de la même manière que les modèles 🤗 Transformers.

args ([TrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments), *facultatif*) : Les arguments à ajuster pour l'entraînement. Par défaut, une instance basique de [TrainingArguments](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.TrainingArguments) est utilisée, avec `output_dir` défini sur un répertoire nommé *tmp_trainer* dans le répertoire courant, si aucun argument n'est fourni.

data_collator (`DataCollator`, *facultatif*) : La fonction à utiliser pour former un lot à partir d'une liste d'éléments de `train_dataset` ou `eval_dataset`. Par défaut, [default_data_collator()](/docs/transformers/v5.23.0/fr/main_classes/data_collator#transformers.default_data_collator) est utilisé si aucune `processing_class` n'est fournie, sinon une instance de [DataCollatorWithPadding](/docs/transformers/v5.23.0/fr/main_classes/data_collator#transformers.DataCollatorWithPadding) est utilisée si la processing_class est un extracteur de caractéristiques ou un tokeniseur.

train_dataset (`torch.utils.data.Dataset` | `torch.utils.data.IterableDataset` | `datasets.Dataset`, *facultatif*) : Le jeu de données à utiliser pour l’entraînement. S’il s’agit d’un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), les colonnes non acceptées par la méthode `model.forward()` sont automatiquement supprimées.  Notez que s’il s’agit d’un `torch.utils.data.IterableDataset` avec une certaine aléatorisation et que vous entraînez en mode distribué, votre jeu de données itérable doit soit utiliser un attribut interne `generator` qui est un `torch.Generator` pour l’aléatorisation et qui doit être identique sur tous les processus (et le Trainer définira manuellement la graine de ce `generator` à chaque époque), soit posséder une méthode `set_epoch()` qui définit en interne la graine des générateurs de nombres aléatoires utilisés.  Si le jeu de données n’implémente pas `__len__` (par exemple un `IterableDataset` en streaming), `max_steps` doit être défini, car le nombre total de pas d’entraînement ne peut pas être déduit.

eval_dataset (`torch.utils.data.Dataset` | dict[str, `torch.utils.data.Dataset`] | `datasets.Dataset`, *facultatif*) : Le jeu de données à utiliser pour l'évaluation. S'il s'agit d'un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), les colonnes non acceptées par la méthode `model.forward()` sont automatiquement supprimées. S'il s'agit d'un dictionnaire, l'évaluation est effectuée sur chaque jeu de données en préfixant le nom de la métrique avec la clé du dictionnaire.

processing_class (`PreTrainedTokenizerBase` ou `BaseImageProcessor` ou `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[[], PreTrainedModel]`, *facultatif*) : une fonction qui instancie le modèle à utiliser. Si elle est fournie, chaque appel à [train()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.train) démarrera à partir d'une nouvelle instance du modèle telle que définie par cette fonction. La fonction peut ne prendre aucun argument, ou un seul argument contenant l'objet d'essai optuna/Ray Tune, afin de pouvoir choisir différentes architectures en fonction des hyperparamètres (comme le nombre de couches, les tailles des couches internes, les probabilités de dropout, etc.).

compute_loss_func (`Callable`, *facultatif*) : une fonction qui accepte les sorties brutes du modèle, les étiquettes et le nombre d'éléments dans le lot accumulé complet (batch_size * gradient_accumulation_steps) et renvoie la perte. Par exemple, voir la [fonction de perte](https://github.com/huggingface/transformers/blob/052e652d6d53c2b26ffde87e039b723949a53493/src/transformers/trainer.py#L3618) par défaut utilisée par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer).

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](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.EvalPrediction) en entrée et renvoyer un dictionnaire associant des chaînes de caractères aux valeurs des métriques. *Note* Lors du passage de TrainingArgs 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](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback), *facultatif*) : une 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](callback). Si vous souhaitez supprimer l'un des callbacks par défaut utilisés, utilisez la méthode [Trainer.remove_callback()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.remove_callback).

optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`, *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()](/docs/transformers/v5.23.0/fr/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 leur mise 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 transmises à `compute_metrics`. Remarquez que les étiquettes (deuxième paramètre) seront `None` si le jeu de données ne les contient pas.

Trainer est une boucle d'entraînement et d'évaluation simple mais complète pour PyTorch, optimisée pour 🤗 Transformers.

Attributs importants :

- **model** -- Pointe toujours vers le modèle de base. Si vous utilisez un modèle transformers, il s'agira d'une sous-classe de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel).
- **model_wrapped** -- Pointe toujours vers le modèle le plus externe lorsqu'un ou plusieurs autres modules enveloppent le modèle d'origine. C'est ce modèle qui doit être utilisé pour le passage avant. Par exemple, sous `DeepSpeed`, le modèle interne est enveloppé dans `DeepSpeed`, puis à nouveau dans `torch.nn.DistributedDataParallel`. Si le modèle interne n'a pas été enveloppé, alors `self.model_wrapped` est identique à `self.model`.
- **is_model_parallel** -- Indique si un modèle a été basculé en mode parallélisme de modèle (contrairement au parallélisme de données, cela signifie que certaines couches du modèle sont réparties sur différents GPU).
- **place_model_on_device** -- Indique s'il faut placer automatiquement le modèle sur l'appareil. La valeur par défaut est `True`, sauf si le parallélisme de modèle, DeepSpeed, FSDP, une évaluation complète en fp16/bf16 ou le MP SageMaker est actif. Cette valeur peut être remplacée en sous-classant `TrainingArguments` et en surchargeant la propriété `place_model_on_device`.
- **is_in_train** -- Indique si un modèle est actuellement en cours d'exécution de `train` (par exemple, lorsque `evaluate` est appelé pendant `train`)
- **loss_is_scaled_for_ga** -- Indique si la perte renvoyée par `compute_loss` est déjà mise à l'échelle pour l'accumulation de gradients. `True` : `training_step` l'utilise telle quelle. `False` : `training_step` la divise par le nombre d'étapes d'accumulation de gradients. `None` (par défaut) : la perte est considérée comme mise à l'échelle si elle a été normalisée par `num_items_in_batch`, c'est-à-dire si le modèle accepte des arguments de perte ou si une `compute_loss_func` est transmise. Les sous-classes qui calculent leur propre perte doivent le définir.

#### add_callback[[transformers.Trainer.add_callback]]

```python
add_callback(callback: type[transformers.trainer_callback.TrainerCallback] | transformers.trainer_callback.TrainerCallback)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4692)

**Paramètres :**

callback (`type` ou [`~transformers.TrainerCallback]`) : une classe [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback) ou une instance de [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback). Dans le premier cas, un membre de cette classe sera instancié.

Ajouter un rappel à la liste actuelle de [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback).

#### autocast_smart_context_manager[[transformers.Trainer.autocast_smart_context_manager]]

```python
autocast_smart_context_manager(cache_enabled: bool | None = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2223)

Un wrapper d’assistance qui crée un gestionnaire de contexte approprié pour `autocast` en lui transmettant les arguments souhaités, selon la situation. Nous nous appuyons sur accelerate pour autocast, nous ne faisons donc rien ici.

#### call_model_init[[transformers.Trainer.call_model_init]]

```python
call_model_init(trial: optuna.Trial | dict[str, Any] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4583)

Appel de `model_init` pour obtenir une nouvelle instance de modèle, éventuellement conditionnée par un essai d’hyperparamètres.

#### compute_loss[[transformers.Trainer.compute_loss]]

```python
compute_loss(model: Module, inputs: dict[str, typing.Union[torch.Tensor, typing.Any]], return_outputs: bool = False, num_items_in_batch: typing.Union[int, torch.Tensor, NoneType] = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2122)

**Paramètres :**

model (`nn.Module`) : Le modèle pour lequel calculer la perte.

inputs (`dict[str, torch.Tensor | Any]`) : Les données d'entrée pour le modèle.

return_outputs (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut retourner les sorties du modèle en plus de la perte.

num_items_in_batch (Optional[torch.Tensor], *facultatif*) : Le nombre d'éléments du lot. S'il n'est pas fourni, la perte est calculée en utilisant la logique de réduction de taille de lot par défaut.

**Retourne :**

La perte du modèle ainsi que sa sortie si return_outputs était défini sur True

Comment la perte est calculée par Trainer. Par défaut, tous les modèles retournent la perte dans le premier élément.

Sous-classez et surchargez pour un comportement personnalisé. Si vous calculez vous-même la perte, définissez `loss_is_scaled_for_ga` pour indiquer si elle est déjà mise à l'échelle pour l'accumulation de gradients : `False` s'il s'agit d'une moyenne par lot (le Trainer la divise alors par le nombre d'étapes d'accumulation de gradients), `True` si vous l'avez déjà normalisée sur l'ensemble du lot accumulé.

#### compute_loss_context_manager[[transformers.Trainer.compute_loss_context_manager]]

```python
compute_loss_context_manager()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2211)

Un wrapper d’assistance pour regrouper des gestionnaires de contexte.

#### create_accelerator_and_postprocess[[transformers.Trainer.create_accelerator_and_postprocess]]

```python
create_accelerator_and_postprocess()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L806)

Créez l'accélérateur et effectuez la configuration post-création (FSDP, DeepSpeed, etc.).

#### create_model_card[[transformers.Trainer.create_model_card]]

```python
create_model_card(language: str | None = None, license: str | None = None, tags: str | list[str] | None = None, model_name: str | None = None, finetuned_from: str | None = None, tasks: str | list[str] | None = None, dataset_tags: str | list[str] | None = None, dataset: str | list[str] | None = None, dataset_args: str | list[str] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4263)

**Paramètres :**

language (`str`, *facultatif*) : La langue du modèle (le cas échéant)

license (`str`, *facultatif*) : La licence du modèle. Par défaut, elle correspond à la licence du modèle pré-entraîné utilisé, si le modèle d'origine fourni au `Trainer` provient d'un dépôt sur le Hub.

tags (`str` ou `list[str]`, *facultatif*) : Certaines étiquettes à inclure dans les métadonnées de la carte du modèle.

model_name (`str`, *facultatif*) : Le nom du modèle.

finetuned_from (`str`, *facultatif*) : Le nom du modèle utilisé pour l'ajustement fin de celui-ci (le cas échéant). Par défaut, il correspond au nom du dépôt du modèle d'origine fourni au `Trainer` (s'il provient du Hub).

tasks (`str` ou `list[str]`, *facultatif*) : Un ou plusieurs identifiants de tâches, à inclure dans les métadonnées de la carte du modèle.

dataset_tags (`str` ou `list[str]`, *facultatif*) : Un ou plusieurs tags de jeu de données, à inclure dans les métadonnées de la carte du modèle.

dataset (`str` ou `list[str]`, *facultatif*) : Un ou plusieurs identifiants de jeu de données, à inclure dans les métadonnées de la carte du modèle.

dataset_args (`str` ou `list[str]`, *facultatif*) : Un ou plusieurs arguments de jeu de données, à inclure dans les métadonnées de la carte du modèle.

Crée un brouillon de carte de modèle à l'aide des informations disponibles pour le `Trainer`.

#### create_optimizer[[transformers.Trainer.create_optimizer]]

```python
create_optimizer(model = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L1259)

**Retourne :** `torch.optim.Optimizer`

L'instance de l'optimiseur.

Configurer l'optimiseur.

Nous fournissons une valeur par défaut raisonnable qui fonctionne bien. Si vous souhaitez utiliser autre chose, vous pouvez passer un tuple dans l’initialisation du Trainer via `optimizers`, ou sous-classez et surchargez cette méthode dans une sous-classe.

#### create_optimizer_and_scheduler[[transformers.Trainer.create_optimizer_and_scheduler]]

```python
create_optimizer_and_scheduler(num_training_steps: int)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L1248)

Configurez l'optimiseur et le planificateur de taux d'apprentissage.

Nous fournissons une valeur par défaut raisonnable qui fonctionne bien. Si vous souhaitez utiliser autre chose, vous pouvez passer un tuple dans l’initialisation du Trainer via `optimizers`, ou sous-classez et surchargez cette méthode (ou `create_optimizer` et/ou `create_scheduler`) dans une sous-classe.

#### create_scheduler[[transformers.Trainer.create_scheduler]]

```python
create_scheduler(num_training_steps: int, optimizer: typing.Optional[torch.optim.Optimizer] = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L1347)

**Paramètres :**

num_training_steps (int) : Le nombre d'étapes d'entraînement à effectuer.

**Retourne :** `torch.optim.lr_scheduler.LRScheduler`

L'instance du planificateur de taux d'apprentissage.

Configurer le planificateur. L'optimiseur du formateur doit avoir été configuré avant l'appel de cette méthode ou transmis en tant qu'argument.

#### fin[[transformers.Trainer.end]]

```python
end()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L3105)

Terminez les trackers et détruisez le groupe de processus distribué.

Appelée une seule fois, tout à la fin d’un script, après tout ce qui nécessite les autres processus : [train()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.train), [evaluate()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.evaluate), [predict()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.predict), [save_model()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.save_model) et [push_to_hub()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.push_to_hub) communiquent tous entre les processus et échoueront une fois le groupe supprimé.

Exemple :

```python
trainer.train()
trainer.evaluate()
trainer.push_to_hub()
trainer.end()
```

#### évaluer[[transformers.Trainer.evaluate]]

```python
evaluate(eval_dataset: typing.Union[torch.utils.data.Dataset, dict[str, torch.utils.data.Dataset], NoneType] = None, ignore_keys: list[str] | None = None, metric_key_prefix: str = 'eval')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2797)

**Paramètres :**

eval_dataset (`Dataset` | dict[str, `Dataset`], *facultatif*) : Transmettez un jeu de données si vous souhaitez remplacer `self.eval_dataset`. S'il s'agit d'un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), les colonnes non acceptées par la méthode `model.forward()` sont automatiquement supprimées. S'il s'agit d'un dictionnaire, l'évaluation sera effectuée sur chaque jeu de données, en préfixant le nom de la métrique avec la clé du dictionnaire.    Si vous transmettez un dictionnaire dont les clés sont les noms des jeux de données et les valeurs les jeux de données eux-mêmes, evaluate exécutera des évaluations distinctes sur chaque jeu de données. Cela peut être utile pour surveiller l'impact de l'entraînement sur d'autres jeux de données ou simplement pour obtenir une évaluation plus fine. Lorsqu'il est utilisé avec `load_best_model_at_end`, assurez-vous que `metric_for_best_model` référence exactement l'un des jeux de données. Par exemple, si vous transmettez `{"data1": data1, "data2": data2}` pour deux jeux de données `data1` et `data2`, vous pouvez spécifier `metric_for_best_model="eval_data1_loss"` pour utiliser la perte sur `data1` et `metric_for_best_model="eval_data2_loss"` pour la perte sur `data2`.

ignore_keys (`list[str]`, *facultatif*) : Une liste de clés de 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.

metric_key_prefix (`str`, *facultatif*, par défaut `"eval"`) : Préfixe facultatif à utiliser comme préfixe de clé pour les métriques. Par exemple, la métrique "bleu" sera nommée "eval_bleu" si le préfixe est "eval" (par défaut)

**Retourne :**

Un dictionnaire contenant la perte d'évaluation et les éventuelles métriques calculées à partir des prédictions. Le dictionnaire contient également le numéro d'époque, issu de l'état d'entraînement.

Exécute l'évaluation et renvoie les métriques.

Le script d’appel sera chargé de fournir une méthode pour calculer les métriques, car celles-ci dépendent de la tâche (à passer à l’argument `compute_metrics` d’initialisation).

Vous pouvez également sous-classez et remplacer cette méthode pour injecter un comportement personnalisé.

#### evaluation_loop[[transformers.Trainer.evaluation_loop]]

```python
evaluation_loop(dataloader: DataLoader, description: str, prediction_loss_only: bool | None = None, ignore_keys: list[str] | None = None, metric_key_prefix: str = 'eval')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2896)

Boucle de prédiction/évaluation, partagée par `Trainer.evaluate()` et `Trainer.predict()`.

Fonctionne avec ou sans étiquettes.

#### floating_point_ops[[transformers.Trainer.floating_point_ops]]

```python
floating_point_ops(inputs: dict[str, typing.Union[torch.Tensor, typing.Any]])
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4216)

**Paramètres :**

inputs (`dict[str, torch.Tensor | Any]`) : Les entrées et les cibles du modèle.

**Retourne :** `int`

Le nombre d'opérations à virgule flottante.

Pour les modèles qui héritent de [PreTrainedModel](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel), cette méthode est utilisée pour calculer le nombre d’opérations en virgule flottante pour chaque passe avant + arrière. Si vous utilisez un autre modèle, implémentez une telle méthode dans le modèle ou sous-classez et écrasez cette méthode.

#### get_batch_samples[[transformers.Trainer.get_batch_samples]]

```python
get_batch_samples(epoch_iterator: Iterator, num_batches: int, device: device)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2281)

Collecte un nombre spécifié de lots de l'itérateur d'époque et compte, le cas échéant, le nombre d'éléments dans les lots pour mettre à l'échelle correctement la perte.

#### get_cp_size[[transformers.Trainer.get_cp_size]]

```python
get_cp_size()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2583)

Obtenir la taille du parallélisme de contexte

#### get_decay_parameter_names[[transformers.Trainer.get_decay_parameter_names]]

```python
get_decay_parameter_names(model: Module)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L1408)

Obtenez tous les noms de paramètres auxquels la décroissance du poids sera appliquée.

Cette fonction filtre les paramètres de deux manières :
1. Par type de couche (instances de couches spécifiées dans ALL_LAYERNORM_LAYERS)
2. Par motifs de noms de paramètres (contenant « bias » ou une variante de « norm »)

#### get_eval_dataloader[[transformers.Trainer.get_eval_dataloader]]

```python
get_eval_dataloader(eval_dataset: typing.Union[str, torch.utils.data.Dataset, NoneType] = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L936)

**Paramètres :**

eval_dataset (`str` ou `torch.utils.data.Dataset`, *facultatif*) : Si c'est une `str`, `self.eval_dataset[eval_dataset]` sera utilisé comme jeu de données d'évaluation. Si c'est un `Dataset`, `self.eval_dataset` sera remplacé. S'il s'agit d'un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), les colonnes non acceptées par la méthode `model.forward()` sont automatiquement supprimées.

Retourne le `~torch.utils.data.DataLoader` d'évaluation.

Sous-classez et surchargez cette méthode si vous souhaitez injecter un comportement personnalisé.

#### get_learning_rates[[transformers.Trainer.get_learning_rates]]

```python
get_learning_rates()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_pt_utils.py#L1304)

Retourne le taux d'apprentissage de chaque paramètre depuis self.optimizer.

#### get_num_trainable_parameters[[transformers.Trainer.get_num_trainable_parameters]]

```python
get_num_trainable_parameters()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_pt_utils.py#L1296)

Obtenir le nombre de paramètres entraînables.

#### get_optimizer_cls_and_kwargs[[transformers.Trainer.get_optimizer_cls_and_kwargs]]

```python
get_optimizer_cls_and_kwargs(args: TrainingArguments, model: transformers.modeling_utils.PreTrainedModel | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L1377)

**Paramètres :**

args (`transformers.training_args.TrainingArguments`) : les arguments d'entraînement pour la session d'entraînement.

model (`PreTrainedModel`, *facultatif*) : Le modèle en cours d'entraînement. Requis pour certains optimiseurs (GaLore, Apollo, LOMO).

**Retourne :**

Un tuple contenant la classe d'optimiseur et un dictionnaire des arguments par mot-clé de l'optimiseur.

Retourne la classe d'optimiseur et les paramètres de l'optimiseur en fonction des arguments d'entraînement.

#### get_optimizer_group[[transformers.Trainer.get_optimizer_group]]

```python
get_optimizer_group(param: typing.Union[str, torch.nn.parameter.Parameter, NoneType] = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_pt_utils.py#L1314)

**Paramètres :**

param (`str` ou `torch.nn.parameter.Parameter`, *facultatif*) : Le paramètre pour lequel le groupe d'optimiseur doit être retourné.

Retourne le groupe d'optimiseur pour un paramètre si celui-ci est fourni, sinon retourne tous les groupes d'optimiseur pour les paramètres.

#### get_sp_size[[transformers.Trainer.get_sp_size]]

```python
get_sp_size()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2575)

Obtenir la taille du parallélisme de séquence

#### get_test_dataloader[[transformers.Trainer.get_test_dataloader]]

```python
get_test_dataloader(test_dataset: Dataset)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L975)

**Paramètres :**

test_dataset (`torch.utils.data.Dataset`, *facultatif*) : Le jeu de données de test à utiliser. S'il s'agit d'un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), les colonnes non acceptées par la méthode `model.forward()` sont automatiquement supprimées.

Retourne le `~torch.utils.data.DataLoader` de test.

Sous-classez et surchargez cette méthode si vous souhaitez injecter un comportement personnalisé.

#### get_total_train_batch_size[[transformers.Trainer.get_total_train_batch_size]]

```python
get_total_train_batch_size(args: TrainingArguments)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2557)

Calcule la taille totale du lot (micro_batch * grad_accum * dp_world_size).

Tient compte de toutes les dimensions de parallélisme : TP, CP et SP.

Formule : dp_world_size = world_size // (tp_size * cp_size * sp_size)

Où :
- TP (Parallélisme de tenseurs) : Les couches du modèle sont réparties sur plusieurs GPU
- CP (Parallélisme de contexte) : Séquences divisées à l'aide de Ring Attention (FSDP2)
- SP (Parallélisme de séquence) : Séquences divisées à l'aide d'ALST/Ulysses (DeepSpeed)

Toutes les dimensions sont distinctes et multiplicatives : world_size = dp_size * tp_size * cp_size * sp_size

#### get_tp_size[[transformers.Trainer.get_tp_size]]

```python
get_tp_size()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2591)

Récupérez la taille du parallélisme tensoriel à partir de la configuration du modèle ou de DeepSpeed.

#### get_train_dataloader[[transformers.Trainer.get_train_dataloader]]

```python
get_train_dataloader()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L916)

Retourne le `~torch.utils.data.DataLoader` d'entraînement.

N'utilise aucun échantillonneur si `train_dataset` n'implémente pas `__len__`, sinon un échantillonneur aléatoire (adapté à l'entraînement distribué si nécessaire).

Sous-classez et surchargez cette méthode si vous souhaitez injecter un comportement personnalisé.

#### hyperparameter_search[[transformers.Trainer.hyperparameter_search]]

```python
hyperparameter_search(hp_space: collections.abc.Callable[['optuna.Trial'], dict[str, float]] | None = None, compute_objective: collections.abc.Callable[[dict[str, float]], float] | None = None, n_trials: int = 20, direction: str | list[str] = 'minimize', backend: str | transformers.trainer_utils.HPSearchBackend | None = None, hp_name: collections.abc.Callable[['optuna.Trial'], str] | None = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4502)

**Paramètres :**

hp_space (`Callable[["optuna.Trial"], dict[str, float]]`, *facultatif*) : Une fonction qui définit l'espace de recherche des hyperparamètres. Par défaut, elle vaut `default_hp_space_optuna()` ou `default_hp_space_ray()` selon votre backend.

compute_objective (`Callable[[dict[str, float]], float]`, *facultatif*) : Une fonction qui calcule l'objectif à minimiser ou maximiser à partir des métriques renvoyées par la méthode `evaluate`. La valeur par défaut est `default_compute_objective()`.

n_trials (`int`, *facultatif*, valeur par défaut 100) : Le nombre d'exécutions d'essai à tester.

direction (`str` ou `list[str]`, *facultatif*, par défaut `"minimize"`) : s'il s'agit d'une optimisation mono-objectif, direction est de type `str`, pouvant être `"minimize"` ou `"maximize"` ; il faut choisir `"minimize"` lors de l'optimisation de la perte de validation et `"maximize"` lors de l'optimisation d'une ou de plusieurs métriques. S'il s'agit d'une optimisation multi-objectifs, direction est de type `list[str]`, pouvant être une liste de `"minimize"` et `"maximize"` ; il faut choisir `"minimize"` lors de l'optimisation de la perte de validation et `"maximize"` lors de l'optimisation d'une ou de plusieurs métriques.

backend (`str` ou `~training_utils.HPSearchBackend`, *facultatif*) : Le backend à utiliser pour la recherche d'hyperparamètres. Par défaut, optuna ou Ray Tune sera utilisé, selon celui qui est installé. Si les deux sont installés, optuna sera utilisé par défaut.

hp_name (`Callable[["optuna.Trial"], str]]`, *facultatif*) : Une fonction qui définit le nom de l'essai/exécution. La valeur par défaut est None.

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires pour chaque backend :  - `optuna` : paramètres de [optuna.study.create_study](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.create_study.html) ainsi que les paramètres `timeout`, `n_jobs` et `gc_after_trial` de [optuna.study.Study.optimize](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.Study.html#optuna.study.Study.optimize) - `ray` : paramètres de [tune.run](https://docs.ray.io/en/latest/tune/api_docs/execution.html#tune-run). Si `resources_per_trial` n'est pas défini dans `kwargs`, la valeur par défaut est 1 cœur CPU et 1 GPU (si disponible). Si `progress_reporter` n'est pas défini dans `kwargs`, [ray.tune.CLIReporter](https://docs.ray.io/en/latest/tune/api/doc/ray.tune.CLIReporter.html) est utilisé.

**Retourne :** [`trainer_utils.BestRun` ou `list[trainer_utils.BestRun]`]

Toutes les informations sur la meilleure exécution ou les meilleures exécutions pour l’optimisation multi-objectifs. Le résumé de l’expérience peut être trouvé dans l’attribut `run_summary` pour l’arrière-plan Ray.

Lancez une recherche d'hyperparamètres à l'aide de `optuna` ou de `Ray Tune`. La quantité optimisée est déterminée par `compute_objective`, qui par défaut renvoie la perte d'évaluation lorsqu'aucune métrique n'est fournie, ou la somme de toutes les métriques dans le cas contraire.

Pour utiliser cette méthode, vous devez avoir fourni un `model_init` lors de l’initialisation de votre [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) : il est nécessaire de réinitialiser le modèle à chaque nouvelle exécution. Cela est incompatible avec l’argument `optimizers`, vous devez donc sous-classez [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) et surcharger la méthode [create_optimizer_and_scheduler()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.create_optimizer_and_scheduler) pour un optimiseur/schéma personnalisé.

#### init_hf_repo[[transformers.Trainer.init_hf_repo]]

```python
init_hf_repo(token: str | None = None, private: bool | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4237)

**Paramètres :**

token (`str`, *facultatif*) : Jeton avec permission d'écriture. Par défaut, `self.args.hub_token`.

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

Initialise un dépôt git dans `self.args.hub_model_id`.

#### is_local_process_zero[[transformers.Trainer.is_local_process_zero]]

```python
is_local_process_zero()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4732)

Indique si ce processus est le processus principal local (par exemple, sur une seule machine lors d'une formation distribuée sur plusieurs machines).

#### is_world_process_zero[[transformers.Trainer.is_world_process_zero]]

```python
is_world_process_zero()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4739)

Indique si ce processus est le processus principal global (lors de l’entraînement distribué sur plusieurs machines, cette valeur ne sera `True` que pour un seul processus).

#### log[[transformers.Trainer.log]]

```python
log(logs: dict[str, float], start_time: float | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4181)

**Paramètres :**

logs (`dict[str, float]`) : Les valeurs à consigner.

start_time (`Optional[float]`) : Le début de l'entraînement.

Journaliser `logs` sur les différents objets surveillant l'entraînement.

Sous-classez et surchargez cette méthode pour injecter un comportement personnalisé.

#### log_metrics[[transformers.Trainer.log_metrics]]

```python
log_metrics(split, metrics)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_pt_utils.py#L1152)

**Paramètres :**

split (`str`) : Nom du mode/segment : l'un des `train`, `eval`, `test`

metrics (`dict[str, float]`) : Les métriques renvoyées par train/evaluate/predictmetrics : dictionnaire de métriques

Enregistrer les métriques dans un format spécial.

Dans un environnement distribué, cela n'est effectué que pour le processus de rang 0.

Remarques sur les rapports de mémoire :

Pour obtenir un rapport d'utilisation de la mémoire, vous devez installer `psutil`. Vous pouvez le faire avec `pip install psutil`.

Lorsque cette méthode est exécutée, vous verrez un rapport qui inclura :

```
init_mem_cpu_alloc_delta   =     1301MB
init_mem_cpu_peaked_delta  =      154MB
init_mem_gpu_alloc_delta   =      230MB
init_mem_gpu_peaked_delta  =        0MB
train_mem_cpu_alloc_delta  =     1345MB
train_mem_cpu_peaked_delta =        0MB
train_mem_gpu_alloc_delta  =      693MB
train_mem_gpu_peaked_delta =        7MB
```

**Comprendre les rapports :**

- Le premier segment, par exemple `train__`, indique l’étape pour laquelle les métriques sont fournies. Les rapports commençant par `init_` seront ajoutés à la première étape exécutée. Ainsi, si seule l’évaluation est exécutée, l’utilisation de la mémoire pour `__init__` sera rapportée avec les métriques `eval_`.
- le troisième segment, qui est soit `cpu` soit `gpu`, vous indique s'il s'agit de la métrique de la RAM générale ou de la mémoire gpu0.
- `*_alloc_delta` - correspond à la différence du compteur de mémoire utilisée/allouée entre la fin et le début de l'étape - elle peut être négative si une fonction a libéré plus de mémoire qu'elle n'en a alloué.
- `*_peaked_delta` - correspond à toute mémoire supplémentaire qui a été consommée puis libérée - par rapport au compteur de mémoire actuellement allouée - il n'est jamais négatif. Lorsque vous examinez les métriques d'une étape, vous additionnez `alloc_delta` + `peaked_delta` pour connaître la quantité de mémoire nécessaire à la réalisation de cette étape.

Le rapport est généré uniquement pour le processus de rang 0 et le gpu 0 (s'il existe un gpu). Généralement, cela suffit, car le processus principal effectue la majeure partie du travail, mais ce n'est pas tout à fait le cas si le parallélisme de modèle est utilisé, car d'autres GPUs peuvent alors utiliser une quantité différente de mémoire gpu. Ce n'est pas non plus la même chose sous DataParallel, où gpu0 peut nécessiter beaucoup plus de mémoire que les autres, car il stocke les gradients et les états de l'optimiseur pour tous les GPUs participants. Peut-être que, à l'avenir, ces rapports évolueront pour mesurer également ces aspects.

La métrique de RAM CPU mesure la RSS (Resident Set Size), qui inclut à la fois la mémoire propre au processus et la mémoire partagée avec d'autres processus. Il est important de noter qu'elle n'inclut pas la mémoire échangée (swapped out), ce qui peut rendre les rapports imprécis.

La mémoire CPU de pointe est mesurée à l'aide d'un thread d'échantillonnage. En raison du GIL de Python, il est possible que certains pics de mémoire soient manqués si ce thread n'a pas eu l'occasion de s'exécuter au moment où la consommation mémoire était la plus élevée. Par conséquent, ce rapport peut être inférieur à la réalité. L'utilisation de `tracemalloc` aurait permis de rapporter la mémoire de pointe exacte, mais il ne signale pas les allocations de mémoire en dehors de Python. Ainsi, si une extension C++ CUDA a alloué sa propre mémoire, celle-ci ne sera pas signalée. C'est pourquoi cette approche a été abandonnée au profit de la méthode d'échantillonnage de la mémoire, qui lit l'utilisation actuelle de la mémoire par le processus.

L'allocation GPU et le rapport de la mémoire de pointe sont effectués à l'aide de `torch.cuda.memory_allocated()` et `torch.cuda.max_memory_allocated()`. Cette métrique ne signale que les « deltas » des allocations spécifiques à PyTorch, car le système de gestion de la mémoire `torch.cuda` ne suit pas la mémoire allouée en dehors de PyTorch. Par exemple, le premier appel CUDA charge typiquement les noyaux CUDA, ce qui peut consommer de 0,5 à 2 Go de mémoire GPU.

Notez que ce traceur ne prend pas en compte les allocations de mémoire effectuées en dehors des appels `__init__`, `train`, `evaluate` et `predict` de [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer).

Les appels à `evaluation` pouvant survenir pendant `train`, nous ne pouvons pas gérer les invocations imbriquées car `torch.cuda.max_memory_allocated` est un compteur unique. S'il est réinitialisé par un appel d'évaluation imbriqué, le traceur de `train` rapportera des informations incorrectes. Si ce [problème PyTorch](https://github.com/pytorch/pytorch/issues/16266) est résolu, il sera possible de rendre cette classe réentrante. En attendant, nous ne suivrons que le niveau externe des méthodes `train`, `evaluate` et `predict`. Cela signifie que si `eval` est appelé pendant `train`, c'est ce dernier qui tiendra compte de sa propre utilisation mémoire ainsi que de celle du premier.

Cela signifie également que si un autre outil utilisé avec le [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) appelle `torch.cuda.reset_peak_memory_stats`, les statistiques de pic de mémoire GPU pourraient être invalides. De plus, le [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) perturbera le comportement normal de tout outil de ce type qui s’appuie sur l’appel de `torch.cuda.reset_peak_memory_stats` par ses propres moyens.

Pour une performance optimale, vous pouvez envisager de désactiver le profilage mémoire pour les exécutions en production.

#### metrics_format[[transformers.Trainer.metrics_format]]

```python
metrics_format(metrics: dict[str, float])
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_pt_utils.py#L1125)

**Paramètres :**

metrics (`dict[str, float]`) : Les métriques renvoyées par train/evaluate/predict

**Retourne :** métriques (`dict[str, float]`)

Les métriques reformattées

Reformater les valeurs des métriques du Trainer dans un format lisible par l'humain.

#### num_examples[[transformers.Trainer.num_examples]]

```python
num_examples(dataloader: DataLoader)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L993)

Assistant pour obtenir le nombre d'échantillons dans un `~torch.utils.data.DataLoader` en accédant à son jeu de données. Si dataloader.dataset n'existe pas ou n'a pas de longueur, l'estime au mieux

#### pop_callback[[transformers.Trainer.pop_callback]]

```python
pop_callback(callback: type[transformers.trainer_callback.TrainerCallback] | transformers.trainer_callback.TrainerCallback)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4703)

**Paramètres :**

callback (`type` ou [`~transformers.TrainerCallback]`) : une classe [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback) ou une instance de [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback). Dans le premier cas, retire le premier membre de cette classe trouvé dans la liste des callbacks.

**Retourne :** [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback)

Le callback supprimé, s'il a été trouvé.

Supprime un rappel de la liste actuelle de [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback) et le renvoie.

Si le rappel n'est pas trouvé, renvoie `None` (et aucune erreur n'est levée).

#### predict[[transformers.Trainer.predict]]

```python
predict(test_dataset: Dataset, ignore_keys: list[str] | None = None, metric_key_prefix: str = 'test')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L3124)

**Paramètres :**

test_dataset (`Dataset`) : Jeu de données sur lequel exécuter les prédictions. S'il s'agit d'un `datasets.Dataset`, les colonnes non acceptées par la méthode `model.forward()` sont automatiquement supprimées.

ignore_keys (`list[str]`, *facultatif*) : Une liste de clés de 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.

metric_key_prefix (`str`, *facultatif*, par défaut `"test"`) : Préfixe facultatif à utiliser comme préfixe de clé pour les métriques. Par exemple, la métrique "bleu" sera nommée "test_bleu" si le préfixe est "test" (par défaut)

Exécute la prédiction et renvoie les prédictions ainsi que les métriques potentielles.

Selon le jeu de données et votre cas d’usage, votre jeu de test peut contenir des étiquettes. Dans ce cas, cette méthode renverra également des métriques, comme dans `evaluate()`.

Si vos prédictions ou vos étiquettes ont des longueurs de séquence différentes (par exemple, parce que vous effectuez un bourrage dynamique dans une tâche de classification de jetons), les prédictions seront bourrées (à droite) pour permettre la concaténation en un seul tableau. L’indice de bourrage est -100.

Retourne : *NamedTuple* Un namedtuple avec les clés suivantes :

- predictions (`np.ndarray`) : les prédictions sur `test_dataset`.
- label_ids (`np.ndarray`, *facultatif*) : les étiquettes (si le jeu de données en contenait).
- metrics (`dict[str, float]`, *facultatif*) : Le dictionnaire potentiel des métriques (si le jeu de données contenait des étiquettes).

#### prediction_step[[transformers.Trainer.prediction_step]]

```python
prediction_step(model: Module, inputs: dict[str, typing.Union[torch.Tensor, typing.Any]], prediction_loss_only: bool, ignore_keys: list[str] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L3185)

**Paramètres :**

model (`nn.Module`) : Le modèle à évaluer.

inputs (`dict[str, torch.Tensor | Any]`) : Les entrées et les cibles du modèle. Le dictionnaire sera dépaqueté avant d'être transmis au modèle. La plupart des modèles s'attendent à ce que les cibles soient fournies via l'argument `labels`. Consultez la documentation de votre modèle pour connaître tous les arguments acceptés.

prediction_loss_only (`bool`) : Indique s'il faut retourner uniquement la perte.

ignore_keys (`list[str]`, *facultatif*) : Une liste de clés de 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.

**Retourne :** tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]

Un tuple contenant la perte, les logits et les étiquettes (chacun étant facultatif).

Effectuer une étape d'évaluation sur `model` en utilisant `inputs`.

Sous-classez et écrasez pour injecter un comportement personnalisé.

#### push_to_hub[[transformers.Trainer.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/transformers/blob/v5.23.0/src/transformers/trainer.py#L4337)

**Paramètres :**

commit_message (`str`, *facultatif*, valeur 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 le contrôle 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 l'engagement. 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`. Sans effet si le dépôt existe déjà.

kwargs (`dict[str, Any]`, *facultatif*) : Arguments supplémentaires passés à [create_model_card()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.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`.

#### remove_callback[[transformers.Trainer.remove_callback]]

```python
remove_callback(callback: type[transformers.trainer_callback.TrainerCallback] | transformers.trainer_callback.TrainerCallback)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4719)

**Paramètres :**

callback (`type` ou [`~transformers.TrainerCallback]`) : une classe [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback) ou une instance de [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback). Dans le premier cas, supprime le premier membre de cette classe trouvé dans la liste des callbacks.

Supprimer un rappel de la liste actuelle de [TrainerCallback](/docs/transformers/v5.23.0/fr/main_classes/callback#transformers.TrainerCallback).

#### save_metrics[[transformers.Trainer.save_metrics]]

```python
save_metrics(split, metrics, combined = True)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_pt_utils.py#L1243)

**Paramètres :**

split (`str`) : Nom du mode/segment : l'un des `train`, `eval`, `test`, `all`

metrics (`dict[str, float]`) : Les métriques renvoyées par train/evaluate/predict

combined (`bool`, *facultatif*, valeur par défaut `True`) : Crée des métriques combinées en mettant à jour `all_results.json` avec les métriques de cet appel

Enregistrez les métriques dans un fichier json pour ce split, par exemple `train_results.json`.

Dans un environnement distribué, cela n'est effectué que pour le processus de rang 0.

Pour comprendre les métriques, veuillez lire la docstring de [log_metrics()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.log_metrics). La seule différence est que des chiffres bruts non formatés sont enregistrés dans la méthode actuelle.

#### save_model[[transformers.Trainer.save_model]]

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

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/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.

#### save_state[[transformers.Trainer.save_state]]

```python
save_state()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_pt_utils.py#L1282)

Enregistre l'état du Trainer, car Trainer.save_model n'enregistre que le tokenizer avec le modèle.

Dans un environnement distribué, cela n'est effectué que pour le processus de rang 0.

#### set_initial_training_values[[transformers.Trainer.set_initial_training_values]]

```python
set_initial_training_values(args: TrainingArguments, dataloader: DataLoader)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2487)

Calcule et renvoie les valeurs suivantes :
- `num_train_epochs`
- `num_update_steps_per_epoch`
- `num_examples`
- `num_train_samples`
- `total_train_batch_size`
- `steps_in_epoch` (nombre total de lots par époque)
- `max_steps`

#### store_flos[[transformers.Trainer.store_flos]]

```python
store_flos()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L4205)

Enregistrer le nombre d'opérations en virgule flottante effectuées pour le modèle.

#### train[[transformers.Trainer.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/transformers/blob/v5.23.0/src/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](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.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](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.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 de 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 :** `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.

#### training_step[[transformers.Trainer.training_step]]

```python
training_step(model: Module, inputs: dict[str, typing.Union[torch.Tensor, typing.Any]], num_items_in_batch: typing.Union[int, torch.Tensor, NoneType] = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer.py#L2043)

**Paramètres :**

model (`nn.Module`) : Le modèle à entraîner.

inputs (`dict[str, torch.Tensor | Any]`) : Les entrées et les cibles du modèle. Le dictionnaire sera dépaqueté avant d'être transmis au modèle. La plupart des modèles s'attendent à ce que les cibles soient fournies via l'argument `labels`. Consultez la documentation de votre modèle pour connaître tous les arguments acceptés.

**Retourne :** `torch.Tensor`

Le tenseur de la perte d'entraînement sur ce lot.

Effectuer une étape d'entraînement sur un lot d'entrées.

Sous-classez et écrasez pour injecter un comportement personnalisé.

## Seq2SeqTrainer[[transformers.Seq2SeqTrainer]]

#### transformers.Seq2SeqTrainer[[transformers.Seq2SeqTrainer]]

```python
transformers.Seq2SeqTrainer(model: typing.Union[ForwardRef('PreTrainedModel'), torch.nn.Module, NoneType] = None, args: typing.Optional[ForwardRef('TrainingArguments')] = None, data_collator: typing.Optional[ForwardRef('DataCollator')] = None, train_dataset: typing.Union[torch.utils.data.Dataset, ForwardRef('IterableDataset'), ForwardRef('datasets.Dataset'), NoneType] = None, eval_dataset: typing.Union[torch.utils.data.Dataset, dict[str, torch.utils.data.Dataset], NoneType] = None, processing_class: typing.Union[ForwardRef('PreTrainedTokenizerBase'), ForwardRef('BaseImageProcessor'), ForwardRef('FeatureExtractionMixin'), ForwardRef('ProcessorMixin'), NoneType] = None, model_init: collections.abc.Callable[[], 'PreTrainedModel'] | None = None, compute_loss_func: collections.abc.Callable | None = None, compute_metrics: collections.abc.Callable[['EvalPrediction'], dict] | None = None, callbacks: list['TrainerCallback'] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_seq2seq.py#L55)

#### évaluer[[transformers.Seq2SeqTrainer.evaluate]]

```python
evaluate(eval_dataset: typing.Optional[torch.utils.data.Dataset] = None, ignore_keys: list[str] | None = None, metric_key_prefix: str = 'eval', **gen_kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_seq2seq.py#L139)

**Paramètres :**

eval_dataset (`Dataset`, *facultatif*) : Passez un jeu de données si vous souhaitez remplacer `self.eval_dataset`. S'il s'agit d'un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), les colonnes non acceptées par la méthode `model.forward()` sont automatiquement supprimées. Il doit implémenter la méthode `__len__`.

ignore_keys (`list[str]`, *facultatif*) : Une liste de clés de 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.

metric_key_prefix (`str`, *facultatif*, par défaut `"eval"`) : Un préfixe facultatif à utiliser comme préfixe de clé pour les métriques. Par exemple, la métrique "bleu" sera nommée "eval_bleu" si le préfixe est `"eval"` (par défaut)

max_length (`int`, *facultatif*) : La longueur cible maximale à utiliser lors de la prédiction avec la méthode generate.

num_beams (`int`, *facultatif*) : Nombre de faisceaux pour la recherche par faisceaux qui sera utilisé lors de la prédiction avec la méthode generate. 1 signifie qu'aucune recherche par faisceaux n'est effectuée.

gen_kwargs : kwargs spécifiques à `generate`.

**Retourne :**

Un dictionnaire contenant la perte d'évaluation et les éventuelles métriques calculées à partir des prédictions. Le dictionnaire contient également le numéro d'époque, issu de l'état d'entraînement.

Exécute l'évaluation et renvoie les métriques.

Le script d’appel sera chargé de fournir une méthode pour calculer les métriques, car celles-ci dépendent de la tâche (à passer à l’argument `compute_metrics` d’initialisation).

Vous pouvez également sous-classez et remplacer cette méthode pour injecter un comportement personnalisé.

#### predict[[transformers.Seq2SeqTrainer.predict]]

```python
predict(test_dataset: Dataset, ignore_keys: list[str] | None = None, metric_key_prefix: str = 'test', **gen_kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/trainer_seq2seq.py#L195)

**Paramètres :**

test_dataset (`Dataset`) : Jeu de données sur lequel exécuter les prédictions. S'il s'agit d'un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), les colonnes non acceptées par la méthode `model.forward()` sont automatiquement supprimées. Doit implémenter la méthode `__len__`

ignore_keys (`list[str]`, *facultatif*) : Une liste de clés de 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.

metric_key_prefix (`str`, *facultatif*, par défaut `"eval"`) : Un préfixe facultatif à utiliser comme préfixe de clé pour les métriques. Par exemple, la métrique "bleu" sera nommée "eval_bleu" si le préfixe est `"eval"` (par défaut)

max_length (`int`, *facultatif*) : La longueur cible maximale à utiliser lors de la prédiction avec la méthode generate.

num_beams (`int`, *facultatif*) : Nombre de faisceaux pour la recherche par faisceaux qui sera utilisé lors de la prédiction avec la méthode generate. 1 signifie qu'aucune recherche par faisceaux n'est effectuée.

gen_kwargs : kwargs spécifiques à `generate`.

Exécute la prédiction et renvoie les prédictions ainsi que les métriques potentielles.

Selon le jeu de données et votre cas d’usage, votre jeu de test peut contenir des étiquettes. Dans ce cas, cette méthode renverra également des métriques, comme dans `evaluate()`.

Si vos prédictions ou vos étiquettes ont des longueurs de séquence différentes (par exemple, parce que vous effectuez un bourrage dynamique dans une tâche de classification de jetons), les prédictions seront bourrées (à droite) pour permettre leur concaténation en un seul tableau. L’indice de bourrage est -100.

Retourne : *NamedTuple* Un namedtuple avec les clés suivantes :

- predictions (`np.ndarray`) : les prédictions sur `test_dataset`.
- label_ids (`np.ndarray`, *facultatif*) : les étiquettes (si le jeu de données en contenait).
- metrics (`dict[str, float]`, *facultatif*) : Le dictionnaire potentiel des métriques (si le jeu de données contenait des étiquettes).

## TrainingArguments[[transformers.TrainingArguments]]

#### transformers.TrainingArguments[[transformers.TrainingArguments]]

```python
transformers.TrainingArguments(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 = 5e-05, 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 = False, 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 | None = None, 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 = 500, 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: typing.Any | 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)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L180)

**Paramètres :**

output_dir (`str`, *facultatif*, valeur par défaut `"trainer_output"`) : Le répertoire de sortie où les prédictions du modèle et les points de contrôle seront écrits.

**Durée d'entraînement et taille du lot :**

per_device_train_batch_size (`int`, *facultatif*, valeur par défaut : 8) : La taille du lot *par appareil*. La **taille de lot globale** est calculée comme suit : `per_device_train_batch_size * number_of_devices` dans les configurations multi-GPU ou distribuées.

num_train_epochs(`float`, *facultatif*, valeur par défaut 3.0) : Nombre total d'époques d'entraînement à effectuer (si la valeur n'est pas un entier, la partie décimale correspond au pourcentage de la dernière époque à effectuer avant l'arrêt de l'entraînement).

max_steps (`int`, *facultatif*, valeur par défaut : -1) : Remplace `num_train_epochs`. S'il est défini sur un nombre positif, il indique le nombre total d'étapes d'entraînement à effectuer. Pour un jeu de données fini, l'entraînement est répété sur le jeu de données (si toutes les données sont épuisées) jusqu'à ce que `max_steps` soit atteint. Il doit être défini sur une valeur positive lorsque le jeu de données d'entraînement n'implémente pas `__len__` (par exemple, un jeu de données en streaming), car le nombre total d'étapes ne peut alors pas être déduit et est nécessaire pour limiter la boucle d'entraînement et configurer le planificateur de taux d'apprentissage.

**Taux d'apprentissage et planificateur :**

learning_rate (`float`, *facultatif*, valeur par défaut : 5e-5) : Le taux d'apprentissage initial de l'optimiseur. Il s'agit généralement du taux d'apprentissage maximal lors de l'utilisation d'un planificateur avec une phase de montée en charge (warmup).

lr_scheduler_type (`str` ou [SchedulerType](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.SchedulerType), *facultatif*, par défaut `"linear"`) : Le type de planificateur de taux d'apprentissage à utiliser. Consultez [SchedulerType](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.SchedulerType) pour toutes les valeurs possibles. Choix courants : - "linear" = [get_linear_schedule_with_warmup()](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) - "cosine" = [get_cosine_schedule_with_warmup()](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.get_cosine_schedule_with_warmup) - "constant" =  [get_constant_schedule()](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.get_constant_schedule) - "constant_with_warmup" = [get_constant_schedule_with_warmup()](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.get_constant_schedule_with_warmup)

lr_scheduler_kwargs (`dict` ou `str`, *facultatif*, valeur par défaut `None`) : Les arguments supplémentaires pour le lr_scheduler. Consultez la documentation de chaque scheduler pour les valeurs possibles.

warmup_steps (`int` ou `float`, *facultatif*, valeur par défaut 0) : Nombre d'étapes pour un réchauffement linéaire de 0 à `learning_rate`. Le réchauffement aide à stabiliser l'entraînement lors de la phase initiale. Peut être : - Un entier : nombre exact d'étapes de réchauffement - Un float dans l'intervalle [0, 1) : interprété comme le ratio des étapes d'entraînement totales

**Optimiseur :**

optim (`str` ou `training_args.OptimizerNames`, *facultatif*, par défaut `"adamw_torch"` (pour torch>=2.8 `"adamw_torch_fused"`)) : L'optimiseur à utiliser. Options courantes : - `"adamw_torch"` : AdamW de PyTorch (défaut recommandé) - `"adamw_torch_fused"` : noyau AdamW fusionné - `"adamw_hf"` : implémentation AdamW de HuggingFace - `"sgd"` : descente de gradient stochastique avec élan - `"adafactor"` : optimiseur économe en mémoire pour les grands modèles - `"adamw_8bit"` : AdamW 8 bits (nécessite bitsandbytes) Voir `OptimizerNames` pour la liste complète.

optim_args (`str`, *facultatif*) : Arguments facultatifs fournis aux optimiseurs tels que AnyPrecisionAdamW, AdEMAMix et GaLore.

weight_decay (`float`, *facultatif*, valeur par défaut 0) : Coefficient de décroissance du poids appliqué par l'optimiseur (et non par la fonction de perte). Ajoute une régularisation L2 pour prévenir le surapprentissage en pénalisant les poids élevés. Exclu automatiquement des paramètres de biais et de LayerNorm. Valeurs typiques : 0,01 (standard), 0,1 (régularisation plus forte), 0,0 (aucune régularisation).

adam_beta1 (`float`, *facultatif*, valeur par défaut 0.9) : Taux de décroissance exponentielle pour les estimations du premier moment (momentum) dans les optimiseurs basés sur Adam. Contrôle la quantité d'historique des gradients à conserver.

adam_beta2 (`float`, *facultatif*, valeur par défaut 0.999) : Taux de décroissance exponentielle pour les estimations du second moment (variance) dans les optimiseurs basés sur Adam. Contrôle le réglage adaptatif du taux d'apprentissage.

adam_epsilon (`float`, *facultatif*, valeur par défaut 1e-8) : Valeur d'épsilon pour la stabilité numérique dans les optimiseurs basés sur Adam. Empêche la division par zéro au dénominateur de la règle de mise à jour.

optim_target_modules (`Union[str, list[str]]`, *facultatif*) : Les modules cibles à optimiser, c'est-à-dire les noms de modules que vous souhaitez entraîner. Utilisé actuellement pour l'[algorithme GaLore](https://huggingface.co/papers/2403.03507) et l'[algorithme APOLLO](https://huggingface.co/papers/2412.05270). Consultez [l'implémentation de GaLore](https://github.com/jiaweizzhao/GaLore) et [l'implémentation d'APOLLO](https://github.com/zhuhanqing/APOLLO) pour plus de détails. Vous devez vous assurer de passer un optimiseur GaLore ou APOLLO valide, par exemple l'un des suivants : "apollo_adamw", "galore_adamw", "galore_adamw_8bit", "galore_adafactor", et de vous assurer que les modules cibles sont uniquement des modules `nn.Linear`.

**Régularisation et stabilité de l'entraînement :**

gradient_accumulation_steps (`int`, *facultatif*, valeur par défaut : 1) : Nombre d'étapes de mise à jour pour accumuler les gradients avant d'effectuer un passage arrière/mise à jour. Permet de simuler des tailles de lot plus importantes sans mémoire supplémentaire. Taille de lot effective = `per_device_train_batch_size × num_devices × gradient_accumulation_steps`. > [!TIP] > Lors de l'utilisation de l'accumulation de gradients, une « étape » correspond à une étape avec un passage arrière. Par conséquent, la journalisation, l'évaluation et l'enregistrement se produiront toutes les `gradient_accumulation_steps × xxx_step` exemples d'entraînement.

average_tokens_across_devices (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non faire la moyenne des jetons entre les appareils. Si activé, utilise all_reduce pour synchroniser num_tokens_in_batch afin de calculer précisément la perte. Référence : https://github.com/huggingface/transformers/issues/34242

max_grad_norm (`float`, *facultatif*, valeur par défaut 1.0) : Norme maximale du gradient pour le clipping des gradients. Appliquée après la rétropropagation, avant l'étape de l'optimiseur. Empêche l'explosion des gradients en les réduisant lorsque leur norme globale dépasse ce seuil. Définir à 0 pour désactiver le clipping. Valeurs typiques : 1.0 (standard), 0.5 (plus conservateur), 5.0 (moins agressif).

label_smoothing_factor (`float`, *facultatif*, valeur par défaut 0.0) : Facteur de lissage des étiquettes pour éviter l'excès de confiance. Remplace les cibles dures 0/1 par des cibles douces : 0 devient `ε/num_labels` et 1 devient `1 - ε + ε/num_labels`, où ε = `label_smoothing_factor`. Une valeur nulle signifie qu'aucun lissage n'est appliqué. Plage typique : de 0.0 à 0.1.

**Entraînement en précision mixte :**

bf16 (`bool`, *facultatif*, valeur par défaut `False`) : Active l'entraînement en précision mixte bfloat16 (BF16). Généralement préféré à FP16 en raison d'une meilleure stabilité numérique et de l'absence de mise à l'échelle de la perte requise.

fp16 (`bool`, *facultatif*, valeur par défaut `False`) : Active l'entraînement en précision mixte float16 (FP16). Pensez à utiliser BF16 à la place si votre matériel le prend en charge.

bf16_full_eval (`bool`, *facultatif*, valeur par défaut `False`) : Utiliser la pleine précision BF16 pour l'évaluation (et non seulement la précision mixte). Plus rapide et économe en mémoire, mais peut affecter légèrement les valeurs des métriques. S'applique uniquement pendant l'évaluation.

fp16_full_eval (`bool`, *facultatif*, valeur par défaut `False`) : Utiliser la pleine précision FP16 pour l'évaluation (et non seulement la précision mixte). Plus rapide et économe en mémoire, mais peut affecter légèrement les valeurs des métriques. S'applique uniquement pendant l'évaluation.

tf32 (`bool`, *facultatif*) : Active le mode TensorFloat-32 (TF32) sur les GPU Ampere et plus récents. TF32 utilise une précision de 19 bits pour les multiplications de matrices (contre 23 bits pour FP32), offrant jusqu'à 8 fois plus de rapidité avec une perte de précision négligeable. La valeur par défaut dépend de la version de PyTorch. Voir [la documentation TF32](https://huggingface.co/docs/transformers/perf_train_gpu_one#tf32).

**Activation Checkpointing :**

activation_checkpointing (`bool`, *facultatif*, valeur par défaut `False`) : Active le checkpointing des activations pour échanger de la puissance de calcul contre de la mémoire. Réduit l'utilisation de la mémoire en effaçant les activations pendant le passage avant et en les recalculant pendant le passage arrière. Permet d'entraîner des modèles plus grands ou des tailles de lot plus élevées, au prix d'un entraînement environ 20 % plus lent.

activation_checkpointing_kwargs (`dict`, *facultatif*, valeur par défaut `None`) : Arguments nominaux transmis à `activation_checkpointing_enable()`. `every_n_layers` effectue le checkpointing uniquement de toutes les n-ièmes couches décodeur au lieu de toutes ; `1` correspond au comportement habituel tout-ou-rien, et des valeurs plus élevées restituent une partie de la mémoire au détriment de la vitesse. `offload` conserve les activations sauvegardées en mémoire hôte épinglée, ce qui libère `layers x sequence x hidden` octets de mémoire sur l'appareil et ralentit l'étape. Toute autre clé est transmise à `torch.utils.checkpoint.checkpoint`.

gradient_checkpointing (`bool`, *facultatif*) : Alias obsolète de `activation_checkpointing`, sera supprimé dans la v6.

gradient_checkpointing_kwargs (`dict`, *facultatif*) : alias obsolète de `activation_checkpointing_kwargs`, sera supprimé dans la v6.

**Compilation :**

torch_compile (`bool`, *facultatif*, valeur par défaut `False`) : Compile le modèle à l'aide de `torch.compile()` de PyTorch 2.0 pour un entraînement plus rapide. Peut offrir une accélération de 20 à 50 % sans aucune modification du code. Utilise les paramètres de compilation par défaut, sauf si `torch_compile_backend` ou `torch_compile_mode` sont spécifiés.

torch_compile_backend (`str`, *facultatif*) : Backend pour `torch.compile()`. S'il est défini, active automatiquement `torch_compile`. Les options incluent `"inductor"` (par défaut), `"aot_eager"`, `"cudagraphs"`. Les backends varient selon la version de PyTorch - consultez la documentation de PyTorch pour les options disponibles.

torch_compile_mode (`str`, *facultatif*) : Mode de compilation pour `torch.compile()`. S'il est défini, active automatiquement `torch_compile`. Options : `"default"`, `"reduce-overhead"` (minimiser la surcharge Python), `"max-autotune"` (optimisation agressive, temps de compilation plus long).

**Noyaux :**

use_liger_kernel (`bool`, *facultatif*, valeur par défaut `False`) : Active les optimisations [Liger Kernel](https://github.com/linkedin/Liger-Kernel). Augmente le débit multi-GPU d'environ 20 % et réduit l'utilisation de la mémoire d'environ 60 %. Compatible avec Flash Attention, FSDP et DeepSpeed. Prend actuellement en charge les modèles Llama, Mistral, Mixtral et Gemma.

liger_kernel_config (`Optional[dict]`, *facultatif*) : Configuration pour Liger Kernel. Transmise en tant que kwargs à `_apply_liger_kernel_to_instance()`. Les options incluent généralement : `"rope"`, `"swiglu"`, `"cross_entropy"`, `"fused_linear_cross_entropy"`, `"rms_norm"`. Si `None`, la configuration par défaut est utilisée.

**Optimisations supplémentaires :**

use_cache (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut activer le cache pour le modèle. Pour l'entraînement, cela n'est généralement pas nécessaire, à l'exception de certaines méthodes PEFT qui utilisent `past_key_values`.

neftune_noise_alpha (`Optional[float]`) : Si la valeur n'est pas `None`, les embeddings de bruit NEFTune seront activés. Cela peut améliorer considérablement les performances du modèle lors de l'ajustement fin sur des instructions. Consultez le [paper original](https://huggingface.co/papers/2310.05914) et le [code original](https://github.com/neelsjain/NEFTune). Prend en charge les `PreTrainedModel` de transformers ainsi que les `PeftModel` de peft. Le paper original utilisait des valeurs comprises dans l'intervalle [5.0, 15.0].

torch_empty_cache_steps (`int`, *facultatif*) : Nombre d'étapes à attendre avant d'appeler `torch.<device>.empty_cache()`. Si cette valeur n'est pas définie ou est définie sur None, le cache ne sera pas vidé. Cela peut aider à éviter les erreurs de mémoire insuffisante CUDA en réduisant l'utilisation maximale de la VRAM, au prix d'une [performance environ 10 % plus lente](https://github.com/huggingface/transformers/issues/31372).

auto_find_batch_size (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut déterminer automatiquement une taille de lot d'entraînement qui tient en mémoire, par décroissance exponentielle, afin d'éviter les erreurs CUDA Out-of-Memory. La taille de lot d'évaluation n'est pas ajustée.

**Journalisation et suivi de l'entraînement :**

logging_strategy (`str` ou [IntervalStrategy](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.IntervalStrategy), *facultatif*, par défaut `"steps"`) : La stratégie de journalisation à adopter pendant l'entraînement. Les valeurs possibles sont : - `"no"` : Aucune journalisation n'est effectuée pendant l'entraînement. - `"epoch"` : La journalisation est effectuée à la fin de chaque époque. - `"steps"` : La journalisation est effectuée toutes les `logging_steps`.

logging_steps (`int` ou `float`, *facultatif*, valeur par défaut : 500) : Nombre d'étapes de mise à jour entre deux journaux si `logging_strategy="steps"`. Doit être un entier ou un nombre flottant dans l'intervalle `[0,1)`. S'il est inférieur à 1, il sera interprété comme le ratio des étapes d'entraînement totales.

logging_first_step (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut journaliser la première `global_step` ou non.

log_on_each_node (`bool`, *facultatif*, valeur par défaut `True`) : Dans l'entraînement distribué multi-nœuds, indique s'il faut journaliser en utilisant `log_level` une fois par nœud, ou uniquement sur le nœud principal.

logging_nan_inf_filter (`bool`, *facultatif*, valeur par défaut `True`) : Exclure les pertes NaN et Inf lors de la journalisation. Si `True`, remplace les pertes d'entraînement NaN/Inf par la moyenne des pertes valides récentes et exclut les lots NaN/Inf (par exemple, les lots sans jetons d'étiquette) de la perte d'évaluation. N'affecte pas le calcul des gradients, uniquement la journalisation.

include_num_input_tokens_seen (`Optional[Union[str, bool]]`, *facultatif*, valeur par défaut "no") : Indique s'il faut suivre le nombre de jetons d'entrée vus. Doit être l'une des valeurs ["all", "non_padding", "no"] ou une valeur booléenne qui correspond à "all" ou "no". Peut être plus lent en formation distribuée, car des opérations de collecte doivent être appelées.

**Journalisation :**

log_level (`str`, *facultatif*, valeur par défaut `passive`) : Niveau de journalisation pour le processus principal. Options : `"debug"`, `"info"`, `"warning"`, `"error"`, `"critical"` ou `"passive"` (ne modifie pas le niveau de journalisation actuel de Transformers, qui est `"warning"` par défaut)

log_level_replica (`str`, *facultatif*, valeur par défaut `"warning"`) : Niveau de journalisation pour les processus répliques dans l'entraînement distribué. Les options sont les mêmes que pour `log_level`.

disable_tqdm (`bool`, *facultatif*) : Désactive les barres de progression tqdm. La valeur par défaut est `True` si `log_level` est warning ou inférieur, `False` sinon.

**Intégration du suivi des expériences :**

report_to (`str` ou `list[str]`, *facultatif*, valeur par défaut `"none"`) : La liste des intégrations vers lesquelles signaler les résultats et les journaux. Les plateformes prises en charge sont `"azure_ml"`, `"clearml"`, `"codecarbon"`, `"comet_ml"`, `"dagshub"`, `"dvclive"`, `"flyte"`, `"mlflow"`, `"swanlab"`, `"tensorboard"`, `"trackio"` et `"wandb"`. Utilisez `"all"` pour signaler à toutes les intégrations installées, `"none"` pour aucune intégration.

run_name (`str`, *facultatif*) : Un descripteur pour l'exécution. Utilisé généralement pour la journalisation [trackio](https://github.com/gradio-app/trackio), [wandb](https://www.wandb.com/), [mlflow](https://www.mlflow.org/), [comet](https://www.comet.com/site) et [swanlab](https://swanlab.cn).

project (`str`, *facultatif*, valeur par défaut `"huggingface"`) : Le nom du projet à utiliser pour la journalisation. Actuellement, utilisé uniquement par Trackio.

trackio_space_id (`str` ou `None`, *facultatif*, valeur par défaut `None`) : L'identifiant de l'Espace Hugging Face à utiliser pour la journalisation Trackio en direct avec un Espace basé sur Gradio. Doit être un nom d'Espace complet comme `'username/reponame'` ou `'orgname/reponame'`, ou simplement `'reponame'` (l'Espace est créé dans l'espace de noms de l'utilisateur actuellement connecté). Si `None`, les métriques sont journalisées uniquement dans un répertoire **local** (aucun Espace sur le Hub). Cet Espace Gradio a un accès **lecture et écriture** au **Bucket** Trackio, ce qui est souhaitable lorsque l'entraînement est **en cours**—par exemple lors de la **reprise** d'une exécution partielle ou de l'**agrégation des journaux** provenant de plusieurs machines. L'Espace sera **public** sauf si vous définissez `hub_private_repo=True` ou si le paramètre par défaut de votre organisation est de créer des Espaces privés.

trackio_bucket_id (`str` ou `None`, *facultatif*, valeur par défaut `None`) : identifiant facultatif du Bucket Hugging Face pour Trackio. S'il n'est pas défini, Trackio en dérive un. Utilisé conjointement avec un Space Gradio (`trackio_space_id`) et lors du déploiement d'un Space statique (`trackio_static_space_id` n'est pas `False`).

trackio_static_space_id (`str`, `False` ou `None`, *facultatif*, par défaut `None`) : L'identifiant de l'Espace Hugging Face à utiliser pour l'Espace statique créé après la fin de l'entraînement. Doit être un nom complet d'Espace comme `'username/reponame'` ou `'orgname/reponame'`, ou simplement `'reponame'` (l'Espace est créé dans l'espace de noms de l'utilisateur actuellement connecté). Si False, aucun Espace statique ne sera créé. Si None, et que le modèle est poussé sur le Hub, un Espace statique sera créé avec un nom par défaut et ce lien sera ajouté depuis la carte du modèle. L'Espace sera public, sauf si vous définissez `hub_private_repo=True` ou si le paramètre par défaut de votre organisation est de créer des Espaces privés.

**Évaluation :**

eval_strategy (`str` ou [IntervalStrategy](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.IntervalStrategy), *facultatif*, par défaut `"no"`) : Moment où effectuer l'évaluation. Options : - `"no"` : Aucune évaluation pendant l'entraînement - `"steps"` : Évaluer toutes les `eval_steps` - `"epoch"` : Évaluer à la fin de chaque époque

eval_steps (`int` ou `float`, *facultatif*) : Nombre d'étapes de mise à jour entre deux évaluations si `eval_strategy="steps"`. Par défaut, prend la même valeur que `logging_steps` si non défini. Doit être un entier ou un nombre flottant dans l'intervalle `[0,1)`. S'il est inférieur à 1, il sera interprété comme un ratio des étapes d'entraînement totales.

eval_delay (`float`, *facultatif*) : Nombre d'époques ou d'étapes à attendre avant que la première évaluation puisse être effectuée, en fonction de eval_strategy.

per_device_eval_batch_size (`int`, *facultatif*, valeur par défaut : 8) : La taille du lot par cœur d'accélérateur/CPU pour l'évaluation.

prediction_loss_only (`bool`, *facultatif*, valeur par défaut `False`) : Lors de l'évaluation et de la génération de prédictions, ne renvoie que la perte.

eval_on_start (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut effectuer une étape d'évaluation (vérification de cohérence) avant l'entraînement afin de s'assurer que les étapes de validation fonctionnent correctement.

eval_do_concat_batches (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut concaténer récursivement les entrées, pertes, étiquettes et prédictions entre les lots. Si `False`, ils sont stockés sous forme de listes, chaque lot étant conservé séparément.

eval_use_gather_object (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut effectuer une collecte récursive des objets dans une liste/tuple/dictionnaire imbriqué d'objets à partir de tous les appareils. Cette option ne doit être activée que si les utilisateurs ne renvoient pas uniquement des tenseurs, et PyTorch la décourage activement. Elle est utile lorsque la structure des étiquettes est non standard, comme dans les tâches de vision par ordinateur.

eval_accumulation_steps (`int`, *facultatif*) : Nombre d'étapes de prédiction pour lesquelles accumuler les tenseurs de sortie avant de transférer les résultats vers le CPU. Si cette valeur n'est pas définie, l'ensemble des prédictions est accumulé sur l'accélérateur de l'appareil avant d'être transféré vers le CPU (plus rapide, mais nécessite plus de mémoire).

**Calcul des métriques :**

include_for_metrics (`list[str]`, *facultatif*, valeur par défaut `[]`) : Inclut des données supplémentaires dans la fonction `compute_metrics` si nécessaire pour le calcul des métriques. Options possibles à ajouter à la liste `include_for_metrics` : - `"inputs"` : Données d'entrée transmées au modèle, destinées au calcul de métriques dépendant des entrées. - `"loss"` : Valeurs de perte calculées lors de l'évaluation, destinées au calcul de métriques dépendant de la perte.

batch_eval_metrics (`bool`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, l'évaluation appellera compute_metrics à la fin de chaque lot pour accumuler des statistiques, plutôt que de stocker tous les logits d'évaluation en mémoire. Lorsqu'il est défini sur `True`, vous devez transmettre une fonction compute_metrics qui accepte un argument booléen `compute_result` ; lorsqu'elle reçoit `True`, elle déclenche le calcul des statistiques globales finales à partir des statistiques de niveau lot que vous avez accumulées sur l'ensemble d'évaluation.

**Point de contrôle et sauvegarde :**

save_only_model (`bool`, *facultatif*, valeur par défaut `False`) : Enregistre uniquement les poids du modèle, sans l'état de l'optimiseur, du planificateur ou du générateur aléatoire. Réduit considérablement la taille du point de contrôle, mais empêche la reprise de l'entraînement depuis ce point de contrôle. À utiliser lorsque vous avez uniquement besoin du modèle entraîné pour l'inférence, et non pour une formation continue. Vous ne pouvez charger le modèle qu'à l'aide de `from_pretrained` avec cette option définie sur `True`.

save_strategy (`str` ou `SaveStrategy`, *facultatif*, par défaut `"steps"`) : La stratégie d'enregistrement des points de contrôle à adopter pendant l'entraînement. Les valeurs possibles sont : - `"no"` : Aucun enregistrement n'est effectué pendant l'entraînement. - `"epoch"` : L'enregistrement est effectué à la fin de chaque époque. - `"steps"` : L'enregistrement est effectué toutes les `save_steps`. - `"best"` : L'enregistrement est effectué chaque fois qu'une nouvelle `best_metric` est atteinte.

save_steps (`int` ou `float`, *facultatif*, valeur par défaut : 500) : Nombre d'étapes de mise à jour entre deux sauvegardes de points de contrôle si `save_strategy="steps"`. Doit être un entier ou un nombre flottant dans l'intervalle `[0,1)`. S'il est inférieur à 1, il sera interprété comme un ratio des étapes d'entraînement totales.

save_on_each_node (`bool`, *facultatif*, valeur par défaut `False`) : Lors d'une formation distribuée multi-nœuds, indique s'il faut enregistrer les modèles et les points de contrôle sur chaque nœud, ou uniquement sur le nœud principal. Cette option ne doit pas être activée si les différents nœuds utilisent le même stockage, car les fichiers seraient enregistrés avec les mêmes noms sur chaque nœud.

save_total_limit (`int`, *facultatif*) : Nombre maximal de points de contrôle à conserver. Supprime les points de contrôle plus anciens dans `output_dir`. Lorsque `load_best_model_at_end=True`, le meilleur point de contrôle est toujours conservé, ainsi que les plus récents. Par exemple, `save_total_limit=5` conserve les 4 plus récents ainsi que le meilleur.

enable_jit_checkpoint (`bool`, *facultatif*, valeur par défaut `False`) : Active le checkpointing Just-In-Time lors du signal SIGTERM pour une terminaison propre sur les charges de travail préemptibles. **Important** : Configurez la période d'arrêt propre de votre orchestrateur pour laisser un temps suffisant. Pour Kubernetes, définissez `terminationGracePeriodSeconds` (la valeur par défaut de 30 s est généralement insuffisante). Pour Slurm, utilisez `--signal=TERM@<seconds>`. La période de grâce requise doit être supérieure ou égale à la durée de la plus longue itération + le temps de sauvegarde du checkpoint.

**Intégration avec Hugging Face Hub :**

push_to_hub (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non pousser le modèle sur le Hub à chaque fois que le modèle est enregistré. Si cette option est activée, `output_dir` devient un répertoire git synchronisé avec le dépôt (déterminé par `hub_model_id`) et le contenu est poussé à chaque fois qu'un enregistrement est déclenché (selon votre `save_strategy`). L'appel de [save_model()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.save_model) déclenchera également un push.

hub_token (`str`, *facultatif*) : Jeton à utiliser pour pousser le modèle sur le Hub. Par défaut, le jeton du dossier de cache obtenu avec `hf auth login` est utilisé.

hub_private_repo (`bool`, *facultatif*) : Indique si le dépôt doit être privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le paramètre par défaut de l'organisation est « privé ». Cette valeur est ignorée si le dépôt existe déjà. En cas d'envoi de rapports vers Trackio avec le déploiement sur Hugging Face Spaces activé, la même logique détermine si le Space est privé.

hub_model_id (`str`, *facultatif*) : Le nom du dépôt à garder synchronisé avec le *output_dir* local. Il peut s'agir d'un simple identifiant de modèle, auquel cas le modèle sera poussé dans votre espace de noms. Sinon, il doit s'agir du nom complet du dépôt, par exemple `"user_name/model"`, ce qui vous permet de pousser vers une organisation dont vous êtes membre avec `"organization_name/model"`. La valeur par défaut est `user_name/output_dir_name`, *output_dir_name* étant le nom de `output_dir`.

hub_strategy (`str` ou `HubStrategy`, *facultatif*, par défaut `"every_save"`) : Définit ce qui doit être poussé vers le Hub et quand. Options : - `"end"` : Pousse uniquement à la fin de l'entraînement - `"every_save"` : Pousse à chaque sauvegarde (asynchrone pour ne pas bloquer l'entraînement) - `"checkpoint"` : Comme `"every_save"`, mais pousse également le dernier point de contrôle dans le sous-dossier `"last-checkpoint"` pour faciliter la reprise - `"all_checkpoints"` : Pousse tous les points de contrôle à mesure qu'ils apparaissent

hub_always_push (`bool`, *facultatif*, valeur par défaut `False`) : Sauf si cette valeur est `True`, le `Trainer` ignore l'envoi d'un point de contrôle si l'envoi précédent n'est pas terminé.

hub_revision (`str`, *facultatif*) : La révision à utiliser lors de la publication sur le Hub. Peut être un nom de branche, un tag ou un hash de commit.

**Suivi optimal des modèles :**

load_best_model_at_end (`bool`, *facultatif*, valeur par défaut `False`) : Charge le meilleur point de contrôle à la fin de l'entraînement. Nécessite que `eval_strategy` soit défini. Lorsqu'il est activé, le meilleur point de contrôle est toujours enregistré (voir `save_total_limit`).  Si `True`, `save_strategy` doit correspondre à `eval_strategy` (sauf si `save_strategy` est `"best"`), et si `"steps"` est utilisé, `save_steps` doit être un multiple de `eval_steps`.

metric_for_best_model (`str`, *facultatif*) : Métrique à utiliser pour comparer les modèles lorsque `load_best_model_at_end=True`. Doit être un nom de métrique renvoyé par l'évaluation, avec ou sans le préfixe `"eval_"`. La valeur par défaut est `"loss"`. Si vous définissez ce paramètre, `greater_is_better` aura par défaut la valeur `True`, sauf si le nom se termine par `"loss"`. Exemples : `"accuracy"`, `"f1"`, `"eval_bleu"`.

greater_is_better (`bool`, *facultatif*) : Indique si des valeurs de métrique plus élevées sont préférables. La valeur par défaut est basée sur `metric_for_best_model` : `True` si le nom de la métrique ne se termine pas par `"loss"`, `False` sinon.

**Reprise de l'entraînement :**

ignore_data_skip (`bool`, *facultatif*, valeur par défaut `False`) : lors de la reprise de l'entraînement, ignore l'avance rapide dans le jeu de données pour atteindre l'état précédent. Si `True`, l'entraînement démarre depuis le début du jeu de données (reprise plus rapide, mais les résultats ne correspondront pas à l'entraînement interrompu). Si `False`, les données déjà vues sont ignorées (reprise plus lente, mais poursuite exacte).

restore_callback_states_from_checkpoint (`bool`, *facultatif*, valeur par défaut `False`) : Restaure les états des callbacks depuis le point de contrôle lors de la reprise. Si `True`, les callbacks passés au Trainer seront remplacés s'ils existent dans le point de contrôle.

**Reproductibilité :**

full_determinism (`bool`, *facultatif*, valeur par défaut `False`) : Si `True`, [enable_full_determinism()](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.enable_full_determinism) est appelé à la place de [set_seed()](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.set_seed) pour garantir des résultats reproductibles lors de l'entraînement distribué. Important : cela aura un impact négatif sur les performances, il ne faut donc l'utiliser que pour le débogage.

seed (`int`, *facultatif*, valeur par défaut 42) : Graine aléatoire qui sera définie au début de l'entraînement. Pour garantir la reproductibilité entre les exécutions, utilisez la fonction `~Trainer.model_init` pour instancier le modèle s'il possède des paramètres initialisés aléatoirement.

data_seed (`int`, *facultatif*) : Graine aléatoire à utiliser avec les échantillonneurs de données. Si elle n'est pas définie, les générateurs aléatoires pour l'échantillonnage de données utiliseront la même graine que `seed`. Cela permet de garantir la reproductibilité de l'échantillonnage des données, indépendamment de la graine du modèle.

**Configuration matérielle :**

use_cpu (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser le cpu. Si la valeur est False, le dispositif/le backend torch disponible sera utilisé.

**Configuration d'Accelerate :**

accelerator_config (`str`, `dict` ou `AcceleratorConfig`, *facultatif*) : Configuration de l'intégration interne Accelerate. Peut être : - Chemin vers un fichier de configuration JSON : `"accelerator_config.json"` - Dictionnaire contenant les options de configuration - Instance de `AcceleratorConfig` Options principales : - `split_batches` (`bool`, valeur par défaut `False`) : Indique s'il faut diviser les lots entre les appareils. Si `True`, la taille réelle du lot est identique sur tous les appareils (la taille totale doit être divisible par num_processes). Si `False`, chaque appareil reçoit la taille de lot spécifiée. - `dispatch_batches` (`bool`) : Si `True`, seul le processus principal itère sur le dataloader et distribue les lots aux appareils. La valeur par défaut est `True` pour `IterableDataset`, et `False` dans le cas contraire. - `even_batches` (`bool`, valeur par défaut `True`) : Duplique les échantillons depuis le début du jeu de données pour garantir que tous les workers reçoivent des lots de taille égale. - `use_seedable_sampler` (`bool`, valeur par défaut `True`) : Utilise un échantillonneur aléatoire entièrement initialisable par graine pour assurer la reproductibilité. - `use_configured_state` (`bool`, valeur par défaut `False`) : Utilise un `AcceleratorState`/`PartialState` préinitialisé au lieu d'en créer un nouveau. Peut causer des problèmes lors de l'ajustement des hyperparamètres.

parallelism_config (`ParallelismConfig`, *facultatif*) : Configuration du parallélisme pour l'exécution d'entraînement. Nécessite Accelerate `1.10.1`

**Chargeur de données :**

dataloader_drop_last (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut supprimer le dernier lot incomplet (si la longueur du jeu de données n'est pas divisible par la taille du lot) ou non.

dataloader_num_workers (`int`, *facultatif*, valeur par défaut 0) : Nombre de sous-processus à utiliser pour le chargement des données (PyTorch uniquement). 0 signifie que les données seront chargées dans le processus principal.

dataloader_pin_memory (`bool`, *facultatif*, par défaut `True`) : Indique si vous souhaitez épingler la mémoire dans les chargeurs de données ou non. La valeur par défaut est `True`.

dataloader_persistent_workers (`bool`, *facultatif*, valeur par défaut `False`) : Si True, le chargeur de données ne mettra pas fin aux processus de travail après qu'un jeu de données a été consommé une fois. Cela permet de maintenir les instances de Dataset des travailleurs en vie. Cela peut potentiellement accélérer l'entraînement, mais augmentera l'utilisation de la RAM. La valeur par défaut sera `False`.

dataloader_prefetch_factor (`int`, *facultatif*) : Nombre de lots chargés à l'avance par chaque travailleur. 2 signifie qu'il y aura au total 2 * num_workers lots préchargés sur l'ensemble des travailleurs.

dataloader_multiprocessing_context (`str`, *facultatif*) : Méthode de démarrage du multiprocessing à utiliser pour les workers de chargement de données (`"fork"`, `"spawn"` ou `"forkserver"`). Par défaut, la méthode de démarrage par défaut de PyTorch est utilisée, sauf sur MPS avec `dataloader_num_workers > 1`, où la valeur par défaut est `"fork"`. Utilisez `"spawn"` lors du streaming depuis des sources dont les objets ne sont pas sûrs pour le fork (par ex. HDFS via `pyarrow`). Sous `"spawn"`, tout code personnalisé de `collate_fn` ou de jeu de données doit être importable au niveau du module (pas de lambdas/closures).

dataloader_in_order (`bool`, *facultatif*, valeur par défaut `True`) : Si `True`, le chargeur de données fournit les lots dans l'ordre de dispatch des workers. Définissez `False` pour fournir les lots dès qu'ils sont prêts, ce qui peut réduire la latence de fin pour les charges de travail de streaming `IterableDataset`. Nécessite PyTorch >= 2.6.

remove_unused_columns (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut supprimer automatiquement les colonnes non utilisées par la méthode forward du modèle.

label_names (`list[str]`, *facultatif*) : La liste des clés de votre dictionnaire d'entrées qui correspondent aux étiquettes. Par défaut, elle sera la liste des noms d'arguments acceptés par le modèle contenant le mot « label », sauf si le modèle utilisé est l'un des `XxxForQuestionAnswering`, auquel cas elle inclura également les clés `["start_positions", "end_positions"]`. Vous ne devez spécifier `label_names` que si vous utilisez des noms d'étiquettes personnalisés ou si le `forward` de votre modèle consomme plusieurs tenseurs d'étiquettes (par exemple, pour le QA extractif).

train_sampling_strategy (`str`, *facultatif*, valeur par défaut `"random"`) : Le sampler à utiliser pour le dataloader d'entraînement. Les valeurs possibles sont :  - `"random"` : Utilise `RandomSampler` (par défaut). - `"sequential"` : Utilise `SequentialSampler`. - `"group_by_length"` : Utilise `LengthGroupedSampler` pour regrouper les échantillons de longueurs approximativement identiques (afin de minimiser le padding et d'augmenter l'efficacité). - `"batch_rebalance"` : Utilise `BatchRebalanceSampler` pour équilibrer le coût des jetons de padding entre les appareils et les étapes d'accumulation de gradient au sein de chaque lot effectif, réduisant ainsi le gaspillage de padding et la mémoire de pointe par rapport à `"group_by_length"`. Actuellement, seul l'entraînement parallèle de données est pris en charge (le parallélisme de tenseurs n'est pas encore pris en charge).  Remarque : Lors de l'utilisation d'un `IterableDataset`, cet argument est ignoré.

length_column_name (`str`, *facultatif*, valeur par défaut `"length"`) : Nom de la colonne pour les longueurs précalculées. Si la colonne existe, le regroupement par longueur utilisera ces valeurs plutôt que de les calculer au démarrage de l'entraînement. Ignoré sauf si `train_sampling_strategy` est `"group_by_length"`ou `"batch_rebalance"` et que le jeu de données est une instance de `Dataset`.

**DDP (DistributedDataParallel) :**

ddp_find_unused_parameters (`bool`, *facultatif*) : Lors de l'utilisation de l'entraînement distribué, la valeur du drapeau `find_unused_parameters` passée à `DistributedDataParallel`. La valeur par défaut est `False` si le gradient checkpointing est utilisé, `True` sinon.

ddp_bucket_cap_mb (`int`, *facultatif*) : Lors de l'utilisation de l'entraînement distribué, la valeur du drapeau `bucket_cap_mb` transmis à `DistributedDataParallel`.

ddp_broadcast_buffers (`bool`, *facultatif*) : Lors de l'utilisation de l'entraînement distribué, la valeur du drapeau `broadcast_buffers` transmis à `DistributedDataParallel`. Sera par défaut `False` si le gradient checkpointing est utilisé, `True` sinon.

ddp_static_graph (`bool`, *facultatif*) : Lors de l'utilisation de l'entraînement distribué, la valeur du drapeau `static_graph` passée à `DistributedDataParallel`.

ddp_backend (`str`, *facultatif*) : Le backend à utiliser pour l'entraînement distribué. Doit être l'un des suivants : `"nccl"`, `"mpi"`, `"xccl"`, `"gloo"`, `"hccl"`.

ddp_timeout (`int`, *facultatif*, valeur par défaut 1800) : Le délai d'attente pour les appels à `torch.distributed.init_process_group`, utilisé pour éviter les dépassements de délai des sockets GPU lors de l'exécution d'opérations lentes dans des environnements distribués. Veuillez consulter la [documentation PyTorch](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) pour plus d'informations.

**FSDP (Fully Sharded Data Parallel) :**

fsdp (`bool`, *facultatif*, valeur par défaut `None`) : Active PyTorch Fully Sharded Data Parallel (FSDP) pour l'entraînement distribué. Passez `True` pour activer FSDP.

fsdp_config (`str` ou `dict`, *facultatif*) : Paramètres de configuration pour lorsque `fsdp` est activé. Transmettez un chemin vers un fichier de configuration JSON, tel que `fsdp_config.json`, ou un dictionnaire déjà chargé. Clés prises en charge : - version (`int`, *facultatif*, valeur par défaut `2`) : La version de FSDP à utiliser (`2` pour FSDP2, `1` pour le FSDP1 legacy). - reshard_after_forward (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ré-fragmenter les paramètres après le passage avant. Définissez sur `False` pour conserver les paramètres regroupés entre les passages avant et arrière, ce qui évite le re-all-gather et utilise une mémoire de pointe plus élevée. - cpu_offload (`bool`, *facultatif*, valeur par défaut `False`) : Décharge les paramètres et les gradients sur le CPU lorsqu'ils ne sont pas utilisés afin d'économiser la mémoire GPU. - activation_checkpointing (`bool`, *facultatif*, valeur par défaut `False`) : Définissez sur `True` pour réduire la mémoire en recalculant les activations lors du passage arrière. Lors de l'utilisation de FSDP, préférez cette option à l'argument d'entraînement `activation_checkpointing`, qui introduit un all-gather redondant lors du passage arrière. - cpu_ram_efficient_loading (`bool`, *facultatif*, valeur par défaut `False`) : Définissez sur `True` pour charger le point de contrôle pré-entraîné uniquement sur le premier processus. Les autres processus démarrent avec des poids vides et reçoivent les poids par diffusion. - state_dict_type (`str`, *facultatif*, valeur par défaut `"FULL_STATE_DICT"`) : Format du point de contrôle : `"FULL_STATE_DICT"` (fichier unique compatible HF) ou `"SHARDED_STATE_DICT"` (un fichier par rang, plus rapide pour les grands modèles). - auto_wrap_policy (`str`, *facultatif*, valeur par défaut `"TRANSFORMER_BASED_WRAP"`) : Politique d'auto-wrap à utiliser. Choisissez `"TRANSFORMER_BASED_WRAP"`, `"SIZE_BASED_WRAP"` ou `"NO_WRAP"`. - transformer_layer_cls_to_wrap (`list[str]`, *facultatif*) : Noms des classes de couches Transformer (sensibles à la casse) à envelopper, par exemple `LlamaDecoderLayer`. Généralement inutile : la politique d'enveloppement retombe sur `_no_split_modules` du modèle, qui couvre la plupart des modèles transformers. - min_num_params (`int`, *facultatif*, valeur par défaut `0`) : Nombre minimal de paramètres par module pour l'auto-wrapping basé sur la taille (utilisé avec `auto_wrap_policy="SIZE_BASED_WRAP"`). - xla (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser l'entraînement PyTorch/XLA Fully Sharded Data Parallel. Expérimental. - xla_fsdp_settings (`dict`, *facultatif*) : Dictionnaire des paramètres d'enveloppement XLA FSDP. Pour la liste complète des options, consultez la [source XLA FSDP](https://github.com/pytorch/xla/blob/master/torch_xla/distributed/fsdp/xla_fully_sharded_data_parallel.py). - xla_fsdp_grad_ckpt (`bool`, *facultatif*, valeur par défaut `False`) : Définissez sur `True` pour utiliser le gradient checkpointing sur chaque couche enveloppée XLA FSDP imbriquée. Nécessite `xla=True` et une politique d'auto-wrapping (`min_num_params` ou `transformer_layer_cls_to_wrap`).

**DeepSpeed :**

deepspeed (`str` ou `dict`, *facultatif*) : Active l'intégration [DeepSpeed](https://github.com/deepspeedai/DeepSpeed). La valeur est soit : - Le chemin vers le fichier de configuration JSON de DeepSpeed : `"ds_config.json"` - La configuration chargée sous forme de dictionnaire > [!TIP] > Si vous utilisez l'initialisation ZeRO, instanciez votre modèle *après* l'initialisation de `TrainingArguments`, sinon ZeRO ne sera pas appliqué.

**Débogage et profilage (expérimental) :**

debug (`str` ou liste de `DebugOption`, *facultatif*, valeur par défaut `""`) : Active une ou plusieurs fonctionnalités de débogage. Il s'agit d'une fonctionnalité expérimentale. Les options possibles sont : - "underflow_overflow" : détecte les dépassements (overflow) dans les entrées/sorties du modèle et signale les derniers frames ayant conduit à l'événement - "tpu_metrics_debug" : affiche les métriques de débogage sur TPU

skip_memory_metrics (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ignorer l'ajout des rapports du profil mémoire aux métriques. Cette opération est ignorée par défaut, car elle ralentit la vitesse d'entraînement et d'évaluation.

**Options de script externe (non utilisées par Trainer) :**

do_train (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lancer l'entraînement ou non. Cet argument n'est pas utilisé directement par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.

do_eval (`bool`, *facultatif*) : Indique s'il faut ou non effectuer une évaluation sur le jeu de validation. Sera défini sur `True` si `eval_strategy` est différent de `"no"`. Cet argument n'est pas utilisé directement par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.

do_predict (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut exécuter les prédictions sur le jeu de test ou non. Cet argument n'est pas utilisé directement par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.

resume_from_checkpoint (`str`, *facultatif*) : Le chemin vers un dossier contenant un point de contrôle valide pour votre modèle. Cet argument n'est pas utilisé directement par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.

Classe de configuration permettant de contrôler tous les aspects de l'entraînement du modèle avec le Trainer. TrainingArguments centralise tous les hyperparamètres, les réglages d'optimisation, les préférences de journalisation et les choix d'infrastructure nécessaires à l'entraînement.

[HfArgumentParser](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.HfArgumentParser) peut convertir 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.

#### get_process_log_level[[transformers.TrainingArguments.get_process_log_level]]

```python
get_process_log_level()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2065)

Retourne le niveau de journalisation à utiliser selon que ce processus est le processus principal du nœud 0, le processus principal d'un nœud non nul ou un processus non principal.

Pour le processus principal, le niveau de journalisation est par défaut celui défini (`logging.WARNING` si vous n'avez rien fait), sauf s'il est remplacé par l'argument `log_level`.

Pour les processus répliques, le niveau de journalisation est par défaut `logging.WARNING`, sauf s'il est remplacé par l'argument `log_level_replica`.

Le choix entre les paramètres du processus principal et du processus réplique est effectué en fonction de la valeur de retour de `should_log`.

#### get_warmup_steps[[transformers.TrainingArguments.get_warmup_steps]]

```python
get_warmup_steps(num_training_steps: int)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2154)

Obtenir le nombre d'étapes utilisées pour un réchauffement linéaire.

#### main_process_first[[transformers.TrainingArguments.main_process_first]]

```python
main_process_first(local = True, desc = 'work')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2103)

**Paramètres :**

local (`bool`, *facultatif*, valeur par défaut `True`) : si `True`, « first » désigne le processus de rang 0 de chaque nœud ; si `False`, « first » désigne le processus de rang 0 du nœud de rang 0. Dans un environnement multi-nœuds avec un système de fichiers partagé, vous voudrez probablement utiliser `local=False` afin que seul le processus principal du premier nœud effectue le traitement. En revanche, si le système de fichiers n'est pas partagé, le processus principal de chaque nœud devra effectuer le traitement, ce qui est le comportement par défaut.

desc (`str`, *facultatif*, valeur par défaut `"work"`) : une description de la tâche à utiliser dans les journaux de débogage

Un gestionnaire de contexte pour l'environnement distribué de torch, permettant d'exécuter une opération sur le processus principal tout en bloquant les répliques, puis de les libérer une fois l'opération terminée.

Un tel usage concerne la fonctionnalité `map` de `datasets`, qui doit être exécutée une seule fois sur le processus principal pour être efficace ; une fois terminée, elle enregistre une version mise en cache des résultats, qui est ensuite chargée automatiquement par les répliques.

#### set_dataloader[[transformers.TrainingArguments.set_dataloader]]

```python
set_dataloader(train_batch_size: int = 8, eval_batch_size: int = 8, drop_last: bool = False, num_workers: int = 0, pin_memory: bool = True, persistent_workers: bool = False, prefetch_factor: int | None = None, multiprocessing_context: str | None = None, in_order: bool = True, auto_find_batch_size: bool = False, ignore_data_skip: bool = False, sampler_seed: int | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2694)

**Paramètres :**

drop_last (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut supprimer le dernier lot incomplet (si la longueur du jeu de données n'est pas divisible par la taille du lot) ou non.

num_workers (`int`, *facultatif*, valeur par défaut 0) : Nombre de sous-processus à utiliser pour le chargement des données (PyTorch uniquement). 0 signifie que les données seront chargées dans le processus principal.

pin_memory (`bool`, *facultatif*, par défaut `True`) : Indique si vous souhaitez épingler la mémoire dans les chargeurs de données ou non. La valeur par défaut est `True`.

persistent_workers (`bool`, *facultatif*, valeur par défaut `False`) : Si True, le chargeur de données ne mettra pas fin aux processus de travail après qu'un jeu de données a été consommé une fois. Cela permet de maintenir les instances de Dataset des travailleurs en vie. Cela peut potentiellement accélérer l'entraînement, mais augmentera l'utilisation de la RAM. La valeur par défaut sera `False`.

prefetch_factor (`int`, *facultatif*) : Nombre de lots chargés à l'avance par chaque travailleur. 2 signifie qu'il y aura au total 2 * num_workers lots préchargés sur l'ensemble des travailleurs.

multiprocessing_context (`str`, *facultatif*) : Méthode de démarrage du multiprocessing à utiliser pour les travailleurs de chargement de données (`"fork"`, `"spawn"` ou `"forkserver"`). Par défaut, la méthode de démarrage par défaut de PyTorch est utilisée. Utilisez `"spawn"` lors du streaming depuis des sources dont les objets ne sont pas sûrs pour le fork (par ex. HDFS via `pyarrow`). Sous `"spawn"`, tout code personnalisé de `collate_fn` ou de jeu de données doit être importable au niveau du module (pas de lambdas/clôtures).

in_order (`bool`, *facultatif*, valeur par défaut `True`) : Si `True`, le chargeur de données fournit les lots dans l'ordre de dispatch des workers. Définissez `False` pour fournir les lots dès qu'ils sont prêts, ce qui peut réduire la latence de fin pour les charges de travail de streaming `IterableDataset`. Nécessite PyTorch >= 2.6.

auto_find_batch_size (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut déterminer automatiquement une taille de lot qui tient en mémoire par décroissance exponentielle, afin d'éviter les erreurs CUDA Out-of-Memory. Nécessite l'installation de accelerate (`pip install accelerate`)

ignore_data_skip (`bool`, *facultatif*, valeur par défaut `False`) : lors de la reprise de l'entraînement, indique s'il faut ignorer les époques et les lots afin de replacer le chargement des données au même stade que lors de l'entraînement précédent. Si la valeur est `True`, l'entraînement démarre plus rapidement (l'étape d'ignorance pouvant être longue), mais les résultats ne seront pas identiques à ceux que l'entraînement interrompu aurait produits.

sampler_seed (`int`, *facultatif*) : Graine aléatoire à utiliser avec les échantillonneurs de données. Si elle n'est pas définie, les générateurs aléatoires pour l'échantillonnage de données utiliseront la même graine que `self.seed`. Cela permet de garantir la reproductibilité de l'échantillonnage des données, indépendamment de la graine du modèle.

Une méthode qui regroupe tous les arguments liés à la création des dataloaders.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_dataloader(train_batch_size=16, eval_batch_size=64)
>>> args.per_device_train_batch_size
16
```

#### set_evaluate[[transformers.TrainingArguments.set_evaluate]]

```python
set_evaluate(strategy: str | transformers.trainer_utils.IntervalStrategy = 'no', steps: int = 500, batch_size: int = 8, accumulation_steps: int | None = None, delay: float | None = None, loss_only: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2311)

**Paramètres :**

strategy (`str` ou [IntervalStrategy](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.IntervalStrategy), *facultatif*, par défaut `"no"`) : La stratégie d'évaluation à adopter pendant l'entraînement. Les valeurs possibles sont :  - `"no"` : Aucune évaluation n'est effectuée pendant l'entraînement. - `"steps"` : L'évaluation est effectuée (et journalisée) toutes les `steps`. - `"epoch"` : L'évaluation est effectuée à la fin de chaque époque.  Définir une `strategy` différente de `"no"` définira `self.do_eval` sur `True`.

steps (`int`, *facultatif*, valeur par défaut 500) : Nombre d'étapes de mise à jour entre deux évaluations si `strategy="steps"`.

batch_size (`int` *facultatif*, par défaut 8) : La taille du lot par appareil (GPU/noyau TPU/CPU...) utilisée pour l'évaluation.

accumulation_steps (`int`, *facultatif*) : Nombre d'étapes de prédiction pour lesquelles accumuler les tenseurs de sortie avant de transférer les résultats vers le CPU. Si ce paramètre n'est pas défini, l'ensemble des prédictions est accumulé sur GPU/TPU avant d'être transféré vers le CPU (plus rapide, mais nécessite plus de mémoire).

delay (`float`, *facultatif*) : Nombre d'époques ou d'étapes à attendre avant que la première évaluation puisse être effectuée, en fonction de eval_strategy.

loss_only (`bool`, *facultatif*, valeur par défaut `False`) : Ignore toutes les sorties sauf la perte.

Une méthode qui regroupe tous les arguments liés à l'évaluation.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_evaluate(strategy="steps", steps=100)
>>> args.eval_steps
100
```

#### set_logging[[transformers.TrainingArguments.set_logging]]

```python
set_logging(strategy: str | transformers.trainer_utils.IntervalStrategy = 'steps', steps: int = 500, report_to: str | list[str] = 'none', level: str = 'passive', first_step: bool = False, nan_inf_filter: bool = False, on_each_node: bool = False, replica_level: str = 'passive')
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2453)

**Paramètres :**

strategy (`str` ou [IntervalStrategy](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.IntervalStrategy), *facultatif*, par défaut `"steps"`) : La stratégie de journalisation à adopter pendant l’entraînement. Les valeurs possibles sont : - `"no"` : aucun journalisation n’est effectuée pendant l’entraînement. - `"epoch"` : le journalisation est effectué à la fin de chaque époque. - `"steps"` : le journalisation est effectué toutes les `logging_steps`.

steps (`int`, *facultatif*, valeur par défaut 500) : Nombre d'étapes de mise à jour entre deux journaux si `strategy="steps"`.

level (`str`, *facultatif*, valeur par défaut `"passive"`) : Niveau de journalisation à utiliser sur le processus principal. Les choix possibles sont les niveaux de journalisation sous forme de chaînes : `"debug"`, `"info"`, `"warning"`, `"error"` et `"critical"`, ainsi qu'un niveau `"passive"` qui ne définit rien et laisse l'application définir le niveau.

report_to (`str` ou `list[str]`, *facultatif*, valeur par défaut `"none"`) : La liste des intégrations vers lesquelles signaler les résultats et les journaux. Les plateformes prises en charge sont `"azure_ml"`, `"clearml"`, `"codecarbon"`, `"comet_ml"`, `"dagshub"`, `"dvclive"`, `"flyte"`, `"mlflow"`, `"swanlab"`, `"tensorboard"`, `"trackio"` et `"wandb"`. Utilisez `"all"` pour signaler à toutes les intégrations installées, `"none"` pour aucune intégration.

first_step (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut journaliser et évaluer le premier `global_step` ou non.

nan_inf_filter (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut filtrer les pertes `nan` et `inf` pour la journalisation. Si la valeur est `True`, la perte de chaque étape qui est `nan` ou `inf` est filtrée et la perte moyenne de la fenêtre de journalisation actuelle est utilisée à la place. `nan_inf_filter` n'influence que la journalisation des valeurs de perte ; il ne modifie pas le comportement du calcul du gradient ni son application au modèle.

on_each_node (`bool`, *facultatif*, valeur par défaut `True`) : Dans l'entraînement distribué multi-nœuds, indique s'il faut journaliser en utilisant `log_level` une fois par nœud, ou uniquement sur le nœud principal.

replica_level (`str`, *facultatif*, valeur par défaut `"passive"`) : Niveau de journalisation à utiliser sur les répliques. Mêmes choix que `log_level`

Une méthode qui regroupe tous les arguments liés à la journalisation.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_logging(strategy="steps", steps=100)
>>> args.logging_steps
100
```

#### set_lr_scheduler[[transformers.TrainingArguments.set_lr_scheduler]]

```python
set_lr_scheduler(name: str | transformers.trainer_utils.SchedulerType = 'linear', num_epochs: float = 3.0, max_steps: int = -1, warmup_steps: float = 0)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2651)

**Paramètres :**

name (`str` ou [SchedulerType](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.SchedulerType), *facultatif*, par défaut `"linear"`) : Le type de planificateur à utiliser. Consultez la documentation de [SchedulerType](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.SchedulerType) pour toutes les valeurs possibles.

num_epochs(`float`, *facultatif*, valeur par défaut 3.0) : Nombre total d'époques d'entraînement à effectuer (si la valeur n'est pas un entier, la partie décimale correspond au pourcentage de la dernière époque à effectuer avant l'arrêt de l'entraînement).

max_steps (`int`, *facultatif*, valeur par défaut : -1) : Si défini sur un nombre positif, le nombre total d'étapes d'entraînement à effectuer. Remplace `num_train_epochs`. Pour un jeu de données fini, l'entraînement est répété sur le jeu de données (si toutes les données sont épuisées) jusqu'à ce que `max_steps` soit atteint. Il doit être défini sur une valeur positive lorsque le jeu de données d'entraînement n'implémente pas `__len__` (par exemple, un jeu de données en streaming), car le nombre total d'étapes ne peut alors pas être déduit et est nécessaire pour limiter la boucle d'entraînement et configurer le planificateur de taux d'apprentissage.

warmup_steps (`float`, *facultatif*, valeur par défaut 0) : Nombre d'étapes utilisées pour un réchauffement linéaire de 0 à `learning_rate`. Doit être un entier ou un nombre flottant dans l'intervalle `[0,1)`. S'il est inférieur à 1, il sera interprété comme le ratio d'étapes utilisées pour un réchauffement linéaire de 0 à `learning_rate`.

Une méthode qui regroupe tous les arguments liés au planificateur de taux d'apprentissage et à ses hyperparamètres.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_lr_scheduler(name="cosine", warmup_steps=0.05)
>>> args.warmup_steps
0.05
```

#### set_optimizer[[transformers.TrainingArguments.set_optimizer]]

```python
set_optimizer(name: str | transformers.training_args.OptimizerNames = 'adamw_torch', learning_rate: float = 5e-05, weight_decay: float = 0, beta1: float = 0.9, beta2: float = 0.999, epsilon: float = 1e-08, args: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2600)

**Paramètres :**

name (`str` ou `training_args.OptimizerNames`, *facultatif*, par défaut `"adamw_torch"`) : L'optimiseur à utiliser : `"adamw_torch"`, `"adamw_torch_fused"`, `"adamw_anyprecision"` ou `"adafactor"`.

learning_rate (`float`, *facultatif*, valeur par défaut 5e-5) : Le taux d'apprentissage initial.

weight_decay (`float`, *facultatif*, valeur par défaut 0) : Le poids de décroissance à appliquer (s'il n'est pas nul) à toutes les couches, à l'exception des poids de biais et de LayerNorm.

beta1 (`float`, *facultatif*, valeur par défaut 0,9) : l'hyperparamètre beta1 de l'optimiseur adam ou de ses variantes.

beta2 (`float`, *facultatif*, valeur par défaut 0.999) : l'hyperparamètre beta2 de l'optimiseur adam ou de ses variantes.

epsilon (`float`, *facultatif*, valeur par défaut 1e-8) : l'hyperparamètre epsilon pour l'optimiseur adam ou ses variantes.

args (`str`, *facultatif*) : Arguments facultatifs fournis à AnyPrecisionAdamW (utile uniquement lorsque `optim="adamw_anyprecision"`).

Une méthode qui regroupe tous les arguments liés à l'optimiseur et à ses hyperparamètres.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_optimizer(name="adamw_torch", beta1=0.8)
>>> args.optim
'adamw_torch'
```

#### set_push_to_hub[[transformers.TrainingArguments.set_push_to_hub]]

```python
set_push_to_hub(model_id: str, strategy: str | transformers.trainer_utils.HubStrategy = 'every_save', token: str | None = None, private_repo: bool | None = None, always_push: bool = False, revision: str | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2528)

**Paramètres :**

model_id (`str`) : Le nom du dépôt à garder synchronisé avec le *output_dir* local. Il peut s'agir d'un simple identifiant de modèle, auquel cas le modèle sera poussé dans votre espace de noms. Sinon, il doit s'agir du nom complet du dépôt, par exemple `"user_name/model"`, ce qui vous permet de pousser vers une organisation dont vous êtes membre avec `"organization_name/model"`.

strategy (`str` ou `HubStrategy`, *facultatif*, par défaut `"every_save"`) : Définit le périmètre de ce qui est poussé vers le Hub et quand. Les valeurs possibles sont :  - `"end"` : pousse le modèle, sa configuration, la processing_class par exemple le tokenizer (s'il est transmis au [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer)) et un brouillon de carte de modèle lorsque la méthode [save_model()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.save_model) est appelée. - `"every_save"` : pousse le modèle, sa configuration, la processing_class par exemple le tokenizer (s'il est transmis au [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer)) et un brouillon de carte de modèle à chaque sauvegarde du modèle. Les pousses sont asynchrones afin de ne pas bloquer l'entraînement, et si les sauvegardes sont très fréquentes, une nouvelle pousse n'est tentée que si la précédente est terminée. Une dernière pousse est effectuée avec le modèle final à la fin de l'entraînement. - `"checkpoint"` : comme `"every_save"` mais le dernier point de contrôle est également poussé dans un sous-dossier nommé last-checkpoint, ce qui vous permet de reprendre facilement l'entraînement avec `trainer.train(resume_from_checkpoint="last-checkpoint")`. - `"all_checkpoints"` : comme `"checkpoint"` mais tous les points de contrôle sont poussés tels qu'ils apparaissent dans le dossier de sortie (vous obtiendrez donc un dossier de point de contrôle par dossier dans votre dépôt final)

token (`str`, *facultatif*) : Jeton à utiliser pour pousser le modèle sur le Hub. Par défaut, le jeton du dossier de cache obtenu avec `hf auth login` est utilisé.

private_repo (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut rendre le dépôt privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le dépôt par défaut de l'organisation est privé. Cette valeur est ignorée si le dépôt existe déjà.

always_push (`bool`, *facultatif*, valeur par défaut `False`) : Sauf si cette valeur est `True`, le `Trainer` ignore l'envoi d'un point de contrôle si l'envoi précédent n'est pas terminé.

revision (`str`, *facultatif*) : La révision à utiliser lors de la publication sur le Hub. Peut être un nom de branche, un tag ou un hash de commit.

Une méthode qui regroupe tous les arguments liés à la synchronisation des points de contrôle avec le Hub.

L’appel de cette méthode définit `self.push_to_hub` sur `True`, ce qui signifie que `output_dir` devient un répertoire git synchronisé avec le dépôt (déterminé par `model_id`) et que le contenu est poussé à chaque fois qu’une sauvegarde est déclenchée (selon votre `self.save_strategy`). L’appel de [save_model()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.save_model) déclenche également un push.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_push_to_hub("me/awesome-model")
>>> args.hub_model_id
'me/awesome-model'
```

#### set_save[[transformers.TrainingArguments.set_save]]

```python
set_save(strategy: str | transformers.trainer_utils.IntervalStrategy = 'steps', steps: int = 500, total_limit: int | None = None, on_each_node: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2404)

**Paramètres :**

strategy (`str` ou [IntervalStrategy](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.IntervalStrategy), *facultatif*, par défaut `"steps"`) : La stratégie de sauvegarde des points de contrôle à adopter pendant l'entraînement. Les valeurs possibles sont :  - `"no"` : Aucune sauvegarde n'est effectuée pendant l'entraînement. - `"epoch"` : La sauvegarde est effectuée à la fin de chaque époque. - `"steps"` : La sauvegarde est effectuée toutes les `save_steps`.

steps (`int`, *facultatif*, valeur par défaut : 500) : Nombre d'étapes de mise à jour entre deux sauvegardes de points de contrôle si `strategy="steps"`.

total_limit (`int`, *facultatif*) : Si une valeur est transmise, limite le nombre total de points de contrôle. Supprime les points de contrôle les plus anciens dans `output_dir`.

on_each_node (`bool`, *facultatif*, valeur par défaut `False`) : Lors d'une formation distribuée multi-nœuds, indique s'il faut enregistrer les modèles et les points de contrôle sur chaque nœud, ou uniquement sur le nœud principal. Cette option ne doit pas être activée si les différents nœuds utilisent le même stockage, car les fichiers seraient enregistrés avec les mêmes noms sur chaque nœud.

Une méthode qui regroupe tous les arguments liés à l'enregistrement des points de contrôle.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_save(strategy="steps", steps=100)
>>> args.save_steps
100
```

#### set_testing[[transformers.TrainingArguments.set_testing]]

```python
set_testing(batch_size: int = 8, loss_only: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2368)

**Paramètres :**

batch_size (`int` *facultatif*, par défaut 8) : La taille du lot par appareil (GPU/noyau TPU/CPU...) utilisée pour les tests.

loss_only (`bool`, *facultatif*, valeur par défaut `False`) : Ignore toutes les sorties sauf la perte.

Une méthode qui regroupe tous les arguments de base liés aux tests sur un jeu de données de validation.

L'appel de cette méthode définit automatiquement `self.do_predict` sur `True`.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_testing(batch_size=32)
>>> args.per_device_eval_batch_size
32
```

#### set_training[[transformers.TrainingArguments.set_training]]

```python
set_training(learning_rate: float = 5e-05, batch_size: int = 8, weight_decay: float = 0, num_epochs: float = 3, max_steps: int = -1, gradient_accumulation_steps: int = 1, seed: int = 42, activation_checkpointing: bool = False, gradient_checkpointing: bool | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2225)

**Paramètres :**

learning_rate (`float`, *facultatif*, valeur par défaut 5e-5) : Le taux d'apprentissage initial pour l'optimiseur.

batch_size (`int` *facultatif*, par défaut 8) : La taille du lot par appareil (GPU/noyau TPU/CPU...) utilisée pour l'entraînement.

weight_decay (`float`, *facultatif*, valeur par défaut 0) : Le taux de décroissance du poids à appliquer (s'il n'est pas nul) à toutes les couches, à l'exception des poids de biais et de LayerNorm, dans l'optimiseur.

num_epochs (`float`, *facultatif*, valeur par défaut 3.0) : Nombre total d'époques d'entraînement à effectuer (si la valeur n'est pas un entier, la partie décimale correspond au pourcentage de la dernière époque à effectuer avant l'arrêt de l'entraînement).

max_steps (`int`, *facultatif*, valeur par défaut : -1) : Si défini sur un nombre positif, le nombre total d'étapes d'entraînement à effectuer. Remplace `num_train_epochs`. Pour un jeu de données fini, l'entraînement est répété sur le jeu de données (si toutes les données sont épuisées) jusqu'à ce que `max_steps` soit atteint. Il doit être défini sur une valeur positive lorsque le jeu de données d'entraînement n'implémente pas `__len__` (par exemple, un jeu de données en streaming), car le nombre total d'étapes ne peut alors pas être déduit et est nécessaire pour limiter la boucle d'entraînement et configurer le planificateur de taux d'apprentissage.

gradient_accumulation_steps (`int`, *facultatif*, valeur par défaut : 1) : Nombre d'étapes de mise à jour pour accumuler les gradients avant d'effectuer un passage de rétropropagation/mise à jour. Lors de l'utilisation de l'accumulation de gradients, une étape est comptée comme une étape avec passage de rétropropagation. Par conséquent, la journalisation, l'évaluation et la sauvegarde seront effectuées toutes les `gradient_accumulation_steps * xxx_step` exemples d'entraînement.

seed (`int`, *facultatif*, valeur par défaut 42) : Graine aléatoire qui sera définie au début de l'entraînement. Pour garantir la reproductibilité entre les exécutions, utilisez la fonction `~Trainer.model_init` pour instancier le modèle s'il possède des paramètres initialisés aléatoirement.

activation_checkpointing (`bool`, *facultatif*, valeur par défaut `False`) : Si True, utilise le checkpointing d'activation pour économiser de la mémoire au détriment d'une passe arrière plus lente.

gradient_checkpointing (`bool`, *facultatif*) : Alias obsolète de `activation_checkpointing`, sera supprimé dans la v6.

Une méthode qui regroupe tous les arguments de base liés à l'entraînement.

L'appel de cette méthode définit automatiquement `self.do_train` sur `True`.

Exemple :

```py
>>> from transformers import TrainingArguments

>>> args = TrainingArguments("working_dir")
>>> args = args.set_training(learning_rate=1e-4, batch_size=32)
>>> args.learning_rate
1e-4
```

#### to_dict[[transformers.TrainingArguments.to_dict]]

```python
to_dict()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2175)

Sérialise cette instance en remplaçant `Enum` par leurs valeurs (pour la prise en charge de la sérialisation JSON). Elle obscurcit les valeurs des jetons en supprimant leur valeur.

#### to_json_string[[transformers.TrainingArguments.to_json_string]]

```python
to_json_string()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2205)

Sérialise cette instance en chaîne JSON.

#### to_sanitized_dict[[transformers.TrainingArguments.to_sanitized_dict]]

```python
to_sanitized_dict()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args.py#L2211)

Sérialisation assainie à utiliser avec les hparams de TensorBoard

## Seq2SeqTrainingArguments[[transformers.Seq2SeqTrainingArguments]]

#### transformers.Seq2SeqTrainingArguments[[transformers.Seq2SeqTrainingArguments]]

```python
transformers.Seq2SeqTrainingArguments(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 = 5e-05, 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 = False, 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 | None = None, 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 = 500, 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: typing.Any | 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, sortish_sampler: bool = False, predict_with_generate: bool = False, generation_max_length: int | None = None, generation_num_beams: int | None = None, generation_config: str | pathlib.Path | transformers.generation.configuration_utils.GenerationConfig | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args_seq2seq.py#L29)

**Paramètres :**

output_dir (`str`, *facultatif*, valeur par défaut `"trainer_output"`) : Le répertoire de sortie où les prédictions du modèle et les points de contrôle seront écrits.

**Durée d'entraînement et taille du lot :**

per_device_train_batch_size (`int`, *facultatif*, valeur par défaut : 8) : La taille du lot *par appareil*. La **taille de lot globale** est calculée comme suit : `per_device_train_batch_size * number_of_devices` dans les configurations multi-GPU ou distribuées.

num_train_epochs(`float`, *facultatif*, valeur par défaut 3.0) : Nombre total d'époques d'entraînement à effectuer (si la valeur n'est pas un entier, la partie décimale correspond au pourcentage de la dernière époque à effectuer avant l'arrêt de l'entraînement).

max_steps (`int`, *facultatif*, valeur par défaut : -1) : Remplace `num_train_epochs`. S'il est défini sur un nombre positif, il indique le nombre total d'étapes d'entraînement à effectuer. Pour un jeu de données fini, l'entraînement est répété sur le jeu de données (si toutes les données sont épuisées) jusqu'à ce que `max_steps` soit atteint. Il doit être défini sur une valeur positive lorsque le jeu de données d'entraînement n'implémente pas `__len__` (par exemple, un jeu de données en streaming), car le nombre total d'étapes ne peut alors pas être déduit et est nécessaire pour limiter la boucle d'entraînement et configurer le planificateur de taux d'apprentissage.

**Taux d'apprentissage et planificateur :**

learning_rate (`float`, *facultatif*, valeur par défaut : 5e-5) : Le taux d'apprentissage initial de l'optimiseur. Il s'agit généralement du taux d'apprentissage maximal lors de l'utilisation d'un planificateur avec une phase de montée en charge (warmup).

lr_scheduler_type (`str` ou [SchedulerType](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.SchedulerType), *facultatif*, par défaut `"linear"`) : Le type de planificateur de taux d'apprentissage à utiliser. Consultez [SchedulerType](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.SchedulerType) pour toutes les valeurs possibles. Choix courants : - "linear" = [get_linear_schedule_with_warmup()](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) - "cosine" = [get_cosine_schedule_with_warmup()](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.get_cosine_schedule_with_warmup) - "constant" =  [get_constant_schedule()](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.get_constant_schedule) - "constant_with_warmup" = [get_constant_schedule_with_warmup()](/docs/transformers/v5.23.0/fr/main_classes/optimizer_schedules#transformers.get_constant_schedule_with_warmup)

lr_scheduler_kwargs (`dict` ou `str`, *facultatif*, valeur par défaut `None`) : Les arguments supplémentaires pour le lr_scheduler. Consultez la documentation de chaque scheduler pour les valeurs possibles.

warmup_steps (`int` ou `float`, *facultatif*, valeur par défaut 0) : Nombre d'étapes pour un réchauffement linéaire de 0 à `learning_rate`. Le réchauffement aide à stabiliser l'entraînement lors de la phase initiale. Peut être : - Un entier : nombre exact d'étapes de réchauffement - Un float dans l'intervalle [0, 1) : interprété comme le ratio des étapes d'entraînement totales

**Optimiseur :**

optim (`str` ou `training_args.OptimizerNames`, *facultatif*, par défaut `"adamw_torch"` (pour torch>=2.8 `"adamw_torch_fused"`)) : L'optimiseur à utiliser. Options courantes : - `"adamw_torch"` : AdamW de PyTorch (défaut recommandé) - `"adamw_torch_fused"` : noyau AdamW fusionné - `"adamw_hf"` : implémentation AdamW de HuggingFace - `"sgd"` : descente de gradient stochastique avec élan - `"adafactor"` : optimiseur économe en mémoire pour les grands modèles - `"adamw_8bit"` : AdamW 8 bits (nécessite bitsandbytes) Voir `OptimizerNames` pour la liste complète.

optim_args (`str`, *facultatif*) : Arguments facultatifs fournis aux optimiseurs tels que AnyPrecisionAdamW, AdEMAMix et GaLore.

weight_decay (`float`, *facultatif*, valeur par défaut 0) : Coefficient de décroissance du poids appliqué par l'optimiseur (et non par la fonction de perte). Ajoute une régularisation L2 pour prévenir le surapprentissage en pénalisant les poids élevés. Exclu automatiquement des paramètres de biais et de LayerNorm. Valeurs typiques : 0,01 (standard), 0,1 (régularisation plus forte), 0,0 (aucune régularisation).

adam_beta1 (`float`, *facultatif*, valeur par défaut 0.9) : Taux de décroissance exponentielle pour les estimations du premier moment (momentum) dans les optimiseurs basés sur Adam. Contrôle la quantité d'historique des gradients à conserver.

adam_beta2 (`float`, *facultatif*, valeur par défaut 0.999) : Taux de décroissance exponentielle pour les estimations du second moment (variance) dans les optimiseurs basés sur Adam. Contrôle le réglage adaptatif du taux d'apprentissage.

adam_epsilon (`float`, *facultatif*, valeur par défaut 1e-8) : Valeur d'épsilon pour la stabilité numérique dans les optimiseurs basés sur Adam. Empêche la division par zéro au dénominateur de la règle de mise à jour.

optim_target_modules (`Union[str, list[str]]`, *facultatif*) : Les modules cibles à optimiser, c'est-à-dire les noms de modules que vous souhaitez entraîner. Utilisé actuellement pour l'[algorithme GaLore](https://huggingface.co/papers/2403.03507) et l'[algorithme APOLLO](https://huggingface.co/papers/2412.05270). Consultez [l'implémentation de GaLore](https://github.com/jiaweizzhao/GaLore) et [l'implémentation d'APOLLO](https://github.com/zhuhanqing/APOLLO) pour plus de détails. Vous devez vous assurer de passer un optimiseur GaLore ou APOLLO valide, par exemple l'un des suivants : "apollo_adamw", "galore_adamw", "galore_adamw_8bit", "galore_adafactor", et de vous assurer que les modules cibles sont uniquement des modules `nn.Linear`.

**Régularisation et stabilité de l'entraînement :**

gradient_accumulation_steps (`int`, *facultatif*, valeur par défaut : 1) : Nombre d'étapes de mise à jour pour accumuler les gradients avant d'effectuer un passage arrière/mise à jour. Permet de simuler des tailles de lot plus importantes sans mémoire supplémentaire. Taille de lot effective = `per_device_train_batch_size × num_devices × gradient_accumulation_steps`. > [!TIP] > Lors de l'utilisation de l'accumulation de gradients, une « étape » correspond à une étape avec un passage arrière. Par conséquent, la journalisation, l'évaluation et l'enregistrement se produiront toutes les `gradient_accumulation_steps × xxx_step` exemples d'entraînement.

average_tokens_across_devices (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ou non faire la moyenne des jetons entre les appareils. Si activé, utilise all_reduce pour synchroniser num_tokens_in_batch afin de calculer précisément la perte. Référence : https://github.com/huggingface/transformers/issues/34242

max_grad_norm (`float`, *facultatif*, valeur par défaut 1.0) : Norme maximale du gradient pour le clipping des gradients. Appliquée après la rétropropagation, avant l'étape de l'optimiseur. Empêche l'explosion des gradients en les réduisant lorsque leur norme globale dépasse ce seuil. Définir à 0 pour désactiver le clipping. Valeurs typiques : 1.0 (standard), 0.5 (plus conservateur), 5.0 (moins agressif).

label_smoothing_factor (`float`, *facultatif*, valeur par défaut 0.0) : Facteur de lissage des étiquettes pour éviter l'excès de confiance. Remplace les cibles dures 0/1 par des cibles douces : 0 devient `ε/num_labels` et 1 devient `1 - ε + ε/num_labels`, où ε = `label_smoothing_factor`. Une valeur nulle signifie qu'aucun lissage n'est appliqué. Plage typique : de 0.0 à 0.1.

**Entraînement en précision mixte :**

bf16 (`bool`, *facultatif*, valeur par défaut `False`) : Active l'entraînement en précision mixte bfloat16 (BF16). Généralement préféré à FP16 en raison d'une meilleure stabilité numérique et de l'absence de mise à l'échelle de la perte requise.

fp16 (`bool`, *facultatif*, valeur par défaut `False`) : Active l'entraînement en précision mixte float16 (FP16). Pensez à utiliser BF16 à la place si votre matériel le prend en charge.

bf16_full_eval (`bool`, *facultatif*, valeur par défaut `False`) : Utiliser la pleine précision BF16 pour l'évaluation (et non seulement la précision mixte). Plus rapide et économe en mémoire, mais peut affecter légèrement les valeurs des métriques. S'applique uniquement pendant l'évaluation.

fp16_full_eval (`bool`, *facultatif*, valeur par défaut `False`) : Utiliser la pleine précision FP16 pour l'évaluation (et non seulement la précision mixte). Plus rapide et économe en mémoire, mais peut affecter légèrement les valeurs des métriques. S'applique uniquement pendant l'évaluation.

tf32 (`bool`, *facultatif*) : Active le mode TensorFloat-32 (TF32) sur les GPU Ampere et plus récents. TF32 utilise une précision de 19 bits pour les multiplications de matrices (contre 23 bits pour FP32), offrant jusqu'à 8 fois plus de rapidité avec une perte de précision négligeable. La valeur par défaut dépend de la version de PyTorch. Voir [la documentation TF32](https://huggingface.co/docs/transformers/perf_train_gpu_one#tf32).

**Activation Checkpointing :**

activation_checkpointing (`bool`, *facultatif*, valeur par défaut `False`) : Active le checkpointing des activations pour échanger de la puissance de calcul contre de la mémoire. Réduit l'utilisation de la mémoire en effaçant les activations pendant le passage avant et en les recalculant pendant le passage arrière. Permet d'entraîner des modèles plus grands ou des tailles de lot plus élevées, au prix d'un entraînement environ 20 % plus lent.

activation_checkpointing_kwargs (`dict`, *facultatif*, valeur par défaut `None`) : Arguments nominaux transmis à `activation_checkpointing_enable()`. `every_n_layers` effectue le checkpointing uniquement de toutes les n-ièmes couches décodeur au lieu de toutes ; `1` correspond au comportement habituel tout-ou-rien, et des valeurs plus élevées restituent une partie de la mémoire au détriment de la vitesse. `offload` conserve les activations sauvegardées en mémoire hôte épinglée, ce qui libère `layers x sequence x hidden` octets de mémoire sur l'appareil et ralentit l'étape. Toute autre clé est transmise à `torch.utils.checkpoint.checkpoint`.

gradient_checkpointing (`bool`, *facultatif*) : Alias obsolète de `activation_checkpointing`, sera supprimé dans la v6.

gradient_checkpointing_kwargs (`dict`, *facultatif*) : alias obsolète de `activation_checkpointing_kwargs`, sera supprimé dans la v6.

**Compilation :**

torch_compile (`bool`, *facultatif*, valeur par défaut `False`) : Compile le modèle à l'aide de `torch.compile()` de PyTorch 2.0 pour un entraînement plus rapide. Peut offrir une accélération de 20 à 50 % sans aucune modification du code. Utilise les paramètres de compilation par défaut, sauf si `torch_compile_backend` ou `torch_compile_mode` sont spécifiés.

torch_compile_backend (`str`, *facultatif*) : Backend pour `torch.compile()`. S'il est défini, active automatiquement `torch_compile`. Les options incluent `"inductor"` (par défaut), `"aot_eager"`, `"cudagraphs"`. Les backends varient selon la version de PyTorch - consultez la documentation de PyTorch pour les options disponibles.

torch_compile_mode (`str`, *facultatif*) : Mode de compilation pour `torch.compile()`. S'il est défini, active automatiquement `torch_compile`. Options : `"default"`, `"reduce-overhead"` (minimiser la surcharge Python), `"max-autotune"` (optimisation agressive, temps de compilation plus long).

**Noyaux :**

use_liger_kernel (`bool`, *facultatif*, valeur par défaut `False`) : Active les optimisations [Liger Kernel](https://github.com/linkedin/Liger-Kernel). Augmente le débit multi-GPU d'environ 20 % et réduit l'utilisation de la mémoire d'environ 60 %. Compatible avec Flash Attention, FSDP et DeepSpeed. Prend actuellement en charge les modèles Llama, Mistral, Mixtral et Gemma.

liger_kernel_config (`Optional[dict]`, *facultatif*) : Configuration pour Liger Kernel. Transmise en tant que kwargs à `_apply_liger_kernel_to_instance()`. Les options incluent généralement : `"rope"`, `"swiglu"`, `"cross_entropy"`, `"fused_linear_cross_entropy"`, `"rms_norm"`. Si `None`, la configuration par défaut est utilisée.

**Optimisations supplémentaires :**

use_cache (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut activer le cache pour le modèle. Pour l'entraînement, cela n'est généralement pas nécessaire, à l'exception de certaines méthodes PEFT qui utilisent `past_key_values`.

neftune_noise_alpha (`Optional[float]`) : Si la valeur n'est pas `None`, les embeddings de bruit NEFTune seront activés. Cela peut améliorer considérablement les performances du modèle lors de l'ajustement fin sur des instructions. Consultez le [paper original](https://huggingface.co/papers/2310.05914) et le [code original](https://github.com/neelsjain/NEFTune). Prend en charge les `PreTrainedModel` de transformers ainsi que les `PeftModel` de peft. Le paper original utilisait des valeurs comprises dans l'intervalle [5.0, 15.0].

torch_empty_cache_steps (`int`, *facultatif*) : Nombre d'étapes à attendre avant d'appeler `torch.<device>.empty_cache()`. Si cette valeur n'est pas définie ou est définie sur None, le cache ne sera pas vidé. Cela peut aider à éviter les erreurs de mémoire insuffisante CUDA en réduisant l'utilisation maximale de la VRAM, au prix d'une [performance environ 10 % plus lente](https://github.com/huggingface/transformers/issues/31372).

auto_find_batch_size (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut déterminer automatiquement une taille de lot d'entraînement qui tient en mémoire, par décroissance exponentielle, afin d'éviter les erreurs CUDA Out-of-Memory. La taille de lot d'évaluation n'est pas ajustée.

**Journalisation et suivi de l'entraînement :**

logging_strategy (`str` ou [IntervalStrategy](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.IntervalStrategy), *facultatif*, par défaut `"steps"`) : La stratégie de journalisation à adopter pendant l'entraînement. Les valeurs possibles sont : - `"no"` : Aucune journalisation n'est effectuée pendant l'entraînement. - `"epoch"` : La journalisation est effectuée à la fin de chaque époque. - `"steps"` : La journalisation est effectuée toutes les `logging_steps`.

logging_steps (`int` ou `float`, *facultatif*, valeur par défaut : 500) : Nombre d'étapes de mise à jour entre deux journaux si `logging_strategy="steps"`. Doit être un entier ou un nombre flottant dans l'intervalle `[0,1)`. S'il est inférieur à 1, il sera interprété comme le ratio des étapes d'entraînement totales.

logging_first_step (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut journaliser la première `global_step` ou non.

log_on_each_node (`bool`, *facultatif*, valeur par défaut `True`) : Dans l'entraînement distribué multi-nœuds, indique s'il faut journaliser en utilisant `log_level` une fois par nœud, ou uniquement sur le nœud principal.

logging_nan_inf_filter (`bool`, *facultatif*, valeur par défaut `True`) : Exclure les pertes NaN et Inf lors de la journalisation. Si `True`, remplace les pertes d'entraînement NaN/Inf par la moyenne des pertes valides récentes et exclut les lots NaN/Inf (par exemple, les lots sans jetons d'étiquette) de la perte d'évaluation. N'affecte pas le calcul des gradients, uniquement la journalisation.

include_num_input_tokens_seen (`Optional[Union[str, bool]]`, *facultatif*, valeur par défaut "no") : Indique s'il faut suivre le nombre de jetons d'entrée vus. Doit être l'une des valeurs ["all", "non_padding", "no"] ou une valeur booléenne qui correspond à "all" ou "no". Peut être plus lent en formation distribuée, car des opérations de collecte doivent être appelées.

**Journalisation :**

log_level (`str`, *facultatif*, valeur par défaut `passive`) : Niveau de journalisation pour le processus principal. Options : `"debug"`, `"info"`, `"warning"`, `"error"`, `"critical"` ou `"passive"` (ne modifie pas le niveau de journalisation actuel de Transformers, qui est `"warning"` par défaut)

log_level_replica (`str`, *facultatif*, valeur par défaut `"warning"`) : Niveau de journalisation pour les processus répliques dans l'entraînement distribué. Les options sont les mêmes que pour `log_level`.

disable_tqdm (`bool`, *facultatif*) : Désactive les barres de progression tqdm. La valeur par défaut est `True` si `log_level` est warning ou inférieur, `False` sinon.

**Intégration du suivi des expériences :**

report_to (`str` ou `list[str]`, *facultatif*, valeur par défaut `"none"`) : La liste des intégrations vers lesquelles signaler les résultats et les journaux. Les plateformes prises en charge sont `"azure_ml"`, `"clearml"`, `"codecarbon"`, `"comet_ml"`, `"dagshub"`, `"dvclive"`, `"flyte"`, `"mlflow"`, `"swanlab"`, `"tensorboard"`, `"trackio"` et `"wandb"`. Utilisez `"all"` pour signaler à toutes les intégrations installées, `"none"` pour aucune intégration.

run_name (`str`, *facultatif*) : Un descripteur pour l'exécution. Utilisé généralement pour la journalisation [trackio](https://github.com/gradio-app/trackio), [wandb](https://www.wandb.com/), [mlflow](https://www.mlflow.org/), [comet](https://www.comet.com/site) et [swanlab](https://swanlab.cn).

project (`str`, *facultatif*, valeur par défaut `"huggingface"`) : Le nom du projet à utiliser pour la journalisation. Actuellement, utilisé uniquement par Trackio.

trackio_space_id (`str` ou `None`, *facultatif*, valeur par défaut `None`) : L'identifiant de l'Espace Hugging Face à utiliser pour la journalisation Trackio en direct avec un Espace basé sur Gradio. Doit être un nom d'Espace complet comme `'username/reponame'` ou `'orgname/reponame'`, ou simplement `'reponame'` (l'Espace est créé dans l'espace de noms de l'utilisateur actuellement connecté). Si `None`, les métriques sont journalisées uniquement dans un répertoire **local** (aucun Espace sur le Hub). Cet Espace Gradio a un accès **lecture et écriture** au **Bucket** Trackio, ce qui est souhaitable lorsque l'entraînement est **en cours**—par exemple lors de la **reprise** d'une exécution partielle ou de l'**agrégation des journaux** provenant de plusieurs machines. L'Espace sera **public** sauf si vous définissez `hub_private_repo=True` ou si le paramètre par défaut de votre organisation est de créer des Espaces privés.

trackio_bucket_id (`str` ou `None`, *facultatif*, valeur par défaut `None`) : identifiant facultatif du Bucket Hugging Face pour Trackio. S'il n'est pas défini, Trackio en dérive un. Utilisé conjointement avec un Space Gradio (`trackio_space_id`) et lors du déploiement d'un Space statique (`trackio_static_space_id` n'est pas `False`).

trackio_static_space_id (`str`, `False` ou `None`, *facultatif*, par défaut `None`) : L'identifiant de l'Espace Hugging Face à utiliser pour l'Espace statique créé après la fin de l'entraînement. Doit être un nom complet d'Espace comme `'username/reponame'` ou `'orgname/reponame'`, ou simplement `'reponame'` (l'Espace est créé dans l'espace de noms de l'utilisateur actuellement connecté). Si False, aucun Espace statique ne sera créé. Si None, et que le modèle est poussé sur le Hub, un Espace statique sera créé avec un nom par défaut et ce lien sera ajouté depuis la carte du modèle. L'Espace sera public, sauf si vous définissez `hub_private_repo=True` ou si le paramètre par défaut de votre organisation est de créer des Espaces privés.

**Évaluation :**

eval_strategy (`str` ou [IntervalStrategy](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.IntervalStrategy), *facultatif*, par défaut `"no"`) : Moment où effectuer l'évaluation. Options : - `"no"` : Aucune évaluation pendant l'entraînement - `"steps"` : Évaluer toutes les `eval_steps` - `"epoch"` : Évaluer à la fin de chaque époque

eval_steps (`int` ou `float`, *facultatif*) : Nombre d'étapes de mise à jour entre deux évaluations si `eval_strategy="steps"`. Par défaut, prend la même valeur que `logging_steps` si non défini. Doit être un entier ou un nombre flottant dans l'intervalle `[0,1)`. S'il est inférieur à 1, il sera interprété comme un ratio des étapes d'entraînement totales.

eval_delay (`float`, *facultatif*) : Nombre d'époques ou d'étapes à attendre avant que la première évaluation puisse être effectuée, en fonction de eval_strategy.

per_device_eval_batch_size (`int`, *facultatif*, valeur par défaut : 8) : La taille du lot par cœur d'accélérateur/CPU pour l'évaluation.

prediction_loss_only (`bool`, *facultatif*, valeur par défaut `False`) : Lors de l'évaluation et de la génération de prédictions, ne renvoie que la perte.

eval_on_start (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut effectuer une étape d'évaluation (vérification de cohérence) avant l'entraînement afin de s'assurer que les étapes de validation fonctionnent correctement.

eval_do_concat_batches (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut concaténer récursivement les entrées, pertes, étiquettes et prédictions entre les lots. Si `False`, ils sont stockés sous forme de listes, chaque lot étant conservé séparément.

eval_use_gather_object (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut effectuer une collecte récursive des objets dans une liste/tuple/dictionnaire imbriqué d'objets à partir de tous les appareils. Cette option ne doit être activée que si les utilisateurs ne renvoient pas uniquement des tenseurs, et PyTorch la décourage activement. Elle est utile lorsque la structure des étiquettes est non standard, comme dans les tâches de vision par ordinateur.

eval_accumulation_steps (`int`, *facultatif*) : Nombre d'étapes de prédiction pour lesquelles accumuler les tenseurs de sortie avant de transférer les résultats vers le CPU. Si cette valeur n'est pas définie, l'ensemble des prédictions est accumulé sur l'accélérateur de l'appareil avant d'être transféré vers le CPU (plus rapide, mais nécessite plus de mémoire).

**Calcul des métriques :**

include_for_metrics (`list[str]`, *facultatif*, valeur par défaut `[]`) : Inclut des données supplémentaires dans la fonction `compute_metrics` si nécessaire pour le calcul des métriques. Options possibles à ajouter à la liste `include_for_metrics` : - `"inputs"` : Données d'entrée transmées au modèle, destinées au calcul de métriques dépendant des entrées. - `"loss"` : Valeurs de perte calculées lors de l'évaluation, destinées au calcul de métriques dépendant de la perte.

batch_eval_metrics (`bool`, *facultatif*, valeur par défaut `False`) : Si défini sur `True`, l'évaluation appellera compute_metrics à la fin de chaque lot pour accumuler des statistiques, plutôt que de stocker tous les logits d'évaluation en mémoire. Lorsqu'il est défini sur `True`, vous devez transmettre une fonction compute_metrics qui accepte un argument booléen `compute_result` ; lorsqu'elle reçoit `True`, elle déclenche le calcul des statistiques globales finales à partir des statistiques de niveau lot que vous avez accumulées sur l'ensemble d'évaluation.

**Point de contrôle et sauvegarde :**

save_only_model (`bool`, *facultatif*, valeur par défaut `False`) : Enregistre uniquement les poids du modèle, sans l'état de l'optimiseur, du planificateur ou du générateur aléatoire. Réduit considérablement la taille du point de contrôle, mais empêche la reprise de l'entraînement depuis ce point de contrôle. À utiliser lorsque vous avez uniquement besoin du modèle entraîné pour l'inférence, et non pour une formation continue. Vous ne pouvez charger le modèle qu'à l'aide de `from_pretrained` avec cette option définie sur `True`.

save_strategy (`str` ou `SaveStrategy`, *facultatif*, par défaut `"steps"`) : La stratégie d'enregistrement des points de contrôle à adopter pendant l'entraînement. Les valeurs possibles sont : - `"no"` : Aucun enregistrement n'est effectué pendant l'entraînement. - `"epoch"` : L'enregistrement est effectué à la fin de chaque époque. - `"steps"` : L'enregistrement est effectué toutes les `save_steps`. - `"best"` : L'enregistrement est effectué chaque fois qu'une nouvelle `best_metric` est atteinte.

save_steps (`int` ou `float`, *facultatif*, valeur par défaut : 500) : Nombre d'étapes de mise à jour entre deux sauvegardes de points de contrôle si `save_strategy="steps"`. Doit être un entier ou un nombre flottant dans l'intervalle `[0,1)`. S'il est inférieur à 1, il sera interprété comme un ratio des étapes d'entraînement totales.

save_on_each_node (`bool`, *facultatif*, valeur par défaut `False`) : Lors d'une formation distribuée multi-nœuds, indique s'il faut enregistrer les modèles et les points de contrôle sur chaque nœud, ou uniquement sur le nœud principal. Cette option ne doit pas être activée si les différents nœuds utilisent le même stockage, car les fichiers seraient enregistrés avec les mêmes noms sur chaque nœud.

save_total_limit (`int`, *facultatif*) : Nombre maximal de points de contrôle à conserver. Supprime les points de contrôle plus anciens dans `output_dir`. Lorsque `load_best_model_at_end=True`, le meilleur point de contrôle est toujours conservé, ainsi que les plus récents. Par exemple, `save_total_limit=5` conserve les 4 plus récents ainsi que le meilleur.

enable_jit_checkpoint (`bool`, *facultatif*, valeur par défaut `False`) : Active le checkpointing Just-In-Time lors du signal SIGTERM pour une terminaison propre sur les charges de travail préemptibles. **Important** : Configurez la période d'arrêt propre de votre orchestrateur pour laisser un temps suffisant. Pour Kubernetes, définissez `terminationGracePeriodSeconds` (la valeur par défaut de 30 s est généralement insuffisante). Pour Slurm, utilisez `--signal=TERM@<seconds>`. La période de grâce requise doit être supérieure ou égale à la durée de la plus longue itération + le temps de sauvegarde du checkpoint.

**Intégration avec Hugging Face Hub :**

push_to_hub (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut ou non pousser le modèle sur le Hub à chaque fois que le modèle est enregistré. Si cette option est activée, `output_dir` devient un répertoire git synchronisé avec le dépôt (déterminé par `hub_model_id`) et le contenu est poussé à chaque fois qu'un enregistrement est déclenché (selon votre `save_strategy`). L'appel de [save_model()](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer.save_model) déclenchera également un push.

hub_token (`str`, *facultatif*) : Jeton à utiliser pour pousser le modèle sur le Hub. Par défaut, le jeton du dossier de cache obtenu avec `hf auth login` est utilisé.

hub_private_repo (`bool`, *facultatif*) : Indique si le dépôt doit être privé. Si la valeur est `None` (par défaut), le dépôt sera public, sauf si le paramètre par défaut de l'organisation est « privé ». Cette valeur est ignorée si le dépôt existe déjà. En cas d'envoi de rapports vers Trackio avec le déploiement sur Hugging Face Spaces activé, la même logique détermine si le Space est privé.

hub_model_id (`str`, *facultatif*) : Le nom du dépôt à garder synchronisé avec le *output_dir* local. Il peut s'agir d'un simple identifiant de modèle, auquel cas le modèle sera poussé dans votre espace de noms. Sinon, il doit s'agir du nom complet du dépôt, par exemple `"user_name/model"`, ce qui vous permet de pousser vers une organisation dont vous êtes membre avec `"organization_name/model"`. La valeur par défaut est `user_name/output_dir_name`, *output_dir_name* étant le nom de `output_dir`.

hub_strategy (`str` ou `HubStrategy`, *facultatif*, par défaut `"every_save"`) : Définit ce qui doit être poussé vers le Hub et quand. Options : - `"end"` : Pousse uniquement à la fin de l'entraînement - `"every_save"` : Pousse à chaque sauvegarde (asynchrone pour ne pas bloquer l'entraînement) - `"checkpoint"` : Comme `"every_save"`, mais pousse également le dernier point de contrôle dans le sous-dossier `"last-checkpoint"` pour faciliter la reprise - `"all_checkpoints"` : Pousse tous les points de contrôle à mesure qu'ils apparaissent

hub_always_push (`bool`, *facultatif*, valeur par défaut `False`) : Sauf si cette valeur est `True`, le `Trainer` ignore l'envoi d'un point de contrôle si l'envoi précédent n'est pas terminé.

hub_revision (`str`, *facultatif*) : La révision à utiliser lors de la publication sur le Hub. Peut être un nom de branche, un tag ou un hash de commit.

**Suivi optimal des modèles :**

load_best_model_at_end (`bool`, *facultatif*, valeur par défaut `False`) : Charge le meilleur point de contrôle à la fin de l'entraînement. Nécessite que `eval_strategy` soit défini. Lorsqu'il est activé, le meilleur point de contrôle est toujours enregistré (voir `save_total_limit`).  Si `True`, `save_strategy` doit correspondre à `eval_strategy` (sauf si `save_strategy` est `"best"`), et si `"steps"` est utilisé, `save_steps` doit être un multiple de `eval_steps`.

metric_for_best_model (`str`, *facultatif*) : Métrique à utiliser pour comparer les modèles lorsque `load_best_model_at_end=True`. Doit être un nom de métrique renvoyé par l'évaluation, avec ou sans le préfixe `"eval_"`. La valeur par défaut est `"loss"`. Si vous définissez ce paramètre, `greater_is_better` aura par défaut la valeur `True`, sauf si le nom se termine par `"loss"`. Exemples : `"accuracy"`, `"f1"`, `"eval_bleu"`.

greater_is_better (`bool`, *facultatif*) : Indique si des valeurs de métrique plus élevées sont préférables. La valeur par défaut est basée sur `metric_for_best_model` : `True` si le nom de la métrique ne se termine pas par `"loss"`, `False` sinon.

**Reprise de l'entraînement :**

ignore_data_skip (`bool`, *facultatif*, valeur par défaut `False`) : lors de la reprise de l'entraînement, ignore l'avance rapide dans le jeu de données pour atteindre l'état précédent. Si `True`, l'entraînement démarre depuis le début du jeu de données (reprise plus rapide, mais les résultats ne correspondront pas à l'entraînement interrompu). Si `False`, les données déjà vues sont ignorées (reprise plus lente, mais poursuite exacte).

restore_callback_states_from_checkpoint (`bool`, *facultatif*, valeur par défaut `False`) : Restaure les états des callbacks depuis le point de contrôle lors de la reprise. Si `True`, les callbacks passés au Trainer seront remplacés s'ils existent dans le point de contrôle.

**Reproductibilité :**

full_determinism (`bool`, *facultatif*, valeur par défaut `False`) : Si `True`, [enable_full_determinism()](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.enable_full_determinism) est appelé à la place de [set_seed()](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.set_seed) pour garantir des résultats reproductibles lors de l'entraînement distribué. Important : cela aura un impact négatif sur les performances, il ne faut donc l'utiliser que pour le débogage.

seed (`int`, *facultatif*, valeur par défaut 42) : Graine aléatoire qui sera définie au début de l'entraînement. Pour garantir la reproductibilité entre les exécutions, utilisez la fonction `~Trainer.model_init` pour instancier le modèle s'il possède des paramètres initialisés aléatoirement.

data_seed (`int`, *facultatif*) : Graine aléatoire à utiliser avec les échantillonneurs de données. Si elle n'est pas définie, les générateurs aléatoires pour l'échantillonnage de données utiliseront la même graine que `seed`. Cela permet de garantir la reproductibilité de l'échantillonnage des données, indépendamment de la graine du modèle.

**Configuration matérielle :**

use_cpu (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser le cpu. Si la valeur est False, le dispositif/le backend torch disponible sera utilisé.

**Configuration d'Accelerate :**

accelerator_config (`str`, `dict` ou `AcceleratorConfig`, *facultatif*) : Configuration de l'intégration interne Accelerate. Peut être : - Chemin vers un fichier de configuration JSON : `"accelerator_config.json"` - Dictionnaire contenant les options de configuration - Instance de `AcceleratorConfig` Options principales : - `split_batches` (`bool`, valeur par défaut `False`) : Indique s'il faut diviser les lots entre les appareils. Si `True`, la taille réelle du lot est identique sur tous les appareils (la taille totale doit être divisible par num_processes). Si `False`, chaque appareil reçoit la taille de lot spécifiée. - `dispatch_batches` (`bool`) : Si `True`, seul le processus principal itère sur le dataloader et distribue les lots aux appareils. La valeur par défaut est `True` pour `IterableDataset`, et `False` dans le cas contraire. - `even_batches` (`bool`, valeur par défaut `True`) : Duplique les échantillons depuis le début du jeu de données pour garantir que tous les workers reçoivent des lots de taille égale. - `use_seedable_sampler` (`bool`, valeur par défaut `True`) : Utilise un échantillonneur aléatoire entièrement initialisable par graine pour assurer la reproductibilité. - `use_configured_state` (`bool`, valeur par défaut `False`) : Utilise un `AcceleratorState`/`PartialState` préinitialisé au lieu d'en créer un nouveau. Peut causer des problèmes lors de l'ajustement des hyperparamètres.

parallelism_config (`ParallelismConfig`, *facultatif*) : Configuration du parallélisme pour l'exécution d'entraînement. Nécessite Accelerate `1.10.1`

**Chargeur de données :**

dataloader_drop_last (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut supprimer le dernier lot incomplet (si la longueur du jeu de données n'est pas divisible par la taille du lot) ou non.

dataloader_num_workers (`int`, *facultatif*, valeur par défaut 0) : Nombre de sous-processus à utiliser pour le chargement des données (PyTorch uniquement). 0 signifie que les données seront chargées dans le processus principal.

dataloader_pin_memory (`bool`, *facultatif*, par défaut `True`) : Indique si vous souhaitez épingler la mémoire dans les chargeurs de données ou non. La valeur par défaut est `True`.

dataloader_persistent_workers (`bool`, *facultatif*, valeur par défaut `False`) : Si True, le chargeur de données ne mettra pas fin aux processus de travail après qu'un jeu de données a été consommé une fois. Cela permet de maintenir les instances de Dataset des travailleurs en vie. Cela peut potentiellement accélérer l'entraînement, mais augmentera l'utilisation de la RAM. La valeur par défaut sera `False`.

dataloader_prefetch_factor (`int`, *facultatif*) : Nombre de lots chargés à l'avance par chaque travailleur. 2 signifie qu'il y aura au total 2 * num_workers lots préchargés sur l'ensemble des travailleurs.

dataloader_multiprocessing_context (`str`, *facultatif*) : Méthode de démarrage du multiprocessing à utiliser pour les workers de chargement de données (`"fork"`, `"spawn"` ou `"forkserver"`). Par défaut, la méthode de démarrage par défaut de PyTorch est utilisée, sauf sur MPS avec `dataloader_num_workers > 1`, où la valeur par défaut est `"fork"`. Utilisez `"spawn"` lors du streaming depuis des sources dont les objets ne sont pas sûrs pour le fork (par ex. HDFS via `pyarrow`). Sous `"spawn"`, tout code personnalisé de `collate_fn` ou de jeu de données doit être importable au niveau du module (pas de lambdas/closures).

dataloader_in_order (`bool`, *facultatif*, valeur par défaut `True`) : Si `True`, le chargeur de données fournit les lots dans l'ordre de dispatch des workers. Définissez `False` pour fournir les lots dès qu'ils sont prêts, ce qui peut réduire la latence de fin pour les charges de travail de streaming `IterableDataset`. Nécessite PyTorch >= 2.6.

remove_unused_columns (`bool`, *facultatif*, par défaut `True`) : Indique s'il faut supprimer automatiquement les colonnes non utilisées par la méthode forward du modèle.

label_names (`list[str]`, *facultatif*) : La liste des clés de votre dictionnaire d'entrées qui correspondent aux étiquettes. Par défaut, elle sera la liste des noms d'arguments acceptés par le modèle contenant le mot « label », sauf si le modèle utilisé est l'un des `XxxForQuestionAnswering`, auquel cas elle inclura également les clés `["start_positions", "end_positions"]`. Vous ne devez spécifier `label_names` que si vous utilisez des noms d'étiquettes personnalisés ou si le `forward` de votre modèle consomme plusieurs tenseurs d'étiquettes (par exemple, pour le QA extractif).

train_sampling_strategy (`str`, *facultatif*, valeur par défaut `"random"`) : Le sampler à utiliser pour le dataloader d'entraînement. Les valeurs possibles sont :  - `"random"` : Utilise `RandomSampler` (par défaut). - `"sequential"` : Utilise `SequentialSampler`. - `"group_by_length"` : Utilise `LengthGroupedSampler` pour regrouper les échantillons de longueurs approximativement identiques (afin de minimiser le padding et d'augmenter l'efficacité). - `"batch_rebalance"` : Utilise `BatchRebalanceSampler` pour équilibrer le coût des jetons de padding entre les appareils et les étapes d'accumulation de gradient au sein de chaque lot effectif, réduisant ainsi le gaspillage de padding et la mémoire de pointe par rapport à `"group_by_length"`. Actuellement, seul l'entraînement parallèle de données est pris en charge (le parallélisme de tenseurs n'est pas encore pris en charge).  Remarque : Lors de l'utilisation d'un `IterableDataset`, cet argument est ignoré.

length_column_name (`str`, *facultatif*, valeur par défaut `"length"`) : Nom de la colonne pour les longueurs précalculées. Si la colonne existe, le regroupement par longueur utilisera ces valeurs plutôt que de les calculer au démarrage de l'entraînement. Ignoré sauf si `train_sampling_strategy` est `"group_by_length"`ou `"batch_rebalance"` et que le jeu de données est une instance de `Dataset`.

**DDP (DistributedDataParallel) :**

ddp_find_unused_parameters (`bool`, *facultatif*) : Lors de l'utilisation de l'entraînement distribué, la valeur du drapeau `find_unused_parameters` passée à `DistributedDataParallel`. La valeur par défaut est `False` si le gradient checkpointing est utilisé, `True` sinon.

ddp_bucket_cap_mb (`int`, *facultatif*) : Lors de l'utilisation de l'entraînement distribué, la valeur du drapeau `bucket_cap_mb` transmis à `DistributedDataParallel`.

ddp_broadcast_buffers (`bool`, *facultatif*) : Lors de l'utilisation de l'entraînement distribué, la valeur du drapeau `broadcast_buffers` transmis à `DistributedDataParallel`. Sera par défaut `False` si le gradient checkpointing est utilisé, `True` sinon.

ddp_static_graph (`bool`, *facultatif*) : Lors de l'utilisation de l'entraînement distribué, la valeur du drapeau `static_graph` passée à `DistributedDataParallel`.

ddp_backend (`str`, *facultatif*) : Le backend à utiliser pour l'entraînement distribué. Doit être l'un des suivants : `"nccl"`, `"mpi"`, `"xccl"`, `"gloo"`, `"hccl"`.

ddp_timeout (`int`, *facultatif*, valeur par défaut 1800) : Le délai d'attente pour les appels à `torch.distributed.init_process_group`, utilisé pour éviter les dépassements de délai des sockets GPU lors de l'exécution d'opérations lentes dans des environnements distribués. Veuillez consulter la [documentation PyTorch](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) pour plus d'informations.

**FSDP (Fully Sharded Data Parallel) :**

fsdp (`bool`, *facultatif*, valeur par défaut `None`) : Active PyTorch Fully Sharded Data Parallel (FSDP) pour l'entraînement distribué. Passez `True` pour activer FSDP.

fsdp_config (`str` ou `dict`, *facultatif*) : Paramètres de configuration pour lorsque `fsdp` est activé. Transmettez un chemin vers un fichier de configuration JSON, tel que `fsdp_config.json`, ou un dictionnaire déjà chargé. Clés prises en charge : - version (`int`, *facultatif*, valeur par défaut `2`) : La version de FSDP à utiliser (`2` pour FSDP2, `1` pour le FSDP1 legacy). - reshard_after_forward (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ré-fragmenter les paramètres après le passage avant. Définissez sur `False` pour conserver les paramètres regroupés entre les passages avant et arrière, ce qui évite le re-all-gather et utilise une mémoire de pointe plus élevée. - cpu_offload (`bool`, *facultatif*, valeur par défaut `False`) : Décharge les paramètres et les gradients sur le CPU lorsqu'ils ne sont pas utilisés afin d'économiser la mémoire GPU. - activation_checkpointing (`bool`, *facultatif*, valeur par défaut `False`) : Définissez sur `True` pour réduire la mémoire en recalculant les activations lors du passage arrière. Lors de l'utilisation de FSDP, préférez cette option à l'argument d'entraînement `activation_checkpointing`, qui introduit un all-gather redondant lors du passage arrière. - cpu_ram_efficient_loading (`bool`, *facultatif*, valeur par défaut `False`) : Définissez sur `True` pour charger le point de contrôle pré-entraîné uniquement sur le premier processus. Les autres processus démarrent avec des poids vides et reçoivent les poids par diffusion. - state_dict_type (`str`, *facultatif*, valeur par défaut `"FULL_STATE_DICT"`) : Format du point de contrôle : `"FULL_STATE_DICT"` (fichier unique compatible HF) ou `"SHARDED_STATE_DICT"` (un fichier par rang, plus rapide pour les grands modèles). - auto_wrap_policy (`str`, *facultatif*, valeur par défaut `"TRANSFORMER_BASED_WRAP"`) : Politique d'auto-wrap à utiliser. Choisissez `"TRANSFORMER_BASED_WRAP"`, `"SIZE_BASED_WRAP"` ou `"NO_WRAP"`. - transformer_layer_cls_to_wrap (`list[str]`, *facultatif*) : Noms des classes de couches Transformer (sensibles à la casse) à envelopper, par exemple `LlamaDecoderLayer`. Généralement inutile : la politique d'enveloppement retombe sur `_no_split_modules` du modèle, qui couvre la plupart des modèles transformers. - min_num_params (`int`, *facultatif*, valeur par défaut `0`) : Nombre minimal de paramètres par module pour l'auto-wrapping basé sur la taille (utilisé avec `auto_wrap_policy="SIZE_BASED_WRAP"`). - xla (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser l'entraînement PyTorch/XLA Fully Sharded Data Parallel. Expérimental. - xla_fsdp_settings (`dict`, *facultatif*) : Dictionnaire des paramètres d'enveloppement XLA FSDP. Pour la liste complète des options, consultez la [source XLA FSDP](https://github.com/pytorch/xla/blob/master/torch_xla/distributed/fsdp/xla_fully_sharded_data_parallel.py). - xla_fsdp_grad_ckpt (`bool`, *facultatif*, valeur par défaut `False`) : Définissez sur `True` pour utiliser le gradient checkpointing sur chaque couche enveloppée XLA FSDP imbriquée. Nécessite `xla=True` et une politique d'auto-wrapping (`min_num_params` ou `transformer_layer_cls_to_wrap`).

**DeepSpeed :**

deepspeed (`str` ou `dict`, *facultatif*) : Active l'intégration [DeepSpeed](https://github.com/deepspeedai/DeepSpeed). La valeur est soit : - Le chemin vers le fichier de configuration JSON de DeepSpeed : `"ds_config.json"` - La configuration chargée sous forme de dictionnaire > [!TIP] > Si vous utilisez l'initialisation ZeRO, instanciez votre modèle *après* l'initialisation de `TrainingArguments`, sinon ZeRO ne sera pas appliqué.

**Débogage et profilage (expérimental) :**

debug (`str` ou liste de `DebugOption`, *facultatif*, valeur par défaut `""`) : Active une ou plusieurs fonctionnalités de débogage. Il s'agit d'une fonctionnalité expérimentale. Les options possibles sont : - "underflow_overflow" : détecte les dépassements (overflow) dans les entrées/sorties du modèle et signale les derniers frames ayant conduit à l'événement - "tpu_metrics_debug" : affiche les métriques de débogage sur TPU

skip_memory_metrics (`bool`, *facultatif*, valeur par défaut `True`) : Indique s'il faut ignorer l'ajout des rapports du profil mémoire aux métriques. Cette opération est ignorée par défaut, car elle ralentit la vitesse d'entraînement et d'évaluation.

**Options de script externe (non utilisées par Trainer) :**

do_train (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut lancer l'entraînement ou non. Cet argument n'est pas utilisé directement par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.

do_eval (`bool`, *facultatif*) : Indique s'il faut ou non effectuer une évaluation sur le jeu de validation. Sera défini sur `True` si `eval_strategy` est différent de `"no"`. Cet argument n'est pas utilisé directement par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.

do_predict (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut exécuter les prédictions sur le jeu de test ou non. Cet argument n'est pas utilisé directement par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.

resume_from_checkpoint (`str`, *facultatif*) : Le chemin vers un dossier contenant un point de contrôle valide pour votre modèle. Cet argument n'est pas utilisé directement par [Trainer](/docs/transformers/v5.23.0/fr/main_classes/trainer#transformers.Trainer) ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.

sortish_sampler (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut utiliser un *sortish sampler* ou non. Pour l'instant, cela n'est possible que si les jeux de données sous-jacents sont des *Seq2SeqDataset*, mais cela sera disponible de manière générale dans un proche avenir. Il trie les entrées selon leurs longueurs afin de minimiser la taille du padding, avec un peu d'aléa pour le jeu d'entraînement.

predict_with_generate (`bool`, *facultatif*, par défaut `False`) : Indique s'il faut utiliser generate pour calculer les métriques génératives (ROUGE, BLEU).

generation_max_length (`int`, *facultatif*) : La `max_length` à utiliser lors de chaque boucle d'évaluation lorsque `predict_with_generate=True`. Par défaut, la valeur de `max_length` de la configuration du modèle est utilisée.

generation_num_beams (`int`, *facultatif*) : La valeur de `num_beams` à utiliser lors de chaque boucle d'évaluation lorsque `predict_with_generate=True`. Par défaut, la valeur de `num_beams` de la configuration du modèle est utilisée.

generation_config (`str` ou `Path` ou [GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig), *facultatif*) : Permet de charger un [GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig) à partir de la méthode `from_pretrained`. Il peut s'agir de :  - une chaîne de caractères, l'*identifiant du modèle* d'une configuration de modèle pré-entraîné hébergée dans un dépôt de modèles sur huggingface.co. - un chemin vers un *répertoire* contenant un fichier de configuration enregistré à l'aide de la méthode [save_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig.save_pretrained), par exemple `./my_model_directory/`. - un objet [GenerationConfig](/docs/transformers/v5.23.0/fr/main_classes/text_generation#transformers.GenerationConfig).

Classe de configuration permettant de contrôler tous les aspects de l'entraînement du modèle avec le Trainer. TrainingArguments centralise tous les hyperparamètres, les réglages d'optimisation, les préférences de journalisation et les choix d'infrastructure nécessaires à l'entraînement.

[HfArgumentParser](/docs/transformers/v5.23.0/fr/internal/trainer_utils#transformers.HfArgumentParser) peut convertir 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.

#### to_dict[[transformers.Seq2SeqTrainingArguments.to_dict]]

```python
to_dict()
```

[Source](https://github.com/huggingface/transformers/blob/v5.23.0/src/transformers/training_args_seq2seq.py#L84)

Sérialise cette instance en remplaçant `Enum` par leurs valeurs et `GenerationConfig` par des dictionnaires (pour la prise en charge de la sérialisation JSON). Elle obscurcit les valeurs des jetons en supprimant leur valeur.