# Callbacks

Les callbacks sont des objets qui permettent de personnaliser le comportement de la boucle d’entraînement dans le [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.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](/docs/transformers/main/fr/main_classes/callback#transformers.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](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer) et redéfinir les méthodes nécessaires (voir [trainer](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](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback). Elle reçoit les [TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments) utilisés pour instancier le [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer), peut accéder à l'état interne de ce Trainer via [TrainerState](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerState), et peut effectuer certaines actions sur la boucle d'entraînement via [TrainerControl](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerControl).

## Callbacks disponibles[[transformers.integrations.CometCallback]]

Voici la liste des [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) disponibles dans la bibliothèque :

#### transformers.integrations.CometCallback[[transformers.integrations.CometCallback]]

```python
transformers.integrations.CometCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1133)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui envoie les journaux à [Comet ML](https://www.comet.com/site/).

#### configuration[[transformers.integrations.CometCallback.setup]]

```python
setup(args, state, model)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1147)

Configurer l'intégration optionnelle Comet.

Environnement :
- **COMET_MODE** (`str`, *facultatif*, par défaut `get_or_create`) : Permet de contrôler s'il faut créer et journaliser une nouvelle expérience Comet ou ajouter des données à une expérience existante. Il accepte les valeurs suivantes :
  * `get_or_create` : décide automatiquement en fonction de la présence de `COMET_EXPERIMENT_KEY` et de l’existence ou non d’une Experiment portant cette clé.
  * `create` : Crée toujours une nouvelle expérience Comet.
  * `get` : Tentez toujours d’ajouter à une expérience Comet existante. Nécessite que `COMET_EXPERIMENT_KEY` soit 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*, valeur par défaut `TRUE`) : Indique s'il faut ou non journaliser les actifs d'entraînement (points de contrôle, etc.) vers Comet. Peut prendre la valeur `TRUE` ou `FALSE`.

Pour un certain nombre d'éléments configurables de l'environnement, voir [ici](https://www.comet.com/docs/v2/guides/experiment-management/configure-sdk/#explore-comet-configuration-options).

#### transformers.DefaultFlowCallback[[transformers.DefaultFlowCallback]]

```python
transformers.DefaultFlowCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L563)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.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.

#### transformers.PrinterCallback[[transformers.PrinterCallback]]

```python
transformers.PrinterCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L698)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) nu qui se contente d’afficher les journaux.

#### transformers.ProgressCallback[[transformers.ProgressCallback]]

```python
transformers.ProgressCallback(max_str_len: int = 100)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L624)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.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.

#### transformers.EarlyStoppingCallback[[transformers.EarlyStoppingCallback]]

```python
transformers.EarlyStoppingCallback(early_stopping_patience: int = 1, early_stopping_threshold: float | None = 0.0)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L711)

**Paramètres :**

early_stopping_patience (`int`) : À utiliser avec `metric_for_best_model` pour arrêter l'entraînement lorsque la métrique spécifiée se dégrade pendant `early_stopping_patience` appels d'évaluation.

early_stopping_threshold(`float`, *facultatif*) : À utiliser avec TrainingArguments `metric_for_best_model` et `early_stopping_patience` pour indiquer de combien la métrique spécifiée doit s'améliorer pour satisfaire aux conditions d'arrêt anticipé. `

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui gère l'arrêt anticipé.

Ce rappel dépend de la fonctionnalité *load_best_model_at_end* de l’argument [TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments) pour définir best_metric dans [TrainerState](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerState). Notez que si l’argument [TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments) *save_steps* diffère de *eval_steps*, l’arrêt anticipé n’interviendra pas avant la prochaine étape de sauvegarde.

#### transformers.integrations.TensorBoardCallback[[transformers.integrations.TensorBoardCallback]]

```python
transformers.integrations.TensorBoardCallback(tb_writer = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L577)

**Paramètres :**

tb_writer (`SummaryWriter`, *facultatif*) : L'objet writer à utiliser. Un objet sera instancié s'il n'est pas défini.

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui envoie les journaux à [TensorBoard](https://www.tensorflow.org/tensorboard).

Environnement :
- **TENSORBOARD_LOGGING_DIR** (`str`, *facultatif*, valeur par défaut `None`) : le répertoire de journalisation où enregistrer les résultats. La valeur par défaut est os.path.join(args.output_dir, default_logdir())

#### transformers.integrations.TrackioCallback[[transformers.integrations.TrackioCallback]]

```python
transformers.integrations.TrackioCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L935)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui journalise les métriques vers Trackio.

#### configuration[[transformers.integrations.TrackioCallback.setup]]

```python
setup(args, state, model, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L969)

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](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments).

#### transformers.integrations.WandbCallback[[transformers.integrations.WandbCallback]]

```python
transformers.integrations.WandbCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L695)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui journalise les métriques, les médias et les points de contrôle du modèle vers [Weight and Biases](https://www.wandb.com/).

#### configuration[[transformers.integrations.WandbCallback.setup]]

```python
setup(args, state, model, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L711)

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. Plus d’informations sont disponibles [ici](https://docs.wandb.ai/guides/integrations/huggingface). 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 sur `"end"`, le modèle est téléversé à la fin de l'entraînement. Si défini sur `"checkpoint"`, le point de contrôle est téléversé toutes les `args.save_steps` . Si défini sur `"false"`, le modèle n'est pas téléversé. À utiliser en combinaison avec `load_best_model_at_end()` pour téléverser le meilleur modèle.
- **WANDB_WATCH** (`str`, *facultatif*, valeur 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*, valeur par défaut `"huggingface"`) : définissez cette valeur sur une chaîne personnalisée pour stocker les résultats dans un projet différent.

#### transformers.integrations.MLflowCallback[[transformers.integrations.MLflowCallback]]

```python
transformers.integrations.MLflowCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1286)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui envoie les journaux à [MLflow](https://www.mlflow.org/). Peut être désactivé en définissant la variable d’environnement `DISABLE_MLFLOW_INTEGRATION = TRUE`.

#### configuration[[transformers.integrations.MLflowCallback.setup]]

```python
setup(args, state, model)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1305)

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 sur `True` ou *1*, chaque point de contrôle enregistré lors de chaque sauvegarde dans le `output_dir` de [TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.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 si les exécutions doivent être stockées 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éfaut `None`) : Indique si un experiment_name MLflow doit être utilisé pour lancer l'exécution. La valeur par défaut est `None`, ce qui pointe vers l'expérience `Default` dans MLflow. Sinon, il s'agit du nom de l'expérience à activer, sensible à la casse. Si aucune expérience portant ce nom n'existe, une nouvelle expérience est créée avec ce nom.
- **MLFLOW_TAGS** (`str`, *facultatif*) : une chaîne de caractères représentant un dictionnaire de paires clé/valeur à ajouter en tant que balises à l’exécution MLflow. Exemple : `os.environ['MLFLOW_TAGS']='{"release.candidate": "RC1", "release.version": "2.2.0"}'`.
- **MLFLOW_NESTED_RUN** (`str`, *facultatif*) : Indique s'il faut utiliser les exécutions imbriquées de MLflow. Si la valeur est définie sur `True` ou *1*, une exécution imbriquée sera créée à l'intérieur de l'exécution en cours.
- **MLFLOW_RUN_ID** (`str`, *facultatif*) : Permet de se rattacher à 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'environnement `MLFLOW_RUN_ID` est définie, `start_run` tente 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*, valeur par défaut `False`) : 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.

#### transformers.integrations.AzureMLCallback[[transformers.integrations.AzureMLCallback]]

```python
transformers.integrations.AzureMLCallback(azureml_run = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1263)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui envoie les journaux à [AzureML](https://pypi.org/project/azureml-sdk/).

#### transformers.integrations.CodeCarbonCallback[[transformers.integrations.CodeCarbonCallback]]

```python
transformers.integrations.CodeCarbonCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1809)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui suit les émissions de CO2 de l'entraînement.

#### transformers.integrations.ClearMLCallback[[transformers.integrations.ClearMLCallback]]

```python
transformers.integrations.ClearMLCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1843)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui envoie les journaux à [ClearML](https://clear.ml/).

Environnement :
- **CLEARML_PROJECT** (`str`, *facultatif*, par défaut `HuggingFace Transformers`) : nom du projet ClearML.
- **CLEARML_TASK** (`str`, *facultatif*, par défaut `Trainer`) : nom de la tâche ClearML.
- **CLEARML_LOG_MODEL** (`bool`, *facultatif*, valeur par défaut `False`) : Indique s'il faut enregistrer les modèles en tant qu'artefacts pendant l'entraînement.

#### transformers.integrations.DagsHubCallback[[transformers.integrations.DagsHubCallback]]

```python
transformers.integrations.DagsHubCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1467)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui journalise vers [DagsHub](https://dagshub.com/). Étend `MLflowCallback`

#### configuration[[transformers.integrations.DagsHubCallback.setup]]

```python
setup(*args, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L1481)

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 de l'expérience. La valeur par défaut est `False`.

#### transformers.integrations.FlyteCallback[[transformers.integrations.FlyteCallback]]

```python
transformers.integrations.FlyteCallback(save_log_history: bool = True, sync_checkpoints: bool = True)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2094)

**Paramètres :**

save_log_history (`bool`, *facultatif*, valeur par défaut `True`) : lorsqu'il est défini sur True, les journaux d'entraînement sont enregistrés sous forme de Flyte Deck.

sync_checkpoints (`bool`, *facultatif*, valeur par défaut `True`) : lorsqu'il est défini sur 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](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui envoie les journaux à [Flyte](https://flyte.org/). Remarque : ce callback ne fonctionne que dans le cadre d'une tâche Flyte.

Exemple :

```python
# Note: This example skips over some setup steps for brevity.
from flytekit import current_context, task

@task
def train_hf_transformer():
    cp = current_context().checkpoint
    trainer = Trainer(..., callbacks=[FlyteCallback()])
    output = trainer.train(resume_from_checkpoint=cp.restore())
```

#### transformers.integrations.KubeflowCallback[[transformers.integrations.KubeflowCallback]]

```python
transformers.integrations.KubeflowCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2436)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui signale la progression de l’entraînement à [Kubeflow Trainer](https://github.com/kubeflow/trainer).

Ce rappel est enregistré automatiquement lors de l’entraînement au sein d’un TrainJob Kubeflow lorsque le feature gate `TrainJobRuntimeStatus` est activé. 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 statut
- `KUBEFLOW_TRAINER_SERVER_CA_CERT` : Chemin du certificat CA pour la vérification TLS
- `KUBEFLOW_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'interrompront pas l'entraînement

Peut être désactivé en définissant la variable d'environnement `DISABLE_KUBEFLOW_INTEGRATION=TRUE`.

#### transformers.integrations.DVCLiveCallback[[transformers.integrations.DVCLiveCallback]]

```python
transformers.integrations.DVCLiveCallback(live: typing.Any | None = None, log_model: typing.Union[typing.Literal['all'], bool, NoneType] = None, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2157)

**Paramètres :**

live (`dvclive.Live`, *facultatif*, valeur par défaut `None`) : 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 utiliser `dvclive.Live.log_artifact()` pour journaliser les points de contrôle créés par [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer). Si la valeur est `True`, le point de contrôle final est journalisé à la fin de l'entraînement. Si la valeur est `"all"`, l'intégralité du `output_dir` de [TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments) est journalisée à chaque point de contrôle.

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui envoie les journaux à [DVCLive](https://www.dvc.org/doc/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](https://dvc.org/doc/dvclive/ml-frameworks/huggingface).

#### configuration[[transformers.integrations.DVCLiveCallback.setup]]

```python
setup(args, state, model)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2198)

Configurez l'intégration optionnelle DVCLive. Pour personnaliser ce rappel au-delà des variables d'environnement ci-dessous, voir [ici](https://dvc.org/doc/dvclive/ml-frameworks/huggingface).

Environnement :
- **HF_DVCLIVE_LOG_MODEL** (`str`, *facultatif*) : Indique s'il faut utiliser `dvclive.Live.log_artifact()` pour journaliser les points de contrôle créés par [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer). Si la valeur est `True` ou *1*, le point de contrôle final est journalisé à la fin de l'entraînement. Si la valeur est `all`, l'intégralité du `output_dir` de [TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments) est journalisée à chaque point de contrôle.

#### transformers.integrations.SwanLabCallback[[transformers.integrations.SwanLabCallback]]

```python
transformers.integrations.SwanLabCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2262)

Un [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) qui journalise les métriques, les médias et les points de contrôle du modèle vers [SwanLab](https://swanlab.cn/).

#### configuration[[transformers.integrations.SwanLabCallback.setup]]

```python
setup(args, state, model, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/integrations/integration_utils.py#L2276)

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](https://docs.swanlab.cn/guide_cloud/integration/integration-huggingface-transformers.html).

Vous pouvez également remplacer les variables d’environnement suivantes. Trouvez plus d’informations sur les variables d’environnement [ici](https://docs.swanlab.cn/en/api/environment-variable.html#environment-variables)

Environnement :
- **SWANLAB_API_KEY** (`str`, *facultatif*, par défaut `None`) : 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éfaut `None`) : 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éfaut `swanlog`) : cette variable d'environnement spécifie le chemin de stockage des fichiers journaux 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éfaut `cloud`) : 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 [ici](https://docs.swanlab.cn/en/api/py-init.html#swanlab-init)

- **SWANLAB_LOG_MODEL** (`str`, *facultatif*, valeur par défaut `None`) : SwanLab ne prend pas actuellement en charge la fonctionnalité de mode d'enregistrement. Cette fonctionnalité sera disponible dans une future version

- **SWANLAB_WEB_HOST** (`str`, *facultatif*, valeur par défaut `None`) : Adresse Web de l'environnement cloud SwanLab pour la version privée (gratuite)

- **SWANLAB_API_HOST** (`str`, *facultatif*, valeur par défaut `None`) : adresse de l'API de l'environnement cloud SwanLab pour la version privée (gratuite)

- **SWANLAB_RUN_ID** (`str`, *facultatif*, valeur par défaut `None`) : identifiant de l'expérience à reprendre. À utiliser avec `SWANLAB_RESUME` pour poursuivre une expérience existante.

- **SWANLAB_RESUME** (`str`, *facultatif*, valeur par défaut `None`) : mode de reprise (`"must"`, `"allow"`, `"never"`). La valeur par défaut est `"allow"` lorsque `resume_from_checkpoint` est utilisé.

## TrainerCallback[[transformers.TrainerCallback]]

#### transformers.TrainerCallback[[transformers.TrainerCallback]]

```python
transformers.TrainerCallback()
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L295)

**Paramètres :**

args ([TrainingArguments](/docs/transformers/main/fr/main_classes/trainer#transformers.TrainingArguments)) : les arguments d'entraînement utilisés pour instancier le [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer).

state ([TrainerState](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerState)) : l'état actuel du [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer).

control ([TrainerControl](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerControl)) : l'objet renvoyé au [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer) et qui peut être utilisé pour prendre certaines décisions.

model ([PreTrainedModel](/docs/transformers/main/fr/main_classes/model#transformers.PreTrainedModel) ou `torch.nn.Module`) : Le modèle en cours d'entraînement.

processing_class ([`PreTrainedTokenizer` ou `BaseImageProcessor` ou `ProcessorMixin` ou `FeatureExtractionMixin`]) : 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 par la dernière phase d'évaluation. Elles ne sont accessibles que dans l'événement `on_evaluate`.

logs  (`dict[str, float]`) : Les valeurs à consigner.  Elles ne sont accessibles que dans l'événement `on_log`.

Une classe destinée aux objets qui inspectent l'état de la boucle d'entraînement lors de certains événements et prennent 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 des arguments 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. Pour un exemple, consultez le code du simple [PrinterCallback](/docs/transformers/main/fr/main_classes/callback#transformers.PrinterCallback).

Exemple :

```python
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[[transformers.TrainerCallback.on_epoch_begin]]

```python
on_epoch_begin(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L361)

Événement appelé au début d'une époque.

#### on_epoch_end[[transformers.TrainerCallback.on_epoch_end]]

```python
on_epoch_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L366)

Événement appelé à la fin d'une époque.

#### on_evaluate[[transformers.TrainerCallback.on_evaluate]]

```python
on_evaluate(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L398)

Événement appelé après une phase d'évaluation.

#### on_init_end[[transformers.TrainerCallback.on_init_end]]

```python
on_init_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L346)

Événement appelé à la fin de l'initialisation du [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer).

#### on_log[[transformers.TrainerCallback.on_log]]

```python
on_log(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L413)

Événement appelé après l'enregistrement des derniers journaux.

#### on_optimizer_step[[transformers.TrainerCallback.on_optimizer_step]]

```python
on_optimizer_step(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L382)

É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[[transformers.TrainerCallback.on_pre_optimizer_step]]

```python
on_pre_optimizer_step(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L377)

Événement appelé avant l'étape de l'optimiseur mais après le rognage des gradients. Utile pour surveiller les gradients.

#### on_predict[[transformers.TrainerCallback.on_predict]]

```python
on_predict(args: TrainingArguments, state: TrainerState, control: TrainerControl, metrics, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L403)

Événement appelé après une prédiction réussie.

#### on_prediction_step[[transformers.TrainerCallback.on_prediction_step]]

```python
on_prediction_step(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L418)

Événement appelé après une étape de prédiction.

#### on_push_begin[[transformers.TrainerCallback.on_push_begin]]

```python
on_push_begin(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L423)

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

#### on_save[[transformers.TrainerCallback.on_save]]

```python
on_save(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L408)

Événement appelé après l'enregistrement d'un point de contrôle.

#### on_step_begin[[transformers.TrainerCallback.on_step_begin]]

```python
on_step_begin(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L371)

Événement appelé au début d'une étape d'entraînement. En cas d'accumulation de gradients, une étape d'entraînement peut nécessiter plusieurs entrées.

#### on_step_end[[transformers.TrainerCallback.on_step_end]]

```python
on_step_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L392)

Événement appelé à la fin d'une étape d'entraînement. En cas d'accumulation de gradients, une étape d'entraînement peut nécessiter plusieurs entrées.

#### on_substep_end[[transformers.TrainerCallback.on_substep_end]]

```python
on_substep_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L387)

Événement appelé à la fin d'une sous-étape pendant l'accumulation des gradients.

#### on_train_begin[[transformers.TrainerCallback.on_train_begin]]

```python
on_train_begin(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L351)

Événement appelé au début de l'entraînement.

#### on_train_end[[transformers.TrainerCallback.on_train_end]]

```python
on_train_end(args: TrainingArguments, state: TrainerState, control: TrainerControl, **kwargs)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L356)

Événement appelé à la fin de l'entraînement.

Voici un exemple de la manière d’enregistrer un rappel personnalisé avec le [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer) de PyTorch :

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

```python
trainer = Trainer(...)
trainer.add_callback(MyCallback)
# Alternatively, we can pass an instance of the callback class
trainer.add_callback(MyCallback())
```

## TrainerState[[transformers.TrainerState]]

#### transformers.TrainerState[[transformers.TrainerState]]

```python
transformers.TrainerState(epoch: float = 0, global_step: int = 0, max_steps: int = 0, logging_steps: int = 500, eval_steps: int = 500, save_steps: int = 500, train_batch_size: int | None = None, num_train_epochs: int = 0, num_input_tokens_seen: int = 0, total_flos: float = 0, log_history: list = None, best_metric: float | None = None, best_global_step: int | None = None, best_model_checkpoint: str | None = None, is_local_process_zero: bool = True, is_world_process_zero: bool = True, is_hyper_param_search: bool = False, trial_name: str | None = None, trial_params: dict[str, str | float | int | bool] | None = None, stateful_callbacks: list['TrainerCallback'] | None = None)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L35)

**Paramètres :**

epoch (`float`, *facultatif*) : défini uniquement pendant l'entraînement, représente l'époque à laquelle se trouve l'entraînement (la partie décimale indiquant le pourcentage de l'époque en cours déjà complétée).

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*, valeur par défaut 500) : Journaliser toutes les X étapes de mise à jour

eval_steps (`int`, *facultatif*) : Exécuter une évaluation toutes les X étapes.

save_steps (`int`, *facultatif*, valeur 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 lorsque `auto_find_batch_size` a été utilisé.

num_input_tokens_seen (`int`, *facultatif*, valeur par défaut 0) : Lors du suivi des jetons d'entrée, le 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 nombres 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éfinir `best_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*, valeur par défaut `True`) : 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éfaut `True`) : Indique si ce processus est le processus principal global (lors d'une formation distribuée sur plusieurs machines, cette valeur ne sera `True` que pour un seul processus).

is_hyper_param_search (`bool`, *facultatif*, par défaut `False`) : Indique si nous sommes en cours de recherche d'hyperparamètres à l'aide de Trainer.hyperparameter_search. Cela affecte la manière dont les données sont journalisées dans TensorBoard.

stateful_callbacks (`list[StatefulTrainerCallback]`, *facultatif*) : Callbacks attachés au `Trainer` dont l'état doit être sauvegardé ou restauré. Les callbacks concernés doivent implémenter une fonction `state` et une fonction `from_state`.

Une classe contenant l'état interne du [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer) qui sera enregistré avec le modèle et l'optimiseur lors de la création de points de contrôle et transmis au [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.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.

#### compute_steps[[transformers.TrainerState.compute_steps]]

```python
compute_steps(args, max_steps)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L156)

Calcule et stocke la valeur absolue pour les étapes de journalisation, d'évaluation et de sauvegarde, en fonction du fait qu'il s'agisse d'une proportion ou non.

#### init_training_references[[transformers.TrainerState.init_training_references]]

```python
init_training_references(trainer, max_steps, num_train_epochs, trial)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L169)

Stocke les références d'entraînement initiales nécessaires dans `self`

#### load_from_json[[transformers.TrainerState.load_from_json]]

```python
load_from_json(json_path: str)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L149)

Créer une instance à partir du contenu de `json_path`.

#### save_to_json[[transformers.TrainerState.save_to_json]]

```python
save_to_json(json_path: str)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L143)

Enregistrez le contenu de cette instance au format JSON dans `json_path`.

## TrainerControl[[transformers.TrainerControl]]

#### transformers.TrainerControl[[transformers.TrainerControl]]

```python
transformers.TrainerControl(should_training_stop: bool = False, should_epoch_stop: bool = False, should_save: bool = False, should_evaluate: bool = False, should_log: bool = False)
```

[Source](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_callback.py#L234)

**Paramètres :**

should_training_stop (`bool`, *facultatif*, valeur par défaut `False`) : 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*, par défaut `False`) : Indique si l'époque en cours doit être interrompue. Si `True`, cette variable est réinitialisée à `False` au début de l'époque suivante.

should_save (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle doit être enregistré à cette étape. Si `True`, cette variable est réinitialisée à `False` au début de l'étape suivante.

should_evaluate (`bool`, *facultatif*, valeur par défaut `False`) : Indique si le modèle doit être évalué à cette étape. Si `True`, cette variable est remise à `False` au début de l'étape suivante.

should_log (`bool`, *facultatif*, par défaut `False`) : Indique si les journaux doivent être signalés à cette étape. Si `True`, cette variable est réinitialisée à `False` au début de l'étape suivante.

Une classe qui gère le flux de contrôle du [Trainer](/docs/transformers/main/fr/main_classes/trainer#transformers.Trainer). Cette classe est utilisée par le [TrainerCallback](/docs/transformers/main/fr/main_classes/callback#transformers.TrainerCallback) pour activer certains commutateurs dans la boucle d'entraînement.