Transformers documentation
Callbacks
Callbacks
Les callbacks sont des objets qui permettent de personnaliser le comportement de la boucle d’entraînement dans le Trainer de PyTorch. Ils peuvent inspecter l’état de la boucle d’entraînement (pour le suivi de la progression, la journalisation sur TensorBoard ou d’autres plateformes ML…) et prendre des décisions (comme l’arrêt anticipé).
Les callbacks sont des fragments de code « en lecture seule » : à l’exception de l’objet TrainerControl qu’ils retournent, ils ne peuvent rien modifier dans la boucle d’entraînement. Pour les personnalisations qui nécessitent des modifications dans la boucle d’entraînement, vous devez sous-classez Trainer et surcharger les méthodes dont vous avez besoin (voir trainer pour des exemples).
Par défaut, TrainingArguments.report_to est défini sur "none".
La classe principale qui implémente les callbacks est TrainerCallback. Elle reçoit les TrainingArguments utilisés pour instancier le Trainer, peut accéder à l’état interne de ce Trainer via TrainerState et peut effectuer certaines actions sur la boucle d’entraînement via TrainerControl.
Callbacks disponibles
Voici la liste des TrainerCallback disponibles dans la bibliothèque :
Un TrainerCallback qui envoie les journaux à Comet ML.
Configurer l'intégration optionnelle Comet.
Environnement :
- COMET_MODE (
str, facultatif, par défautget_or_create): Contrôle la création et l'enregistrement dans une nouvelle expérience Comet ou l'ajout à une expérience existante. Il accepte les valeurs suivantes :get_or_create: décide automatiquement en fonction de la présence deCOMET_EXPERIMENT_KEYet de l’existence ou non d’un Experiment portant cette clé.create: Crée toujours une nouvelle expérience Comet.get: essaie toujours d’ajouter à une expérience Comet existante. Nécessite queCOMET_EXPERIMENT_KEYsoit défini.
- COMET_START_ONLINE (
bool, facultatif) : Indique s'il faut créer une Expérience en ligne ou hors ligne. - COMET_PROJECT_NAME (
str, facultatif) : Nom du projet Comet pour les expériences. - COMET_LOG_ASSETS (
str, facultatif, par défautTRUE) : Indique s'il faut ou non journaliser les actifs d'entraînement (points de contrôle, etc.) vers Comet. Peut êtreTRUEouFALSE.
Pour un certain nombre d'éléments configurables de l'environnement, voir ici.
Un TrainerCallback qui gère le flux par défaut de la boucle d’entraînement pour les journaux, l’évaluation et les points de contrôle.
Un TrainerCallback nu qui se contente d’afficher les journaux.
Un TrainerCallback qui affiche la progression de l’entraînement ou de l’évaluation.
Vous pouvez modifier max_str_len pour contrôler la longueur à laquelle les chaînes sont tronquées lors de la journalisation.
classe transformers.EarlyStoppingCallback
< source >( early_stopping_patience: int = 1early_stopping_threshold: float | None = 0.0 )
Paramètres
- early_stopping_patience (
int) — À utiliser avecmetric_for_best_modelpour arrêter l’entraînement lorsque la métrique spécifiée se dégrade pendantearly_stopping_patienceappels d’évaluation. - early_stopping_threshold(
float, facultatif) — À utiliser avec TrainingArgumentsmetric_for_best_modeletearly_stopping_patiencepour indiquer de combien la métrique spécifiée doit s'améliorer pour satisfaire les conditions d'arrêt anticipé. `
Un TrainerCallback qui gère l'arrêt anticipé.
Ce rappel dépend de la fonctionnalité load_best_model_at_end de l'argument TrainingArguments pour définir best_metric dans TrainerState. Notez que si l'argument TrainingArguments save_steps diffère de eval_steps, l'arrêt anticipé n'aura lieu qu'à la prochaine étape de sauvegarde.
classe transformers.integrations.TensorBoardCallback
< source >( tb_writer = None )
Un TrainerCallback qui envoie les journaux à TensorBoard.
Environnement :
- TENSORBOARD_LOGGING_DIR (
str, facultatif, valeur par défautNone) : Le répertoire de journalisation pour enregistrer les résultats. La valeur par défaut est os.path.join(args.output_dir, default_logdir())
Un TrainerCallback qui journalise les métriques vers Trackio.
Configurer l'intégration optionnelle Trackio.
Pour personnaliser la configuration, vous pouvez également définir project, trackio_space_id, trackio_bucket_id, trackio_static_space_id et hub_private_repo dans TrainingArguments.
Un TrainerCallback qui journalise les métriques, les médias et les points de contrôle du modèle vers Weight and Biases.
Configurez l'intégration optionnelle Weights & Biases (wandb).
On peut sous-classe et redéfinir cette méthode pour personnaliser la configuration si nécessaire. Trouvez plus d'informations ici. Vous pouvez également redéfinir les variables d'environnement suivantes :
Environnement :
- WANDB_LOG_MODEL (
str, facultatif, par défaut"false") : Indique s'il faut journaliser le modèle et les points de contrôle pendant l'entraînement. Peut prendre la valeur"end","checkpoint"ou"false". Si défini à"end", le modèle sera téléversé à la fin de l'entraînement. Si défini à"checkpoint", le point de contrôle sera téléversé toutes lesargs.save_stepsétapes. Si défini à"false", le modèle ne sera pas téléversé. À utiliser avecload_best_model_at_end()pour téléverser le meilleur modèle. - WANDB_WATCH (
str, facultatif, par défaut"false") : Peut prendre la valeur"gradients","all","parameters"ou"false". Définissez-le sur"all"pour enregistrer les gradients et les paramètres. - WANDB_PROJECT (
str, facultatif, par défaut"huggingface") : Définissez cette valeur sur une chaîne personnalisée pour stocker les résultats dans un projet différent.
Un TrainerCallback qui envoie les journaux à MLflow. Peut être désactivé en définissant la variable d'environnement DISABLE_MLFLOW_INTEGRATION = TRUE.
Configurer l'intégration optionnelle MLflow.
Environnement :
- HF_MLFLOW_LOG_ARTIFACTS (
str, facultatif) : Indique s'il faut utiliser la fonctionnalité.log_artifact()de MLflow pour journaliser les artefacts. Cela n'a de sens que si la journalisation est effectuée sur un serveur distant, par exemple s3 ou GCS. Si la valeur est définie surTrueou 1, chaque point de contrôle enregistré lors de chaque sauvegarde dans leoutput_dirde TrainingArguments sera copié dans le stockage d'artefacts local ou distant. Son utilisation sans stockage distant se limitera à copier les fichiers vers votre emplacement d'artefacts. - MLFLOW_TRACKING_URI (
str, facultatif) : Indique s'il faut stocker les exécutions dans un chemin spécifique ou sur un serveur distant. Non défini par défaut, ce qui entraîne l'omission totale de la configuration de l'URI de suivi. - MLFLOW_EXPERIMENT_NAME (
str, facultatif, par défautNone) : Indique s'il faut utiliser un experiment_name MLflow sous lequel lancer l'exécution. La valeur par défaut estNone, ce qui pointe vers l'expérienceDefaultdans MLflow. Sinon, il s'agit du nom sensible à la casse de l'expérience à activer. Si une expérience portant ce nom n'existe pas, une nouvelle expérience portant ce nom est créée. - MLFLOW_TAGS (
str, facultatif) : Une chaîne de caractères représentant un dictionnaire de paires clé/valeur à ajouter à l’exécution MLflow en tant que balises. Exemple :os.environ['MLFLOW_TAGS']='{"release.candidate": "RC1", "release.version": "2.2.0"}'. - MLFLOW_NESTED_RUN (
str, facultatif) : Indique s'il faut utiliser des exécutions imbriquées MLflow. Si défini surTrueou 1, une exécution imbriquée sera créée à l'intérieur de l'exécution actuelle. - MLFLOW_RUN_ID (
str, facultatif) : Permet de se reconnecter à une exécution existante, ce qui peut être utile lors de la reprise de l’entraînement depuis un point de contrôle. Lorsque la variable d’environnementMLFLOW_RUN_IDest définie,start_runtente de reprendre l’exécution avec l’identifiant d’exécution spécifié et les autres paramètres sont ignorés. - MLFLOW_FLATTEN_PARAMS (
str, facultatif, par défautFalse) : Indique s'il faut aplatir le dictionnaire des paramètres avant de les journaliser. - MLFLOW_MAX_LOG_PARAMS (
int, facultatif) : Définit le nombre maximal de paramètres à consigner dans l’exécution.
Un TrainerCallback qui envoie les journaux à AzureML.
Un TrainerCallback qui suit les émissions de CO2 de l'entraînement.
Un TrainerCallback qui envoie les journaux à ClearML.
Environnement :
- CLEARML_PROJECT (
str, facultatif, par défautHuggingFace Transformers) : Nom du projet ClearML. - CLEARML_TASK (
str, facultatif, par défautTrainer) : Nom de la tâche ClearML. - CLEARML_LOG_MODEL (
bool, facultatif, valeur par défautFalse) : Indique s'il faut enregistrer les modèles en tant qu'artefacts pendant l'entraînement.
Un TrainerCallback qui journalise vers DagsHub. Étend MLflowCallback
Configurer l’intégration de journalisation de DagsHub.
Environnement :
- HF_DAGSHUB_LOG_ARTIFACTS (
str, facultatif) : Indique s'il faut enregistrer les artefacts de données et de modèle pour l'expérience. La valeur par défaut estFalse.
classe transformers.integrations.FlyteCallback
< source >( save_log_history: bool = Truesync_checkpoints: bool = True )
Paramètres
- save_log_history (
bool, facultatif, valeur par défautTrue) — Lorsque la valeur est True, les journaux d’entraînement sont enregistrés sous forme de Flyte Deck. - sync_checkpoints (
bool, facultatif, valeur par défautTrue) — Lorsque la valeur est True, les points de contrôle sont synchronisés avec Flyte et peuvent être utilisés pour reprendre l’entraînement en cas d’interruption.
Un TrainerCallback qui envoie les journaux à Flyte. NOTE : Ce callback ne fonctionne que dans une tâche Flyte.
Un TrainerCallback qui signale la progression de l’entraînement à Kubeflow Trainer.
Ce rappel est enregistré automatiquement lors de l’entraînement au sein d’un Kubeflow TrainJob lorsque la fonctionnalité TrainJobRuntimeStatus est activée. Le contrôleur Kubeflow injecte les variables d’environnement requises dans le pod d’entraînement.
Variables d’environnement (injectées par le contrôleur) :
KUBEFLOW_TRAINER_SERVER_URL: point de terminaison HTTPS pour les mises à jour de statutKUBEFLOW_TRAINER_SERVER_CA_CERT: Chemin du certificat CA pour la vérification TLSKUBEFLOW_TRAINER_SERVER_TOKEN: Chemin vers le jeton du compte de service pour l'authentification
Informations signalées :
- Pourcentage de progression (0-100 %)
- Temps restant estimé (secondes)
- Métriques d'entraînement (loss, learning_rate, etc.)
Fonctionnalités :
- Mise en veille automatique (max 1 mise à jour toutes les 5 secondes) pour éviter de submerger le contrôleur
- Mise en cache des jetons (5 minutes) pour minimiser les E/S de fichiers
- Seul le rang 0 signale la progression lors de l'entraînement distribué
- Échecs silencieux - les problèmes réseau n'interrompent pas l'entraînement
Peut être désactivé en définissant la variable d'environnement DISABLE_KUBEFLOW_INTEGRATION=TRUE.
classe transformers.integrations.DVCLiveCallback
< source >( live: typing.Any | None = Nonelog_model: typing.Union[typing.Literal['all'], bool, NoneType] = None**kwargs )
Paramètres
- live (
dvclive.Live, facultatif, valeur par défautNone) — Instance Live facultative. Si None, une nouvelle instance sera créée à l'aide de **kwargs. - log_model (Union[Literal[“all”], bool], facultatif, valeur par défaut
None) — Indique s'il faut utiliserdvclive.Live.log_artifact()pour journaliser les points de contrôle créés par Trainer. Si défini surTrue, le point de contrôle final est journalisé à la fin de l'entraînement. Si défini sur"all", l'intégralité duoutput_dirde TrainingArguments est journalisée à chaque point de contrôle.
Un TrainerCallback qui envoie les journaux à DVCLive.
Utilisez les variables d’environnement ci-dessous dans setup pour configurer l’intégration. Pour personnaliser ce rappel au-delà de ces variables d’environnement, voir ici.
Configurez l'intégration optionnelle DVCLive. Pour personnaliser ce rappel au-delà des variables d'environnement ci-dessous, voir ici.
Environnement :
- HF_DVCLIVE_LOG_MODEL (
str, facultatif) : Indique s'il faut utiliserdvclive.Live.log_artifact()pour journaliser les points de contrôle créés par Trainer. Si la valeur estTrueou 1, le point de contrôle final est journalisé à la fin de l'entraînement. Si la valeur estall, l'intégralité duoutput_dirde TrainingArguments est journalisée à chaque point de contrôle.
Un TrainerCallback qui journalise les métriques, les médias et les points de contrôle du modèle vers SwanLab.
Configurer l'intégration optionnelle SwanLab (swanlab).
On peut sous-classe et redéfinir cette méthode pour personnaliser la configuration si nécessaire. Plus d'informations ici.
Vous pouvez également remplacer les variables d’environnement suivantes. Trouvez plus d’informations sur les variables d’environnement ici
Environnement :
SWANLAB_API_KEY (
str, facultatif, par défautNone) : Clé API Cloud. Lors de la connexion, cette variable d’environnement est vérifiée en premier. Si elle n’existe pas, le système vérifie si l’utilisateur est déjà connecté. Sinon, le processus de connexion est initié.- Si une chaîne est transmise à l'interface de connexion, cette variable d'environnement est ignorée.
- Si l'utilisateur est déjà connecté, cette variable d'environnement prend le pas sur les informations de connexion stockées localement.
SWANLAB_PROJECT (
str, facultatif, par défautNone) : Définissez cette valeur sur une chaîne personnalisée pour stocker les résultats dans un projet différent. Si elle n'est pas spécifiée, le nom du répertoire courant est utilisé.SWANLAB_LOG_DIR (
str, facultatif, par défautswanlog) : Cette variable d’environnement spécifie le chemin de stockage des fichiers de journalisation lors de l’exécution en mode local. Par défaut, les journaux sont enregistrés dans un dossier nommé swanlog sous le répertoire de travail.SWANLAB_MODE (
Literal["local", "cloud", "disabled"], facultatif, valeur par défautcloud) : Mode d’analyse de SwanLab, qui implique des callbacks enregistrés par l’opérateur. Actuellement, trois modes sont disponibles : local, cloud et disabled. Remarque : sensible à la casse. Plus d’informations iciSWANLAB_LOG_MODEL (
str, facultatif, valeur par défautNone) : SwanLab ne prend pas actuellement en charge la fonctionnalité de mode d'enregistrement. Cette fonctionnalité sera disponible dans une future versionSWANLAB_WEB_HOST (
str, facultatif, par défautNone) : Adresse Web de l’environnement cloud SwanLab pour la version privée (gratuite)SWANLAB_API_HOST (
str, facultatif, par défautNone) : Adresse de l’API pour l’environnement cloud SwanLab de la version privée (gratuite)SWANLAB_RUN_ID (
str, facultatif, par défautNone) : Identifiant de l'expérience à reprendre. À utiliser avecSWANLAB_RESUMEpour poursuivre une expérience existante.SWANLAB_RESUME (
str, facultatif, par défautNone) : Mode de reprise ("must","allow","never"). Par défaut,"allow"est utilisé lorsqueresume_from_checkpointest employé.
TrainerCallback
classe transformers.TrainerCallback
< source >( )
Paramètres
- args (TrainingArguments) — Les arguments d'entraînement utilisés pour instancier le Trainer.
- state (TrainerState) — L'état actuel du Trainer.
- control (TrainerControl) — L’objet renvoyé au Trainer et qui peut être utilisé pour prendre certaines décisions.
- model (PreTrainedModel ou
torch.nn.Module) — Le modèle en cours d’entraînement. - processing_class ([
PreTrainedTokenizerouBaseImageProcessorouProcessorMixinouFeatureExtractionMixin]) — La classe de traitement utilisée pour encoder les données. Peut être un tokenizer, un processeur, un processeur d'images ou un extracteur de caractéristiques. - optimizer (
torch.optim.Optimizer) — L’optimiseur utilisé pour les étapes d’entraînement. - lr_scheduler (
torch.optim.lr_scheduler.LambdaLR) — Le planificateur utilisé pour définir le taux d'apprentissage. - train_dataloader (
torch.utils.data.DataLoader, facultatif) — Le dataloader actuellement utilisé pour l’entraînement. - eval_dataloader (
torch.utils.data.DataLoader, facultatif) — Le dataloader actuellement utilisé pour l'évaluation. - metrics (
dict[str, float]) — Les métriques calculées lors de la dernière phase d'évaluation.Celles-ci ne sont accessibles que dans l'événement
on_evaluate. - logs (
dict[str, float]) — Les valeurs à consigner dans le journal.Celles-ci ne sont accessibles que dans l'événement
on_log.
Une classe pour les objets qui inspecteront l'état de la boucle d'entraînement à certains événements et prendront certaines décisions. À chacun de ces événements, les arguments suivants sont disponibles :
L'objet control est le seul qui puisse être modifié par le rappel, auquel cas l'événement qui le modifie doit renvoyer la version modifiée.
Les arguments args, state et control sont positionnels pour tous les événements, tous les autres sont regroupés dans kwargs.
Vous pouvez dépaqueter ceux dont vous avez besoin dans la signature de l'événement en les utilisant. À titre d'exemple, consultez le code du
simple PrinterCallback.
Exemple :
class PrinterCallback(TrainerCallback):
def on_log(self, args, state, control, logs=None, **kwargs):
_ = logs.pop("total_flos", None)
if state.is_local_process_zero:
print(logs)on_epoch_begin
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé au début d'une époque.
on_epoch_end
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé à la fin d'une époque.
on_evaluate
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé après une phase d'évaluation.
on_init_end
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé à la fin de l'initialisation du Trainer.
Événement appelé après l'enregistrement des derniers journaux.
on_optimizer_step
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé après l'étape de l'optimiseur mais avant que les gradients ne soient remis à zéro. Utile pour surveiller les gradients.
on_pre_optimizer_step
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé avant l'étape de l'optimiseur mais après le rognage des gradients. Utile pour surveiller les gradients.
on_predict
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControlmetrics**kwargs )
Événement appelé après une prédiction réussie.
on_prediction_step
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé après une étape de prédiction.
on_push_begin
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé avant la publication du modèle sur le hub, au début de Trainer.push_to_hub et Trainer._push_from_checkpoint.
Événement appelé après l'enregistrement d'un point de contrôle.
on_step_begin
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé au début d'une étape d'entraînement. En cas d'utilisation de l'accumulation de gradients, une étape d'entraînement peut nécessiter plusieurs entrées.
on_step_end
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé à la fin d'une étape d'entraînement. En cas d'utilisation de l'accumulation de gradients, une étape d'entraînement peut nécessiter plusieurs entrées.
on_substep_end
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé à la fin d'une sous-étape pendant l'accumulation des gradients.
on_train_begin
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé au début de l'entraînement.
on_train_end
< source >( args: TrainingArgumentsstate: TrainerStatecontrol: TrainerControl**kwargs )
Événement appelé à la fin de l'entraînement.
Voici un exemple de la manière d’enregistrer un rappel personnalisé avec le Trainer de PyTorch :
class MyCallback(TrainerCallback):
"A callback that prints a message at the beginning of training"
def on_train_begin(self, args, state, control, **kwargs):
print("Starting training")
trainer = Trainer(
model,
args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
callbacks=[MyCallback], # We can either pass the callback class this way or an instance of it (MyCallback())
)Une autre façon d’enregistrer un rappel est d’appeler trainer.add_callback() comme suit :
trainer = Trainer(...)
trainer.add_callback(MyCallback)
# Alternatively, we can pass an instance of the callback class
trainer.add_callback(MyCallback())TrainerState
classe transformers.TrainerState
< source >( epoch: float = 0global_step: int = 0max_steps: int = 0logging_steps: int = 500eval_steps: int = 500save_steps: int = 500train_batch_size: int | None = Nonenum_train_epochs: int = 0num_input_tokens_seen: int = 0total_flos: float = 0log_history: list = Nonebest_metric: float | None = Nonebest_global_step: int | None = Nonebest_model_checkpoint: str | None = Noneis_local_process_zero: bool = Trueis_world_process_zero: bool = Trueis_hyper_param_search: bool = Falsetrial_name: str | None = Nonetrial_params: dict[str, str | float | int | bool] | None = Nonestateful_callbacks: list['TrainerCallback'] | None = None )
Paramètres
- epoch (
float, facultatif) — N’est défini que pendant l’entraînement, il représente l’époque à laquelle se trouve l’entraînement (la partie décimale représentant le pourcentage de l’époque actuelle complété). - global_step (
int, facultatif, valeur par défaut 0) — Lors de l'entraînement, représente le nombre d'étapes de mise à jour terminées. - max_steps (
int, facultatif, valeur par défaut 0) — Le nombre d'étapes de mise à jour à effectuer pendant l'entraînement en cours. - logging_steps (
int, facultatif, par défaut 500) — Journaliser toutes les X étapes de mise à jour - eval_steps (
int, facultatif) — Lancer une évaluation toutes les X étapes. - save_steps (
int, facultatif, par défaut 500) — Enregistre un point de contrôle toutes les X étapes de mise à jour. - train_batch_size (
int, facultatif) — La taille du lot pour le chargeur de données d'entraînement. Nécessaire uniquement lorsqueauto_find_batch_sizea été utilisé. - num_input_tokens_seen (
int, facultatif, valeur par défaut 0) — Lors du suivi des jetons d’entrée, nombre de jetons observés pendant l’entraînement (nombre de jetons d’entrée, et non nombre de jetons de prédiction). - total_flos (
float, facultatif, valeur par défaut 0) — Le nombre total d'opérations flottantes effectuées par le modèle depuis le début de l'entraînement (stocké en flottants pour éviter le dépassement). - log_history (
list[dict[str, float]], facultatif) — La liste des journaux effectués depuis le début de l’entraînement. - best_metric (
float, facultatif) — Lors du suivi du meilleur modèle, la valeur de la meilleure métrique rencontrée jusqu’à présent. - best_global_step (
int, facultatif) — Lors du suivi du meilleur modèle, l'étape à laquelle la meilleure métrique a été rencontrée. Utilisé pour définirbest_model_checkpoint. - best_model_checkpoint (
str, facultatif) — Lors du suivi du meilleur modèle, la valeur du nom du point de contrôle du meilleur modèle rencontré jusqu’à présent. - is_local_process_zero (
bool, facultatif, par défautTrue) — 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 (
bool, facultatif, par défautTrue) — Indique si ce processus est le processus principal global (lors d’une formation distribuée sur plusieurs machines, cette valeur ne seraTrueque pour un seul processus). - is_hyper_param_search (
bool, facultatif, valeur par défautFalse) — Indique si nous sommes en cours de recherche d'hyperparamètres à l'aide de Trainer.hyperparameter_search. Cela affectera la manière dont les données seront journalisées dans TensorBoard. - stateful_callbacks (
list[StatefulTrainerCallback], facultatif) — Callbacks attachés auTrainerdont l’état doit être sauvegardé ou restauré. Les callbacks concernés doivent implémenter une fonctionstateet une fonctionfrom_state.
Une classe contenant l'état interne du Trainer qui sera enregistré avec le modèle et l'optimiseur lors de la création d'un point de contrôle et transmis au TrainerCallback.
Dans toute cette classe, une étape doit être comprise comme une étape de mise à jour. Lors de l'utilisation de l'accumulation de gradients, une étape de mise à jour peut nécessiter plusieurs passes avant et arrière : si vous utilisez
gradient_accumulation_steps=n, une étape de mise à jour nécessite de parcourir n lots.
Calcule et stocke la valeur absolue pour les étapes de journalisation, d'évaluation et d'enregistrement, en fonction du fait qu'il s'agisse d'une proportion ou non.
Stocke les références d'entraînement initiales nécessaires dans self
Créer une instance à partir du contenu de json_path.
Enregistrez le contenu de cette instance au format JSON dans json_path.
TrainerControl
classe transformers.TrainerControl
< source >( should_training_stop: bool = Falseshould_epoch_stop: bool = Falseshould_save: bool = Falseshould_evaluate: bool = Falseshould_log: bool = False )
Paramètres
- should_training_stop (
bool, facultatif, défautFalse) — Indique si l'entraînement doit être interrompu.Si
True, cette variable ne sera pas réinitialisée àFalse. L'entraînement s'arrêtera simplement. - should_epoch_stop (
bool, facultatif, défautFalse) — Indique si l'époque en cours doit être interrompue.Si
True, cette variable sera réinitialisée àFalseau début de l'époque suivante. - should_save (
bool, facultatif, défautFalse) — Indique si le modèle doit être enregistré à cette étape.Si
True, cette variable sera remise àFalseau début de l'étape suivante. - should_evaluate (
bool, facultatif, défautFalse) — Indique si le modèle doit être évalué à cette étape.Si
True, cette variable sera remise àFalseau début de l'étape suivante. - should_log (
bool, facultatif, défautFalse) — Indique si les journaux doivent être signalés à cette étape.Si
True, cette variable sera remise àFalseau début de l'étape suivante.
Une classe qui gère le flux de contrôle du Trainer. Cette classe est utilisée par le TrainerCallback pour activer certains commutateurs dans la boucle d'entraînement.