Hugging Face's logo

Transformers documentation

Trainer

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Trainer

La classe 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, les GPU AMD et torch.amp pour PyTorch. Trainer s’utilise de pair avec la classe 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 et Seq2SeqTrainingArguments héritent des classes Trainer et TrainingArguments et sont adaptés à l’entraînement de modèles pour des tâches de séquence à séquence, telles que la résumés ou la traduction.

La classe Trainer est optimisée pour les modèles 🤗 Transformers et peut présenter des comportements surprenants 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
  • votre modèle peut calculer la perte si un argument labels est fourni et que cette perte est retournée comme 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 pour indiquer leur nom au Trainer) mais aucun d’entre eux ne doit s’appeler "label"

Trainer

classe transformers.Trainer

< >

( model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, NoneType] = Noneargs: transformers.training_args.TrainingArguments | None = Nonedata_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = Nonetrain_dataset: Dataset | IterableDataset | datasets.Dataset | None = Noneeval_dataset: Dataset | dict[str, Dataset] | datasets.Dataset | None = Noneprocessing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = Nonemodel_init: collections.abc.Callable[..., transformers.modeling_utils.PreTrainedModel] | None = Nonecompute_loss_func: collections.abc.Callable | None = Nonecompute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = Nonecallbacks: list[transformers.trainer_callback.TrainerCallback] | None = Noneoptimizers: tuple = (None, None)optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = Nonepreprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None )

Paramètres

  • model (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 transmis.

    Trainer est optimisé pour fonctionner avec le PreTrainedModel fourni par la bibliothèque. Vous pouvez tout de même utiliser vos propres modèles définis comme torch.nn.Module, à condition qu’ils fonctionnent de la même manière que les modèles 🤗 Transformers.

  • args (TrainingArguments, facultatif) — Les arguments à ajuster pour l'entraînement. Par défaut, une instance basique de TrainingArguments est utilisée, avec output_dir défini sur un répertoire nommé tmp_trainer dans le répertoire courant, si aucune valeur n'est fournie.
  • 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() est utilisé si aucune processing_class n'est fournie, sinon une instance de DataCollatorWithPadding si la processing_class est un extracteur de caractéristiques ou un tokenizer.
  • 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, 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éatisation et que vous entraînez en mode distribué, votre jeu de données itérable doit soit utiliser un générateur d'attribut interne qui est un torch.Generator pour l'aléatisation, identique sur tous les processus (et le Trainer définira manuellement la graine de ce générateur à chaque époque), soit avoir une méthode set_epoch() qui définit 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 d'étapes d'entraînement ne peut pas être déduit.

    Notez que s’il s’agit d’un torch.utils.data.IterableDataset avec une certaine aléatisation et que vous entraînez de manière distribuée, votre jeu de données itérable doit soit utiliser un attribut interne generator qui est un torch.Generator pour l’aléatisation et qui doit être identique sur tous les processus (et le Trainer définira manuellement la graine de ce generator à chaque époque), soit avoir 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 d’étapes 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, 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 fournie, chaque appel à train() partira 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é entier (batch_size * gradient_accumulation_steps) et renvoie la perte. Par exemple, voir la fonction de perte par défaut utilisée par Trainer.
  • compute_metrics (Callable[[EvalPrediction], Dict], facultatif) — La fonction utilisée pour calculer les métriques lors de l'évaluation. Elle doit prendre un EvalPrediction en entrée et renvoyer un dictionnaire associant des chaînes de caractères aux valeurs des métriques. Note Lors du passage de TrainingArgs avec batch_eval_metrics défini à 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 signaler que la fonction doit calculer et renvoyer les statistiques récapitulatives globales plutôt que d'accumuler les statistiques au niveau du lot
  • callbacks (Liste de 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.

    Si vous souhaitez supprimer l’un des callbacks par défaut utilisés, utilisez la méthode 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() et contrôlé par args.
  • optimizer_cls_and_kwargs (tuple[Type[torch.optim.Optimizer], dict[str, Any]], optional) — A tuple containing the optimizer class and keyword arguments to use. Overrides optim and optim_args in args. Incompatible with the optimizers argument.

    Contrairement à optimizers, cet argument évite d’avoir à placer les paramètres du modèle sur les bons appareils avant d’initialiser le Trainer.

  • preprocess_logits_for_metrics (Callable[[torch.Tensor, torch.Tensor], torch.Tensor], facultatif) — Une fonction qui prétraite les logits juste avant de les mettre en cache à chaque étape d'évaluation. Elle doit prendre deux tenseurs en entrée, les logits et les étiquettes, et renvoyer les logits une fois traités comme souhaité. Les modifications apportées par cette fonction seront reflétées dans les prédictions reçues par compute_metrics.

    Notez que les étiquettes (deuxième paramètre) seront None si le jeu de données ne les contient pas.

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.
  • 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érentes 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 SageMaker MP est actif. Peut être réécrit en sous-classant TrainingArguments et en réécrivant 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

< >

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

Paramètres

  • callback (type ou [`~transformers.TrainerCallback`]) — Une classe TrainerCallback ou une instance de TrainerCallback. Dans le premier cas, un membre de cette classe sera instancié.

Ajouter un rappel à la liste actuelle de TrainerCallback.

autocast_smart_context_manager

< >

( cache_enabled: bool | None = True )

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

< >

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

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

compute_loss

< >

( model: Moduleinputs: dictreturn_outputs: bool = Falsenum_items_in_batch: typing.Union[int, torch.Tensor, NoneType] = None )

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, 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 dans le 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.

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 votre propre 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

< >

( )

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

create_accelerator_and_postprocess

< >

( )

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

create_model_card

< >

( language: str | None = Nonelicense: str | None = Nonetags: str | list[str] | None = Nonemodel_name: str | None = Nonefinetuned_from: str | None = Nonetasks: str | list[str] | None = Nonedataset_tags: str | list[str] | None = Nonedataset: str | list[str] | None = Nonedataset_args: str | list[str] | None = None )

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, la licence du modèle pré-entraîné utilisé est appliquée, si le modèle d’origine transmis au Trainer provient d’un dépôt sur le Hub.
  • tags (str ou list[str], facultatif) — Certaines balises à 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 s’agit du nom du dépôt du modèle d’origine transmis à 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

< >

( model = None ) → torch.optim.Optimizer

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

< >

( num_training_steps: int )

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

< >

( num_training_steps: intoptimizer: typing.Optional[torch.optim.Optimizer] = None ) → torch.optim.lr_scheduler.LRScheduler

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.

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

fin

< >

( )

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(), evaluate(), predict(), save_model() et push_to_hub() communiquent tous entre les processus et échoueront une fois le groupe supprimé.

Exemple :

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

evaluate

< >

( eval_dataset: typing.Union[torch.utils.data.Dataset, dict[str, torch.utils.data.Dataset], NoneType] = Noneignore_keys: list[str] | None = Nonemetric_key_prefix: str = 'eval' )

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, les colonnes non acceptées par la model.forward() méthode 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.

    If you pass a dictionary with names of datasets as keys and datasets as values, evaluate will run separate evaluations on each dataset. This can be useful to monitor how training affects other datasets or simply to get a more fine-grained evaluation. When used with load_best_model_at_end, make sure metric_for_best_model references exactly one of the datasets. If you, for example, pass in {"data1": data1, "data2": data2} for two datasets data1 and data2, you could specify metric_for_best_model="eval_data1_loss" for using the loss on data1 and metric_for_best_model="eval_data2_loss" for the loss on 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 des clés des métriques. Par exemple, la métrique « bleu » sera nommée « eval_bleu » si le préfixe est « eval » (par défaut)

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

Le script d’appel sera responsable de la fourniture d’une méthode pour calculer les métriques, car elles 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

< >

( dataloader: DataLoaderdescription: strprediction_loss_only: bool | None = Noneignore_keys: list[str] | None = Nonemetric_key_prefix: str = 'eval' )

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

Fonctionne avec ou sans étiquettes.

floating_point_ops

< >

( inputs: dict ) → int

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, 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 créez une sous-classe et écrasez cette méthode.

get_batch_samples

< >

( epoch_iterator: Iteratornum_batches: intdevice: device )

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

< >

( )

Obtenir la taille du parallélisme de contexte

get_decay_parameter_names

< >

( model: Module )

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

< >

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

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, 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

< >

( )

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

get_num_trainable_parameters

< >

( )

Obtenir le nombre de paramètres entraînables.

get_optimizer_cls_and_kwargs

< >

( args: TrainingArgumentsmodel: transformers.modeling_utils.PreTrainedModel | None = None )

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 la classe d'optimiseur et les paramètres de l'optimiseur en fonction des arguments d'entraînement.

get_optimizer_group

< >

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

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

< >

( )

Obtenir la taille du parallélisme de séquence

get_test_dataloader

< >

( test_dataset: Dataset )

Paramètres

  • test_dataset (torch.utils.data.Dataset, facultatif) — Le jeu de données de test à utiliser. S'il s'agit d'un 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

< >

( args: TrainingArguments )

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

< >

( )

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

get_train_dataloader

< >

( )

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

< >

( hp_space: collections.abc.Callable[['optuna.Trial'], dict[str, float]] | None = Nonecompute_objective: collections.abc.Callable[[dict[str, float]], float] | None = Nonen_trials: int = 20direction: str | list[str] = 'minimize'backend: str | transformers.trainer_utils.HPSearchBackend | None = Nonehp_name: collections.abc.Callable[['optuna.Trial'], str] | None = None**kwargs ) → [trainer_utils.BestRun or list[trainer_utils.BestRun]]

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. Par défaut, default_compute_objective() est utilisé.
  • 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") — En cas d’optimisation mono-objectif, direction est un 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 plusieurs métriques. En cas d’optimisation multi-objectifs, direction est une list[str], pouvant contenir 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 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 de mots-clés supplémentaires pour chaque backend :

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 le backend Ray.

Lancez une recherche d'hyperparamètres à l'aide de optuna ou 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, 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 : 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 et surcharger la méthode create_optimizer_and_scheduler() pour un optimiseur/planificateur personnalisé.

init_hf_repo

< >

( token: str | None = Noneprivate: bool | None = None )

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. N'a aucun 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

< >

( )

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

< >

( )

Que ce processus soit ou non le processus principal global (lors de l'entraînement distribué sur plusieurs machines, cela ne sera True que pour un seul processus).

log

< >

( logs: dictstart_time: float | None = None )

Paramètres

  • logs (dict[str, float]) — Les valeurs à consigner.
  • start_time (Optional[float]) — 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

< >

( splitmetrics )

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 : dict des 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 RAM générale ou de la mémoire gpu0.
  • *_alloc_delta - est 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 et vous savez combien de mémoire était nécessaire pour terminer 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 GPU peuvent alors utiliser une quantité différente de mémoire gpu. Ce n'est pas non plus la même chose sous DataParallel, où le 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 GPU 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 (swappée), de sorte que les rapports peuvent être 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 peut manquer une partie de la mémoire de pointe 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, elle 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 du processus.

L’allocation GPU et le rapport de la mémoire de pointe sont effectués avec 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 aucune mémoire allouée en dehors de PyTorch. Par exemple, le tout 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.

Les appels à evaluation peuvent survenir pendant train, nous ne pouvons donc pas gérer les invocations imbriquées car torch.cuda.max_memory_allocated est un compteur unique. Ainsi, s’il est réinitialisé par un appel d’évaluation imbriqué, le traceur de train rapportera des informations incorrectes. Si ce problème PyTorch 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 son utilisation mémoire ainsi que de celle du premier.

Cela signifie également que si un autre outil utilisé avec le Trainer appelle torch.cuda.reset_peak_memory_stats, les statistiques de mémoire GPU de pointe pourraient être invalides. Et le 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 lui-même.

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

metrics_format

< >

( metrics: dict ) → metrics (dict[str, float])

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

< >

( dataloader: DataLoader )

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

pop_callback

< >

( callback: type[transformers.trainer_callback.TrainerCallback] | transformers.trainer_callback.TrainerCallback ) → TrainerCallback

Paramètres

  • callback (type ou [`~transformers.TrainerCallback`]) — Une classe TrainerCallback ou une instance de TrainerCallback. Dans le premier cas, retire le premier membre de cette classe trouvé dans la liste des callbacks.

Retourne

TrainerCallback

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

Supprime un rappel de la liste actuelle de TrainerCallback et le renvoie.

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

predict

< >

( test_dataset: Datasetignore_keys: list[str] | None = Nonemetric_key_prefix: str = 'test' )

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 des clés de 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

< >

( model: Moduleinputs: dictprediction_loss_only: boolignore_keys: list[str] | None = None ) → tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]

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

< >

( commit_message: str | None = 'End of training'blocking: bool = Truetoken: str | None = Nonerevision: str | None = Noneprivate: bool | None = None**kwargs )

Paramètres

  • commit_message (str, facultatif, par défaut "End of training") — Message à committer lors de la poussée.
  • blocking (bool, facultatif, par défaut True) — Indique si la fonction doit ne renvoyer que lorsque le git push est terminé.
  • token (str, facultatif, par défaut None) — Jeton avec permission d’écriture pour écraser les arguments originaux du Trainer.
  • revision (str, facultatif) — La révision git à partir de laquelle effectuer le commit. Par défaut, il s'agit de la tête de la branche « main ».
  • private (bool, facultatif) — Indique s'il faut rendre le dépôt privé lors de sa création. La valeur par défaut est args.hub_private_repo. N'a aucun effet si le dépôt existe déjà.
  • kwargs (dict[str, Any], facultatif) — Arguments supplémentaires passés à create_model_card().

Téléchargez self.model et self.processing_class sur le hub de modèles 🤗 dans le dépôt self.args.hub_model_id.

remove_callback

< >

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

Paramètres

  • callback (type ou [`~transformers.TrainerCallback`]) — Une classe TrainerCallback ou une instance de 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.

save_metrics

< >

( splitmetricscombined = True )

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, 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(). La seule différence est que des chiffres bruts non formatés sont enregistrés dans la méthode actuelle.

save_model

< >

( output_dir: str | None = None_internal_call: bool = False )

Enregistrera le modèle, ce qui vous permettra de le recharger à l'aide de from_pretrained().

N'enregistrera que depuis le processus principal.

save_state

< >

( )

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

< >

( args: TrainingArgumentsdataloader: DataLoader )

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

< >

( )

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

train

< >

( resume_from_checkpoint: str | bool | None = Nonetrial: optuna.Trial | dict[str, Any] | None = Noneignore_keys_for_eval: list[str] | None = None ) → TrainOutput

Paramètres

  • resume_from_checkpoint (str ou bool, facultatif) — Si c'est une str, chemin local d'un point de contrôle enregistré par une instance précédente de Trainer. Si c'est un bool et vaut True, charge le dernier point de contrôle dans args.output_dir enregistré par une instance précédente de Trainer. S'il est présent, l'entraînement reprendra à partir des états du modèle/optimiseur/planificateur chargés ici.
  • trial (optuna.Trial ou dict[str, Any], facultatif) — L’exécution de l’essai ou le dictionnaire d’hyperparamètres pour la recherche d’hyperparamètres.
  • ignore_keys_for_eval (list[str], facultatif) — Une liste de clés dans la sortie de votre modèle (s’il s’agit d’un dictionnaire) qui doivent être ignorées lors de la collecte des prédictions pour l’évaluation pendant l’entraînement.

Retourne

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

< >

( model: Moduleinputs: dictnum_items_in_batch: typing.Union[int, torch.Tensor, NoneType] = None ) → torch.Tensor

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

classe transformers.Seq2SeqTrainer

< >

( model: typing.Union[ForwardRef('PreTrainedModel'), torch.nn.Module, NoneType] = Noneargs: typing.Optional[ForwardRef('TrainingArguments')] = Nonedata_collator: typing.Optional[ForwardRef('DataCollator')] = Nonetrain_dataset: typing.Union[torch.utils.data.Dataset, ForwardRef('IterableDataset'), ForwardRef('datasets.Dataset'), NoneType] = Noneeval_dataset: typing.Union[torch.utils.data.Dataset, dict[str, torch.utils.data.Dataset], NoneType] = Noneprocessing_class: typing.Union[ForwardRef('PreTrainedTokenizerBase'), ForwardRef('BaseImageProcessor'), ForwardRef('FeatureExtractionMixin'), ForwardRef('ProcessorMixin'), NoneType] = Nonemodel_init: collections.abc.Callable[[], 'PreTrainedModel'] | None = Nonecompute_loss_func: collections.abc.Callable | None = Nonecompute_metrics: collections.abc.Callable[['EvalPrediction'], dict] | None = Nonecallbacks: list['TrainerCallback'] | None = Noneoptimizers: tuple = (None, None)preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None )

evaluate

< >

( eval_dataset: typing.Optional[torch.utils.data.Dataset] = Noneignore_keys: list[str] | None = Nonemetric_key_prefix: str = 'eval'**gen_kwargs )

Paramètres

  • eval_dataset (Dataset, facultatif) — Transmettez un jeu de données si vous souhaitez remplacer self.eval_dataset. S'il s'agit d'un 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") — Préfixe facultatif à utiliser comme préfixe des clés des 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 — Arguments supplémentaires spécifiques à generate.

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

Le script d’appel sera responsable de la fourniture d’une méthode pour calculer les métriques, car elles 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

< >

( test_dataset: Datasetignore_keys: list[str] | None = Nonemetric_key_prefix: str = 'test'**gen_kwargs )

Paramètres

  • test_dataset (Dataset) — Jeu de données sur lequel exécuter les prédictions. S'il s'agit d'un 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") — Préfixe facultatif à utiliser comme préfixe des clés des 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 — Arguments supplémentaires 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 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).

TrainingArguments

classe transformers.TrainingArguments

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 5e-05lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool = Falsefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool | None = Nonegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 500logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: typing.Any | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1 )

Paramètres

  • output_dir (str, facultatif, 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 ce n'est pas un entier, la partie décimale sera exécutée en pourcentage de la dernière époque avant l'arrêt de l'entraînement).
  • max_steps (int, facultatif, valeur par défaut -1) — Remplace num_train_epochs. Si défini sur un nombre positif, 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 flux), 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, facultatif, défaut : "linear") — Le type de planificateur de taux d'apprentissage à utiliser. Voir SchedulerType pour toutes les valeurs possibles. Choix courants :
  • lr_scheduler_kwargs (dict ou str, facultatif, 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 dans la phase initiale. Peut être :
    • Un entier : nombre exact d'étapes de mise en route
    • Un nombre à virgule flottante dans l'intervalle [0, 1) : interprété comme le ratio des étapes d'entraînement totales

Optimiseur

  • optim (str ou training_args.OptimizerNames, facultatif, 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 d’AdamW par 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 epsilon pour la stabilité numérique dans les optimiseurs basés sur Adam. Empêche la division par zéro dans le 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. Actuellement utilisé pour l'algorithme GaLore et l'algorithme APOLLO. Voir implémentation de GaLore et implémentation de 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 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 de rétropropagation/mise à jour. Simule des tailles de lot plus grandes sans mémoire supplémentaire. Taille de lot effective = per_device_train_batch_size × num_devices × gradient_accumulation_steps.

    Lors de l'utilisation de l'accumulation de gradients, un « pas » est compté comme un pas 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, 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 passe arrière, avant l'étape de l'optimiseur. Empêche l'explosion des gradients en réduisant les gradients 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. Zéro signifie aucun lissage. Plage typique : de 0.0 à 0.1.

Entraînement en précision mixte

  • bf16 (bool, facultatif, 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, par défaut False) — Active l’entraînement en précision mixte float16 (FP16). Envisagez d’utiliser BF16 à la place si votre matériel le prend en charge.
  • bf16_full_eval (bool, facultatif, valeur par défaut False) — Utilise 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) — Utilise 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 (au lieu des 23 bits de FP32), offrant jusqu’à 8 fois plus de vitesse avec une perte de précision négligeable. La valeur par défaut dépend de la version de PyTorch. Voir la documentation 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, par défaut None) — Arguments nominaux transmis à activation_checkpointing_enable(). every_n_layers effectue le checkpointing uniquement de chaque n-ième couche décodeur au lieu de toutes ; 1 correspond au comportement habituel tout-ou-rien, et des valeurs plus élevées rendent 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 un gain de vitesse de 20 à 50 % sans 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(). Si 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).

Kernels

  • use_liger_kernel (bool, facultatif, valeur par défaut False) — Active les optimisations 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, utilise la configuration par défaut.

Optimisations supplémentaires

  • use_cache (bool, facultatif, valeur 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 pour le fine-tuning par instructions. Consultez le paper original et le code original. Prend en charge les PreTrainedModel de transformers ainsi que 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 de pointe de la VRAM, au prix d’une performance environ 10 % plus lente.
  • 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, facultatif, défaut : "steps") — 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, par défaut 500) — Nombre d'étapes de mise à jour entre deux journaux si logging_strategy="steps". Doit être un entier ou un nombre décimal 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) — Lors d’une formation distribuée multi-nœuds, indique s’il faut journaliser à l’aide de 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) — Filtre 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, 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, 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, par défaut "none") — La liste des intégrations vers lesquelles envoyer 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 envoyer les rapports à toutes les intégrations installées, et "none" pour ne pas utiliser d'intégration.
  • run_name (str, facultatif) — Un descripteur pour l'exécution. Utilisé généralement pour la journalisation trackio, wandb, mlflow, comet et swanlab.
  • project (str, facultatif, par défaut "huggingface") — Le nom du projet à utiliser pour la journalisation. Actuellement, utilisé uniquement par Trackio.
  • trackio_space_id (str ou None, facultatif, par défaut None) — L’identifiant de l’espace Hugging Face à utiliser pour la journalisation en direct avec Trackio via un espace basé sur Gradio. Il doit s’agir d’un nom d’espace complet comme 'username/reponame' ou 'orgname/reponame', ou simplement de 'reponame' (l’espace est alors créé dans l’espace de noms de l’utilisateur actuellement connecté). Si la valeur est None, les métriques sont journalisées uniquement dans un répertoire local (aucun espace sur le Hub). Cet espace Gradio dispose d’un accès en 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, par défaut None) — Identifiant de Bucket Hugging Face facultatif pour Trackio. S'il n'est pas défini, Trackio en dérive un. Utilisé en conjonction 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, valeur 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. Il doit s’agir d’un nom d’espace complet comme 'username/reponame' ou 'orgname/reponame', ou simplement de 'reponame' (l’espace est créé dans l’espace de noms de l’utilisateur actuellement connecté). Si la valeur est False, aucun espace statique ne sera créé. Si la valeur est None et que le modèle est poussé sur le Hub, un espace statique sera créé avec un nom par défaut et un lien vers celui-ci sera ajouté à la carte du modèle. L’espace sera public, sauf si vous définissez hub_private_repo=True ou si la valeur par défaut de votre organisation est de créer des espaces privés.

Évaluation

  • eval_strategy (str ou IntervalStrategy, facultatif, défaut : "no") — Quand exécuter 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 le 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) — 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 exécuter récursivement la collecte d'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 retournent pas uniquement des tenseurs, et PyTorch la décourage activement. Cela 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 à accumuler pour les tenseurs de sortie avant de déplacer les résultats vers le CPU. Si non défini, l'ensemble des prédictions est accumulé sur l'accélérateur de l'appareil avant d'être déplacé vers le CPU (plus rapide mais nécessite plus de mémoire).

Calcul des métriques

  • include_for_metrics (list[str], facultatif, défaut []) — Inclure des données supplémentaires dans la compute_metrics fonction si nécessaire pour le calcul des métriques. Options possibles à ajouter à la include_for_metrics liste :
    • "inputs" : Données d’entrée transmises au modèle, destinées au calcul des métriques dépendantes des entrées.
    • "loss" : Valeurs de perte calculées lors de l'évaluation, destinées au calcul de métriques dépendantes 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 passer une fonction compute_metrics qui prend un argument booléen compute_result ; lorsqu’on lui passe True, elle déclenchera les 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’avec from_pretrained si cette option est définie sur True.
  • save_strategy (str ou SaveStrategy, facultatif, défaut : "steps") — Stratégie d'enregistrement 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" : 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 valeur de best_metric est atteinte.
  • save_steps (int ou float, facultatif, par défaut 500) — Nombre d'étapes de mise à jour avant l'enregistrement de deux points de contrôle si save_strategy="steps". Doit être un entier ou un nombre flottant compris dans l'intervalle [0,1). S'il est inférieur à 1, il sera interprété comme le 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 ≥ au temps de la plus longue itération + au temps de sauvegarde du checkpoint.

Intégration avec Hugging Face Hub

  • push_to_hub (bool, facultatif, par défaut False) — Indique s'il faut 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() déclenche également un push.
  • hub_token (str, facultatif) — Le jeton à utiliser pour pousser le modèle sur le Hub. Par défaut, il s’agit du jeton du dossier de cache obtenu avec hf auth login.
  • 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 défaut de l’organisation est le mode 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 l’espace 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, 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 le dernier point de contrôle dans le sous-dossier "last-checkpoint" pour une reprise facile
    • "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 du meilleur modèle

  • 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). Lorsque `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 le saut 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 checkpoint lors de la reprise. Si True, les callbacks passés au Trainer seront remplacés s’ils existent dans le checkpoint.

Reproductibilité

  • full_determinism (bool, facultatif, valeur par défaut False) — Si True, enable_full_determinism() est appelé à la place de 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, 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, par défaut False) — Indique s'il faut utiliser le CPU. Si défini sur False, nous utiliserons le dispositif/le backend torch disponible.

Configuration d'Accelerate

  • accelerator_config (str, dict, ou AcceleratorConfig, facultatif) — Configuration de l'intégration interne d'Accelerate. Peut être :
    • Chemin vers le fichier de configuration JSON : "accelerator_config.json"
    • Dictionnaire avec les options de configuration
    • instance de AcceleratorConfig Options principales :
    • split_batches (bool, 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 (le total 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, False sinon.
    • even_batches (bool, par défaut True) : Duplique des échantillons depuis le début du jeu de données pour garantir que tous les travailleurs reçoivent des lots de taille égale.
    • use_seedable_sampler (bool, par défaut True) : Utilise un échantillonneur aléatoire entièrement seedable pour la reproductibilité.
    • use_configured_state (bool, par défaut False) : Utilise un état 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

Dataloader

  • 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, valeur 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 Dataset des travailleurs en vie. 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 worker. 2 signifie qu’il y aura au total 2 * num_workers lots préchargés sur l’ensemble des workers.
  • dataloader_multiprocessing_context (str, facultatif) — Méthode de démarrage du multiprocessing à utiliser pour les workers de chargement des 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 produit les lots dans l'ordre où les workers ont été dispatchés. Définissez False pour produire les lots dès qu'ils sont prêts, ce qui peut réduire la latence de fin pour les workloads de streaming IterableDataset. Nécessite PyTorch >= 2.6.
  • remove_unused_columns (bool, facultatif, valeur 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 la QA extractive).
  • train_sampling_strategy (str, facultatif, 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 longueur approximativement identique (afin de minimiser le bourrage et d’être plus efficace).
    • "batch_rebalance" : Utilise BatchRebalanceSampler pour équilibrer le coût des jetons de bourrage entre les appareils et les étapes d'accumulation de gradient au sein de chaque lot effectif, réduisant ainsi le gaspillage de bourrage 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, par défaut "length") — Nom de la colonne contenant 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 transmis à 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 passée à 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 transmis à 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) — 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 exécutions distribuées. Veuillez consulter la documentation PyTorch pour plus d’informations.

FSDP (Fully Sharded Data Parallel)

  • fsdp (bool, facultatif, par défaut None) — Active PyTorch Fully Sharded Data Parallel (FSDP) pour l’entraînement distribué. Passez True pour activer FSDP.
  • fsdp_config (str or dict, optional) — Configuration settings for when fsdp is enabled. Pass a path to a JSON config file, such as fsdp_config.json, or an already-loaded dict.

    Clés prises en charge :

    • version (int, facultatif, par défaut 2) : La version de FSDP à utiliser (2 pour FSDP2, 1 pour le FSDP1 legacy).
    • reshard_after_forward (bool, facultatif, par défaut True) : Indique s'il faut re-resshader les paramètres après le passage avant. Définissez-le sur False pour conserver les paramètres regroupés entre les passages avant et arrière, ce qui évite le re-all-gather et entraîne une consommation mémoire de pointe plus élevée.
    • cpu_offload (bool, facultatif, 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, par défaut False) : À définir sur True pour réduire la mémoire en recalculant les activations lors de la passe arrière. Lors de l'utilisation de FSDP, privilégiez cette option par rapport à l'argument d'entraînement activation_checkpointing, qui introduit un all-gather redondant lors de la passe arrière.
    • cpu_ram_efficient_loading (bool, facultatif, par défaut False) : À définir 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, par défaut "FULL_STATE_DICT") : Format de 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, 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, 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’emballage XLA FSDP. Pour la liste complète des options, voir le code source de XLA FSDP.
    • xla_fsdp_grad_ckpt (bool, facultatif, valeur par défaut False) : À définir sur True pour utiliser le gradient checkpointing sur chaque couche imbriquée enveloppée par XLA FSDP. Nécessite xla=True et une politique d’enveloppement automatique (min_num_params ou transformer_layer_cls_to_wrap).

DeepSpeed

  • deepspeed (str ou dict, facultatif) — Active l'intégration DeepSpeed. La valeur est soit :
    • Chemin vers le fichier de configuration JSON de DeepSpeed : "ds_config.json"
    • Configuration chargée en tant que dictionnaire

      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, 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 dans les entrées/sorties du modèle et signale les derniers cadres 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 profilage 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.

Drapeaux de script externe (non utilisés par Trainer)

  • do_train (bool, facultatif, par défaut False) — Indique s'il faut exécuter l'entraînement ou non. Cet argument n'est pas utilisé directement par Trainer ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.
  • do_eval (bool, facultatif) — Indique s'il faut ou non exécuter une évaluation sur le jeu de validation. Sera défini à True si eval_strategy est différent de "no". Cet argument n'est pas utilisé directement par Trainer, il est destiné à être utilisé par vos scripts d'entraînement/évaluation.
  • do_predict (bool, facultatif, par défaut False) — Indique s'il faut exécuter des prédictions sur le jeu de test ou non. Cet argument n'est pas utilisé directement par 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, 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 peut convertir cette classe en arguments argparse qui peuvent être spécifiés sur la ligne de commande.

get_process_log_level

< >

( )

Retourne le niveau de journalisation à utiliser en fonction de savoir si ce processus est le processus principal du nœud 0, le processus principal d'un nœud non-0, 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

< >

( num_training_steps: int )

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

main_process_first

< >

( local = Truedesc = 'work' )

Paramètres

  • local (bool, facultatif, 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 correspond au comportement par défaut.
  • desc (str, facultatif, par défaut "work") — 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 tâche sur le processus principal tout en bloquant les répliques, puis de les libérer une fois la tâche terminée.

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

set_dataloader

< >

( train_batch_size: int = 8eval_batch_size: int = 8drop_last: bool = Falsenum_workers: int = 0pin_memory: bool = Truepersistent_workers: bool = Falseprefetch_factor: int | None = Nonemultiprocessing_context: str | None = Nonein_order: bool = Trueauto_find_batch_size: bool = Falseignore_data_skip: bool = Falsesampler_seed: int | None = None )

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, valeur 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. 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 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. 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).
  • in_order (bool, facultatif, par défaut True) — Si True, le chargeur de données fournit les lots dans l’ordre où les workers ont été dispatchés. 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 ou non 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 défini à True, l’entraînement démarrera plus rapidement (car cette étape de saut peut être longue), mais ne produira pas les mêmes résultats que ceux que l’entraînement interrompu aurait obtenus.
  • 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 :

>>> 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

< >

( strategy: str | transformers.trainer_utils.IntervalStrategy = 'no'steps: int = 500batch_size: int = 8accumulation_steps: int | None = Nonedelay: float | None = Noneloss_only: bool = False )

Paramètres

  • strategy (str ou IntervalStrategy, facultatif, 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éfinit self.do_eval sur True.

  • steps (int, facultatif, 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 (cœur GPU/TPU/CPU…) utilisée pour l'évaluation.
  • accumulation_steps (int, facultatif) — Nombre d’étapes de prédiction à accumuler pour les tenseurs de sortie, avant de déplacer les résultats vers le CPU. Si non défini, l’ensemble des prédictions est accumulé sur GPU/TPU avant d’être déplacé 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 :

>>> from transformers import TrainingArguments

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

set_logging

< >

( strategy: str | transformers.trainer_utils.IntervalStrategy = 'steps'steps: int = 500report_to: str | list[str] = 'none'level: str = 'passive'first_step: bool = Falsenan_inf_filter: bool = Falseon_each_node: bool = Falsereplica_level: str = 'passive' )

Paramètres

  • strategy (str ou IntervalStrategy, facultatif, 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.
  • steps (int, facultatif, par défaut 500) — Nombre d'étapes de mise à jour entre deux journaux si strategy="steps".
  • level (str, facultatif, 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, par défaut "none") — La liste des intégrations vers lesquelles envoyer 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 envoyer les rapports à toutes les intégrations installées, et "none" pour ne pas utiliser d'intégration.
  • first_step (bool, facultatif, par défaut False) — Indique s'il faut journaliser et évaluer le premier global_step ou non.
  • nan_inf_filter (bool, facultatif, par défaut True) — Indique s'il faut filtrer les pertes nan et inf pour la journalisation. Si défini sur 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 l'enregistrement des valeurs de perte ; il ne modifie pas la façon dont le gradient est calculé ou appliqué au modèle.

  • on_each_node (bool, facultatif, par défaut True) — Lors d'une formation distribuée 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, 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 :

>>> from transformers import TrainingArguments

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

set_lr_scheduler

< >

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

Paramètres

  • name (str ou SchedulerType, facultatif, par défaut "linear") — Le type de planificateur à utiliser. Consultez la documentation de 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 d'arrêter l'entraînement).
  • max_steps (int, facultatif, valeur par défaut -1) — Si défini sur un nombre positif, 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 flux), car le nombre total d'étapes ne peut alors pas être inféré 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). Si inférieur à 1, 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 :

>>> 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

< >

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

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, par défaut 5e-5) — Le taux d'apprentissage initial.
  • 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.
  • beta1 (float, facultatif, valeur par défaut 0.9) — Le hyperparamètre beta1 pour l’optimiseur adam ou ses variantes.
  • beta2 (float, facultatif, valeur par défaut 0.999) — Le hyperparamètre beta2 pour l’optimiseur adam ou ses variantes.
  • epsilon (float, facultatif, valeur par défaut 1e-8) — Le 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 :

>>> 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

< >

( model_id: strstrategy: str | transformers.trainer_utils.HubStrategy = 'every_save'token: str | None = Noneprivate_repo: bool | None = Nonealways_push: bool = Falserevision: str | None = None )

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) et un brouillon de carte de modèle lorsque la méthode 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) 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) — Le 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, par défaut False) — Indique si le dépôt doit être privé. Si None (par défaut), le dépôt sera public sauf si le 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 le 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() déclenche également un push.

Exemple :

>>> 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

< >

( strategy: str | transformers.trainer_utils.IntervalStrategy = 'steps'steps: int = 500total_limit: int | None = Noneon_each_node: bool = False )

Paramètres

  • strategy (str ou IntervalStrategy, facultatif, défaut : "steps") — 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" : l'enregistrement est effectué à la fin de chaque époque.
    • "steps" : l'enregistrement est effectué toutes les save_steps.
  • steps (int, facultatif, par défaut 500) — Nombre d'étapes de mise à jour avant 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, 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.

    Cela ne doit pas être activé lorsque les différents nœuds utilisent le même stockage, car les fichiers seront enregistrés avec les mêmes noms pour chaque nœud.

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

Exemple :

>>> from transformers import TrainingArguments

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

set_testing

< >

( batch_size: int = 8loss_only: bool = False )

Paramètres

  • batch_size (int facultatif, par défaut 8) — La taille du lot par appareil (cœur GPU/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 :

>>> from transformers import TrainingArguments

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

set_training

< >

( learning_rate: float = 5e-05batch_size: int = 8weight_decay: float = 0num_epochs: float = 3max_steps: int = -1gradient_accumulation_steps: int = 1seed: int = 42activation_checkpointing: bool = Falsegradient_checkpointing: bool | None = None )

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 (cœur GPU/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 ce n'est pas un entier, la partie décimale sera exécutée en pourcentage de la dernière époque avant l'arrêt de l'entraînement).
  • max_steps (int, facultatif, valeur par défaut -1) — Si défini sur un nombre positif, 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 flux), car le nombre total d'étapes ne peut alors pas être inféré 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 lesquelles 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 un passage arrière. 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, 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 l’activation checkpointing 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 :

>>> 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

< >

( )

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

< >

( )

Sérialise cette instance en chaîne JSON.

to_sanitized_dict

< >

( )

Sérialisation assainie à utiliser avec les hparams de TensorBoard

Seq2SeqTrainingArguments

classe transformers.Seq2SeqTrainingArguments

< >

( output_dir: str | None = Noneper_device_train_batch_size: int = 8num_train_epochs: float = 3.0max_steps: int = -1learning_rate: float = 5e-05lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear'lr_scheduler_kwargs: dict | str | None = Nonewarmup_steps: float = 0optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused'optim_args: str | None = Noneweight_decay: float = 0.0adam_beta1: float = 0.9adam_beta2: float = 0.999adam_epsilon: float = 1e-08optim_target_modules: None | str | list[str] = Nonegradient_accumulation_steps: int = 1average_tokens_across_devices: bool = Truemax_grad_norm: float = 1.0label_smoothing_factor: float = 0.0bf16: bool = Falsefp16: bool = Falsebf16_full_eval: bool = Falsefp16_full_eval: bool = Falsetf32: bool | None = Noneactivation_checkpointing: bool | None = Noneactivation_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonegradient_checkpointing: bool | None = Nonegradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = Nonetorch_compile: bool = Falsetorch_compile_backend: str | None = Nonetorch_compile_mode: str | None = Noneuse_liger_kernel: bool = Falseliger_kernel_config: dict[str, bool] | None = Noneuse_cache: bool = Falseneftune_noise_alpha: float | None = Nonetorch_empty_cache_steps: int | None = Noneauto_find_batch_size: bool = Falselogging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps'logging_steps: float = 500logging_first_step: bool = Falselog_on_each_node: bool = Truelogging_nan_inf_filter: bool = Trueinclude_num_input_tokens_seen: str | bool = 'no'log_level: str = 'passive'log_level_replica: str = 'warning'disable_tqdm: bool | None = Nonereport_to: None | str | list[str] = 'none'run_name: str | None = Noneproject: str = 'huggingface'trackio_space_id: str | None = Nonetrackio_bucket_id: str | None = Nonetrackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = Noneeval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no'eval_steps: float | None = Noneeval_delay: float = 0per_device_eval_batch_size: int = 8prediction_loss_only: bool = Falseeval_on_start: bool = Falseeval_do_concat_batches: bool = Trueeval_use_gather_object: bool = Falseeval_accumulation_steps: int | None = Noneinclude_for_metrics: list = <factory>batch_eval_metrics: bool = Falsesave_only_model: bool = Falsesave_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps'save_steps: float = 500save_on_each_node: bool = Falsesave_total_limit: int | None = Noneenable_jit_checkpoint: bool = Falsepush_to_hub: bool = Falsehub_token: str | None = Nonehub_private_repo: bool | None = Nonehub_model_id: str | None = Nonehub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save'hub_always_push: bool = Falsehub_revision: str | None = Noneload_best_model_at_end: bool = Falsemetric_for_best_model: str | None = Nonegreater_is_better: bool | None = Noneignore_data_skip: bool = Falserestore_callback_states_from_checkpoint: bool = Falsefull_determinism: bool = Falseseed: int = 42data_seed: int | None = Noneuse_cpu: bool = Falseaccelerator_config: dict | str | None = Noneparallelism_config: typing.Any | None = Nonedataloader_drop_last: bool = Falsedataloader_num_workers: int = 0dataloader_pin_memory: bool = Truedataloader_persistent_workers: bool = Falsedataloader_prefetch_factor: int | None = Nonedataloader_multiprocessing_context: str | None = Nonedataloader_in_order: bool = Trueremove_unused_columns: bool = Truelabel_names: list[str] | None = Nonetrain_sampling_strategy: str = 'random'length_column_name: str = 'length'ddp_find_unused_parameters: bool | None = Noneddp_bucket_cap_mb: int | None = Noneddp_broadcast_buffers: bool | None = Noneddp_static_graph: bool | None = Noneddp_backend: str | None = Noneddp_timeout: int = 1800fsdp: str | None = Nonefsdp_config: dict[str, typing.Any] | str | None = Nonedeepspeed: dict | str | None = Nonedebug: str | list[transformers.debug_utils.DebugOption] = ''skip_memory_metrics: bool = Truedo_train: bool = Falsedo_eval: bool = Falsedo_predict: bool = Falseresume_from_checkpoint: str | None = Nonelocal_rank: int = -1sortish_sampler: bool = Falsepredict_with_generate: bool = Falsegeneration_max_length: int | None = Nonegeneration_num_beams: int | None = Nonegeneration_config: str | pathlib.Path | transformers.generation.configuration_utils.GenerationConfig | None = None )

Paramètres

  • output_dir (str, facultatif, 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 ce n'est pas un entier, la partie décimale sera exécutée en pourcentage de la dernière époque avant l'arrêt de l'entraînement).
  • max_steps (int, facultatif, valeur par défaut -1) — Remplace num_train_epochs. Si défini sur un nombre positif, 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 flux), 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, facultatif, défaut : "linear") — Le type de planificateur de taux d'apprentissage à utiliser. Voir SchedulerType pour toutes les valeurs possibles. Choix courants :
  • lr_scheduler_kwargs (dict ou str, facultatif, 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 dans la phase initiale. Peut être :
    • Un entier : nombre exact d'étapes de mise en route
    • Un nombre à virgule flottante dans l'intervalle [0, 1) : interprété comme le ratio des étapes d'entraînement totales

Optimiseur

  • optim (str ou training_args.OptimizerNames, facultatif, 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 d’AdamW par 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 epsilon pour la stabilité numérique dans les optimiseurs basés sur Adam. Empêche la division par zéro dans le 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. Actuellement utilisé pour l'algorithme GaLore et l'algorithme APOLLO. Voir implémentation de GaLore et implémentation de 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 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 de rétropropagation/mise à jour. Simule des tailles de lot plus grandes sans mémoire supplémentaire. Taille de lot effective = per_device_train_batch_size × num_devices × gradient_accumulation_steps.

    Lors de l'utilisation de l'accumulation de gradients, un « pas » est compté comme un pas 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, 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 passe arrière, avant l'étape de l'optimiseur. Empêche l'explosion des gradients en réduisant les gradients 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. Zéro signifie aucun lissage. Plage typique : de 0.0 à 0.1.

Entraînement en précision mixte

  • bf16 (bool, facultatif, 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, par défaut False) — Active l’entraînement en précision mixte float16 (FP16). Envisagez d’utiliser BF16 à la place si votre matériel le prend en charge.
  • bf16_full_eval (bool, facultatif, valeur par défaut False) — Utilise 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) — Utilise 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 (au lieu des 23 bits de FP32), offrant jusqu’à 8 fois plus de vitesse avec une perte de précision négligeable. La valeur par défaut dépend de la version de PyTorch. Voir la documentation 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, par défaut None) — Arguments nominaux transmis à activation_checkpointing_enable(). every_n_layers effectue le checkpointing uniquement de chaque n-ième couche décodeur au lieu de toutes ; 1 correspond au comportement habituel tout-ou-rien, et des valeurs plus élevées rendent 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 un gain de vitesse de 20 à 50 % sans 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(). Si 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).

Kernels

  • use_liger_kernel (bool, facultatif, valeur par défaut False) — Active les optimisations 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, utilise la configuration par défaut.

Optimisations supplémentaires

  • use_cache (bool, facultatif, valeur 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 pour le fine-tuning par instructions. Consultez le paper original et le code original. Prend en charge les PreTrainedModel de transformers ainsi que 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 de pointe de la VRAM, au prix d’une performance environ 10 % plus lente.
  • 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, facultatif, défaut : "steps") — 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, par défaut 500) — Nombre d'étapes de mise à jour entre deux journaux si logging_strategy="steps". Doit être un entier ou un nombre décimal 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) — Lors d’une formation distribuée multi-nœuds, indique s’il faut journaliser à l’aide de 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) — Filtre 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, 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, 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, par défaut "none") — La liste des intégrations vers lesquelles envoyer 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 envoyer les rapports à toutes les intégrations installées, et "none" pour ne pas utiliser d'intégration.
  • run_name (str, facultatif) — Un descripteur pour l'exécution. Utilisé généralement pour la journalisation trackio, wandb, mlflow, comet et swanlab.
  • project (str, facultatif, par défaut "huggingface") — Le nom du projet à utiliser pour la journalisation. Actuellement, utilisé uniquement par Trackio.
  • trackio_space_id (str ou None, facultatif, par défaut None) — L’identifiant de l’espace Hugging Face à utiliser pour la journalisation en direct avec Trackio via un espace basé sur Gradio. Il doit s’agir d’un nom d’espace complet comme 'username/reponame' ou 'orgname/reponame', ou simplement de 'reponame' (l’espace est alors créé dans l’espace de noms de l’utilisateur actuellement connecté). Si la valeur est None, les métriques sont journalisées uniquement dans un répertoire local (aucun espace sur le Hub). Cet espace Gradio dispose d’un accès en 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, par défaut None) — Identifiant de Bucket Hugging Face facultatif pour Trackio. S'il n'est pas défini, Trackio en dérive un. Utilisé en conjonction 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, valeur 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. Il doit s’agir d’un nom d’espace complet comme 'username/reponame' ou 'orgname/reponame', ou simplement de 'reponame' (l’espace est créé dans l’espace de noms de l’utilisateur actuellement connecté). Si la valeur est False, aucun espace statique ne sera créé. Si la valeur est None et que le modèle est poussé sur le Hub, un espace statique sera créé avec un nom par défaut et un lien vers celui-ci sera ajouté à la carte du modèle. L’espace sera public, sauf si vous définissez hub_private_repo=True ou si la valeur par défaut de votre organisation est de créer des espaces privés.

Évaluation

  • eval_strategy (str ou IntervalStrategy, facultatif, défaut : "no") — Quand exécuter 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 le 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) — 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 exécuter récursivement la collecte d'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 retournent pas uniquement des tenseurs, et PyTorch la décourage activement. Cela 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 à accumuler pour les tenseurs de sortie avant de déplacer les résultats vers le CPU. Si non défini, l'ensemble des prédictions est accumulé sur l'accélérateur de l'appareil avant d'être déplacé vers le CPU (plus rapide mais nécessite plus de mémoire).

Calcul des métriques

  • include_for_metrics (list[str], facultatif, défaut []) — Inclure des données supplémentaires dans la compute_metrics fonction si nécessaire pour le calcul des métriques. Options possibles à ajouter à la include_for_metrics liste :
    • "inputs" : Données d’entrée transmises au modèle, destinées au calcul des métriques dépendantes des entrées.
    • "loss" : Valeurs de perte calculées lors de l'évaluation, destinées au calcul de métriques dépendantes 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 passer une fonction compute_metrics qui prend un argument booléen compute_result ; lorsqu’on lui passe True, elle déclenchera les 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’avec from_pretrained si cette option est définie sur True.
  • save_strategy (str ou SaveStrategy, facultatif, défaut : "steps") — Stratégie d'enregistrement 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" : 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 valeur de best_metric est atteinte.
  • save_steps (int ou float, facultatif, par défaut 500) — Nombre d'étapes de mise à jour avant l'enregistrement de deux points de contrôle si save_strategy="steps". Doit être un entier ou un nombre flottant compris dans l'intervalle [0,1). S'il est inférieur à 1, il sera interprété comme le 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 ≥ au temps de la plus longue itération + au temps de sauvegarde du checkpoint.

Intégration avec Hugging Face Hub

  • push_to_hub (bool, facultatif, par défaut False) — Indique s'il faut 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() déclenche également un push.
  • hub_token (str, facultatif) — Le jeton à utiliser pour pousser le modèle sur le Hub. Par défaut, il s’agit du jeton du dossier de cache obtenu avec hf auth login.
  • 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 défaut de l’organisation est le mode 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 l’espace 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, 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 le dernier point de contrôle dans le sous-dossier "last-checkpoint" pour une reprise facile
    • "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 du meilleur modèle

  • 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). Lorsque `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 le saut 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 checkpoint lors de la reprise. Si True, les callbacks passés au Trainer seront remplacés s’ils existent dans le checkpoint.

Reproductibilité

  • full_determinism (bool, facultatif, valeur par défaut False) — Si True, enable_full_determinism() est appelé à la place de 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, 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, par défaut False) — Indique s'il faut utiliser le CPU. Si défini sur False, nous utiliserons le dispositif/le backend torch disponible.

Configuration d'Accelerate

  • accelerator_config (str, dict, ou AcceleratorConfig, facultatif) — Configuration de l'intégration interne d'Accelerate. Peut être :
    • Chemin vers le fichier de configuration JSON : "accelerator_config.json"
    • Dictionnaire avec les options de configuration
    • instance de AcceleratorConfig Options principales :
    • split_batches (bool, 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 (le total 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, False sinon.
    • even_batches (bool, par défaut True) : Duplique des échantillons depuis le début du jeu de données pour garantir que tous les travailleurs reçoivent des lots de taille égale.
    • use_seedable_sampler (bool, par défaut True) : Utilise un échantillonneur aléatoire entièrement seedable pour la reproductibilité.
    • use_configured_state (bool, par défaut False) : Utilise un état 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

Dataloader

  • 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, valeur 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 Dataset des travailleurs en vie. 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 worker. 2 signifie qu’il y aura au total 2 * num_workers lots préchargés sur l’ensemble des workers.
  • dataloader_multiprocessing_context (str, facultatif) — Méthode de démarrage du multiprocessing à utiliser pour les workers de chargement des 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 produit les lots dans l'ordre où les workers ont été dispatchés. Définissez False pour produire les lots dès qu'ils sont prêts, ce qui peut réduire la latence de fin pour les workloads de streaming IterableDataset. Nécessite PyTorch >= 2.6.
  • remove_unused_columns (bool, facultatif, valeur 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 la QA extractive).
  • train_sampling_strategy (str, facultatif, 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 longueur approximativement identique (afin de minimiser le bourrage et d’être plus efficace).
    • "batch_rebalance" : Utilise BatchRebalanceSampler pour équilibrer le coût des jetons de bourrage entre les appareils et les étapes d'accumulation de gradient au sein de chaque lot effectif, réduisant ainsi le gaspillage de bourrage 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, par défaut "length") — Nom de la colonne contenant 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 transmis à 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 passée à 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 transmis à 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) — 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 exécutions distribuées. Veuillez consulter la documentation PyTorch pour plus d’informations.

FSDP (Fully Sharded Data Parallel)

  • fsdp (bool, facultatif, par défaut None) — Active PyTorch Fully Sharded Data Parallel (FSDP) pour l’entraînement distribué. Passez True pour activer FSDP.
  • fsdp_config (str or dict, optional) — Configuration settings for when fsdp is enabled. Pass a path to a JSON config file, such as fsdp_config.json, or an already-loaded dict.

    Clés prises en charge :

    • version (int, facultatif, par défaut 2) : La version de FSDP à utiliser (2 pour FSDP2, 1 pour le FSDP1 legacy).
    • reshard_after_forward (bool, facultatif, par défaut True) : Indique s'il faut re-resshader les paramètres après le passage avant. Définissez-le sur False pour conserver les paramètres regroupés entre les passages avant et arrière, ce qui évite le re-all-gather et entraîne une consommation mémoire de pointe plus élevée.
    • cpu_offload (bool, facultatif, 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, par défaut False) : À définir sur True pour réduire la mémoire en recalculant les activations lors de la passe arrière. Lors de l'utilisation de FSDP, privilégiez cette option par rapport à l'argument d'entraînement activation_checkpointing, qui introduit un all-gather redondant lors de la passe arrière.
    • cpu_ram_efficient_loading (bool, facultatif, par défaut False) : À définir 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, par défaut "FULL_STATE_DICT") : Format de 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, 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, 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’emballage XLA FSDP. Pour la liste complète des options, voir le code source de XLA FSDP.
    • xla_fsdp_grad_ckpt (bool, facultatif, valeur par défaut False) : À définir sur True pour utiliser le gradient checkpointing sur chaque couche imbriquée enveloppée par XLA FSDP. Nécessite xla=True et une politique d’enveloppement automatique (min_num_params ou transformer_layer_cls_to_wrap).

DeepSpeed

  • deepspeed (str ou dict, facultatif) — Active l'intégration DeepSpeed. La valeur est soit :
    • Chemin vers le fichier de configuration JSON de DeepSpeed : "ds_config.json"
    • Configuration chargée en tant que dictionnaire

      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, 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 dans les entrées/sorties du modèle et signale les derniers cadres 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 profilage 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.

Drapeaux de script externe (non utilisés par Trainer)

  • do_train (bool, facultatif, par défaut False) — Indique s'il faut exécuter l'entraînement ou non. Cet argument n'est pas utilisé directement par Trainer ; il est destiné à être utilisé par vos scripts d'entraînement/évaluation.
  • do_eval (bool, facultatif) — Indique s'il faut ou non exécuter une évaluation sur le jeu de validation. Sera défini à True si eval_strategy est différent de "no". Cet argument n'est pas utilisé directement par Trainer, il est destiné à être utilisé par vos scripts d'entraînement/évaluation.
  • do_predict (bool, facultatif, par défaut False) — Indique s'il faut exécuter des prédictions sur le jeu de test ou non. Cet argument n'est pas utilisé directement par 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, il est destiné à être utilisé par vos scripts d’entraînement/évaluation.
  • sortish_sampler (bool, facultatif, défaut False) — utiliser un sortish sampler ou non. N'est possible que si les jeux de données sous-jacents sont des Seq2SeqDataset pour le moment, mais sera disponible de manière générale à l'avenir.

    Il trie les entrées selon leurs longueurs afin de minimiser la taille du bourrage, avec un peu d'aléa pour l'ensemble d'entraînement.

  • predict_with_generate (bool, facultatif, valeur 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) — Le 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, facultatif) — Permet de charger un GenerationConfig à partir de la from_pretrained méthode. 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 dossier contenant un fichier de configuration enregistré à l’aide de la méthode save_pretrained(), par exemple ./my_model_directory/.
    • un objet 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 peut convertir cette classe en arguments argparse qui peuvent être spécifiés sur la ligne de commande.

to_dict

< >

( )

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.

Update on GitHub

←Tokenizer DeepSpeed→