# Callbacks

Los callbacks son objetos que pueden personalizar el comportamiento del bucle de entrenamiento en el [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer) de PyTorch, inspeccionar el estado del bucle de entrenamiento (para informar del progreso, registrar en TensorBoard u otras plataformas de ML...) y tomar decisiones (como el detención anticipada).

Los callbacks son fragmentos de código de "solo lectura"; aparte del objeto [TrainerControl](/docs/transformers/main/es/main_classes/callback#transformers.TrainerControl) que devuelven, no pueden modificar nada en el bucle de entrenamiento. Para personalizaciones que requieran cambios en el bucle de entrenamiento, debe subclasear [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer) y sobrescribir los métodos que necesite (consulte [trainer](trainer) para ver ejemplos).

Por defecto, `TrainingArguments.report_to` se establece en `"none"`.

La clase principal que implementa las callbacks es [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback). Obtiene los [TrainingArguments](/docs/transformers/main/es/main_classes/trainer#transformers.TrainingArguments) utilizados para instanciar el [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer), puede acceder al estado interno de ese Trainer a través de [TrainerState](/docs/transformers/main/es/main_classes/callback#transformers.TrainerState) y puede realizar algunas acciones en el bucle de entrenamiento mediante [TrainerControl](/docs/transformers/main/es/main_classes/callback#transformers.TrainerControl).

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

Esta es la lista de los [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) disponibles en la biblioteca:

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que envía los registros a [Comet ML](https://www.comet.com/site/).

#### configuración[[transformers.integrations.CometCallback.setup]]

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

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

Configura la integración opcional de Comet.

Entorno:
- **COMET_MODE** (`str`, *opcional*, valor predeterminado `get_or_create`): Controla si se debe crear y registrar un nuevo experimento de Comet o si se debe añadir a un experimento existente. Acepta los siguientes valores:
  * `get_or_create`: Decide automáticamente en función de si `COMET_EXPERIMENT_KEY` está definido y si ya existe un Experiment con esa clave.
  * `create`: Siempre crea un nuevo experimento de Comet.
  * `get`: Siempre intenta añadir a un Experimento de Comet existente. Requiere que `COMET_EXPERIMENT_KEY` esté definido.
- **COMET_START_ONLINE** (`bool`, *opcional*): Indica si se debe crear un Experimento en línea o fuera de línea.
- **COMET_PROJECT_NAME** (`str`, *opcional*): nombre del proyecto de Comet para los experimentos.
- **COMET_LOG_ASSETS** (`str`, *opcional*, valor predeterminado `TRUE`): Indica si se registran o no los activos de entrenamiento (puntos de control, etc.) en Comet. Puede ser `TRUE` o `FALSE`.

Para conocer varios elementos configurables del entorno, consulte [aquí](https://www.comet.com/docs/v2/guides/experiment-management/configure-sdk/#explore-comet-configuration-options).

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que gestiona el flujo predeterminado del bucle de entrenamiento para registros, evaluación y puntos de control.

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) simple que solo imprime los registros.

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que muestra el progreso del entrenamiento o la evaluación. Puede modificar `max_str_len` para controlar la longitud a la que se truncan las cadenas al registrar los registros.

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

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

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

**Parámetros:**

early_stopping_patience (`int`) : Se usa con `metric_for_best_model` para detener el entrenamiento cuando la métrica especifica empeora durante `early_stopping_patience` llamadas de evaluación.

early_stopping_threshold(`float`, *opcional*) : Se usa con TrainingArguments `metric_for_best_model` y `early_stopping_patience` para indicar cuánto debe mejorar la métrica especificada para cumplir las condiciones de parada anticipada. `

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que gestiona la detención anticipada.

Este callback depende de la funcionalidad del argumento *load_best_model_at_end* de [TrainingArguments](/docs/transformers/main/es/main_classes/trainer#transformers.TrainingArguments) para establecer best_metric en [TrainerState](/docs/transformers/main/es/main_classes/callback#transformers.TrainerState). Tenga en cuenta que si el argumento *save_steps* de [TrainingArguments](/docs/transformers/main/es/main_classes/trainer#transformers.TrainingArguments) difiere de *eval_steps*, el early stopping no se producirá hasta el siguiente paso de guardado.

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

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

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

**Parámetros:**

tb_writer (`SummaryWriter`, *opcional*) : El escritor a utilizar. Se instanciará uno si no se establece.

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que envía los registros a [TensorBoard](https://www.tensorflow.org/tensorboard).

Entorno:
- **TENSORBOARD_LOGGING_DIR** (`str`, *opcional*, valor predeterminado `None`): El directorio de registro donde se registran los resultados. El valor predeterminado es os.path.join(args.output_dir, default_logdir())

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que registra métricas en Trackio.

#### configuración[[transformers.integrations.TrackioCallback.setup]]

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

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

Configura la integración opcional de Trackio.

Para personalizar la configuración, también puedes establecer `project`, `trackio_space_id`, `trackio_bucket_id`, `trackio_static_space_id` y `hub_private_repo` en [TrainingArguments](/docs/transformers/main/es/main_classes/trainer#transformers.TrainingArguments).

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que registra métricas, medios y puntos de control del modelo en [Weight and Biases](https://www.wandb.com/).

#### configuración[[transformers.integrations.WandbCallback.setup]]

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

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

Configura la integración opcional de Weights & Biases (*wandb*).

Es posible crear una subclase y sobrescribir este método para personalizar la configuración si es necesario. Encontrará más información [aquí](https://docs.wandb.ai/guides/integrations/huggingface). También puede sobrescribir las siguientes variables de entorno:

Entorno:
- **WANDB_LOG_MODEL** (`str`, *opcional*, valor predeterminado `"false"`): Indica si se registran el modelo y los puntos de control durante el entrenamiento. Puede ser `"end"`, `"checkpoint"` o `"false"`. Si se establece en `"end"`, el modelo se subirá al final del entrenamiento. Si se establece en `"checkpoint"`, el punto de control se subirá cada `args.save_steps` . Si se establece en `"false"`, el modelo no se subirá. Úsalo junto con `load_best_model_at_end()` para subir el mejor modelo.
- **WANDB_WATCH** (`str`, *opcional*, valor predeterminado `"false"`): puede ser `"gradients"`, `"all"`, `"parameters"` o `"false"`. Establezca `"all"` para registrar gradientes y parámetros.
- **WANDB_PROJECT** (`str`, *opcional*, valor predeterminado `"huggingface"`): Establezca este valor como una cadena personalizada para almacenar los resultados en un proyecto diferente.

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que envía los registros a [MLflow](https://www.mlflow.org/). Puede desactivarse estableciendo la variable de entorno `DISABLE_MLFLOW_INTEGRATION = TRUE`.

#### configuración[[transformers.integrations.MLflowCallback.setup]]

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

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

Configura la integración opcional de MLflow.

Entorno:
- **HF_MLFLOW_LOG_ARTIFACTS** (`str`, *opcional*): Indica si se debe utilizar la función `.log_artifact()` de MLflow para registrar artefactos. Esto solo tiene sentido si se registra en un servidor remoto, por ejemplo, s3 o GCS. Si se establece en `True` o *1*, se copiará cada punto de control guardado en cada guardado en `output_dir` de [TrainingArguments](/docs/transformers/main/es/main_classes/trainer#transformers.TrainingArguments) al almacenamiento de artefactos local o remoto. Su uso sin un almacenamiento remoto simplemente copiará los archivos a la ubicación de artefactos.
- **MLFLOW_TRACKING_URI** (`str`, *opcional*): Si se deben almacenar las ejecuciones en una ruta específica o en un servidor remoto. No está definido por defecto, lo que omite la configuración de la URI de seguimiento por completo.
- **MLFLOW_EXPERIMENT_NAME** (`str`, *opcional*, valor predeterminado `None`): Indica si se debe utilizar un experiment_name de MLflow bajo el cual lanzar la ejecución. El valor predeterminado es `None`, que apunta al experimento `Default` en MLflow. En caso contrario, es el nombre del experimento que se activará, sensible a mayúsculas y minúsculas. Si no existe un experimento con este nombre, se crea uno nuevo con dicho nombre.
- **MLFLOW_TAGS** (`str`, *opcional*): una cadena con el volcado de un diccionario de pares clave/valor que se añadirá a la ejecución de MLflow como etiquetas. Ejemplo: `os.environ['MLFLOW_TAGS']='{"release.candidate": "RC1", "release.version": "2.2.0"}'`.
- **MLFLOW_NESTED_RUN** (`str`, *opcional*): Si se debe usar ejecuciones anidadas de MLflow. Si se establece en `True` o *1*, se creará una ejecución anidada dentro de la ejecución actual.
- **MLFLOW_RUN_ID** (`str`, *opcional*): Permite volver a adjuntarse a una ejecución existente, lo cual puede ser útil al reanudar el entrenamiento desde un punto de control. Cuando se establece la variable de entorno `MLFLOW_RUN_ID`, `start_run` intenta reanudar una ejecución con el ID de ejecución especificado y se ignoran los demás parámetros.
- **MLFLOW_FLATTEN_PARAMS** (`str`, *opcional*, valor predeterminado `False`): Indica si se debe aplanar el diccionario de parámetros antes de registrarlos.
- **MLFLOW_MAX_LOG_PARAMS** (`int`, *opcional*): Establece el número máximo de parámetros que se registrarán en la ejecución.

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que envía los registros a [AzureML](https://pypi.org/project/azureml-sdk/).

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que rastrea la emisión de CO2 del entrenamiento.

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que envía los registros a [ClearML](https://clear.ml/).

Entorno:
- **CLEARML_PROJECT** (`str`, *opcional*, valor predeterminado `HuggingFace Transformers`): nombre del proyecto de ClearML.
- **CLEARML_TASK** (`str`, *opcional*, valor predeterminado `Trainer`): nombre de la tarea de ClearML.
- **CLEARML_LOG_MODEL** (`bool`, *opcional*, valor predeterminado `False`): Indica si se registran los modelos como artefactos durante el entrenamiento.

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que registra en [DagsHub](https://dagshub.com/). Extiende `MLflowCallback`

#### configuración[[transformers.integrations.DagsHubCallback.setup]]

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

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

Configura la integración de registro de DagsHub.

Entorno:
- **HF_DAGSHUB_LOG_ARTIFACTS** (`str`, *opcional*): Indica si se deben guardar los artefactos de datos y modelos del experimento. El valor predeterminado es `False`.

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

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

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

**Parámetros:**

save_log_history (`bool`, *opcional*, valor predeterminado `True`) : Cuando se establece en True, los registros de entrenamiento se guardan como un Flyte Deck.

sync_checkpoints (`bool`, *opcional*, valor predeterminado `True`) : Cuando se establece en True, los puntos de control se sincronizan con Flyte y pueden usarse para reanudar el entrenamiento en caso de una interrupción.

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que envía los registros a [Flyte](https://flyte.org/). NOTA: Este callback solo funciona dentro de una tarea de Flyte.

Ejemplo:

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que informa del progreso del entrenamiento a [Kubeflow Trainer](https://github.com/kubeflow/trainer).

Este callback se registra automáticamente al entrenar dentro de un TrainJob de Kubeflow con la puerta de función `TrainJobRuntimeStatus` habilitada. El controlador de Kubeflow inyecta las variables de entorno necesarias en el pod de entrenamiento.

**Variables de entorno (inyectadas por el controlador):**

- `KUBEFLOW_TRAINER_SERVER_URL`: punto de acceso HTTPS para actualizaciones de estado
- `KUBEFLOW_TRAINER_SERVER_CA_CERT`: Ruta al certificado CA para la verificación TLS
- `KUBEFLOW_TRAINER_SERVER_TOKEN`: Ruta al token de la cuenta de servicio para la autenticación

**Información reportada:**

- Porcentaje de progreso (0-100%)
- Tiempo restante estimado (segundos)
- Métricas de entrenamiento (loss, learning_rate, etc.)

**Características:**

- Ajuste automático de velocidad (máximo 1 actualización cada 5 segundos) para evitar saturar el controlador
- Caché de tokens (5 minutos) para minimizar la E/S de archivos
- Solo el rango 0 informa del progreso en el entrenamiento distribuido
- Fallos silenciosos: los problemas de red no interrumpirán el entrenamiento

Se puede desactivar estableciendo la variable de entorno `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)
```

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

**Parámetros:**

live (`dvclive.Live`, *opcional*, valor predeterminado `None`) : Instancia Live opcional. Si es None, se creará una nueva instancia usando **kwargs.

log_model (Union[Literal["all"], bool], *opcional*, valor predeterminado `None`) : Si se usa `dvclive.Live.log_artifact()` para registrar los puntos de control creados por [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer). Si se establece en `True`, el punto de control final se registra al final del entrenamiento. Si se establece en `"all"`, todo el `output_dir` de [TrainingArguments](/docs/transformers/main/es/main_classes/trainer#transformers.TrainingArguments) se registra en cada punto de control.

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que envía los registros a [DVCLive](https://www.dvc.org/doc/dvclive).

Use las variables de entorno siguientes en `setup` para configurar la integración. Para personalizar esta devolución de llamada más allá de esas variables de entorno, consulte [aquí](https://dvc.org/doc/dvclive/ml-frameworks/huggingface).

#### configuración[[transformers.integrations.DVCLiveCallback.setup]]

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

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

Configura la integración opcional de DVCLive. Para personalizar esta devolución de llamada más allá de las variables de entorno siguientes, consulta [aquí](https://dvc.org/doc/dvclive/ml-frameworks/huggingface).

Entorno:
- **HF_DVCLIVE_LOG_MODEL** (`str`, *opcional*): Indica si se debe usar `dvclive.Live.log_artifact()` para registrar los puntos de control creados por [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer). Si se establece en `True` o *1*, el punto de control final se registra al final del entrenamiento. Si se establece en `all`, se registra todo el `output_dir` de [TrainingArguments](/docs/transformers/main/es/main_classes/trainer#transformers.TrainingArguments) en cada punto de control.

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

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

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

Un [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) que registra métricas, medios y puntos de control del modelo en [SwanLab](https://swanlab.cn/).

#### configuración[[transformers.integrations.SwanLabCallback.setup]]

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

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

Configura la integración opcional de SwanLab (*swanlab*).

Es posible crear una subclase y sobrescribir este método para personalizar la configuración si es necesario. Encuentre más información [aquí](https://docs.swanlab.cn/guide_cloud/integration/integration-huggingface-transformers.html).

También puede sobrescribir las siguientes variables de entorno. Encuentre más información sobre las variables de entorno [aquí](https://docs.swanlab.cn/en/api/environment-variable.html#environment-variables)

Entorno:
- **SWANLAB_API_KEY** (`str`, *opcional*, valor predeterminado `None`): Clave de API de la nube. Durante el inicio de sesión, se comprueba primero esta variable de entorno. Si no existe, el sistema verifica si el usuario ya ha iniciado sesión. Si no es así, se inicia el proceso de inicio de sesión.

  - Si se pasa una cadena a la interfaz de inicio de sesión, esta variable de entorno se ignora.
  - Si el usuario ya ha iniciado sesión, esta variable de entorno tiene prioridad sobre la información de inicio de sesión almacenada localmente.

- **SWANLAB_PROJECT** (`str`, *opcional*, valor predeterminado `None`): Establezca este valor como una cadena personalizada para guardar los resultados en un proyecto diferente. Si no se especifica, se utiliza el nombre del directorio de trabajo actual.

- **SWANLAB_LOG_DIR** (`str`, *opcional*, valor predeterminado `swanlog`): esta variable de entorno especifica la ruta de almacenamiento para los archivos de registro al ejecutar en modo local. De forma predeterminada, los registros se guardan en una carpeta llamada swanlog dentro del directorio de trabajo.

- **SWANLAB_MODE** (`Literal["local", "cloud", "disabled"]`, *opcional*, valor predeterminado `cloud`): modo de análisis de SwanLab, que implica los callbacks registrados por el operador. Actualmente, hay tres modos: local, cloud y disabled. Nota: sensible a mayúsculas y minúsculas. Encuentra más información [aquí](https://docs.swanlab.cn/en/api/py-init.html#swanlab-init)

- **SWANLAB_LOG_MODEL** (`str`, *opcional*, valor predeterminado `None`): SwanLab no admite actualmente la funcionalidad de modo de guardado. Esta función estará disponible en una versión futura

- **SWANLAB_WEB_HOST** (`str`, *opcional*, valor predeterminado `None`): dirección web del entorno en la nube de SwanLab para la versión privada (es gratuita)

- **SWANLAB_API_HOST** (`str`, *opcional*, valor predeterminado `None`): dirección de la API para el entorno en la nube de SwanLab de la versión privada (es gratuita)

- **SWANLAB_RUN_ID** (`str`, *opcional*, valor predeterminado `None`): ID del experimento para reanudar una ejecución anterior. Úsalo junto con `SWANLAB_RESUME` para continuar un experimento existente.

- **SWANLAB_RESUME** (`str`, *opcional*, valor predeterminado `None`): Modo de reanudación (`"must"`, `"allow"`, `"never"`). El valor predeterminado es `"allow"` cuando se usa `resume_from_checkpoint`.

## TrainerCallback[[transformers.TrainerCallback]]

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

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

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

**Parámetros:**

args ([TrainingArguments](/docs/transformers/main/es/main_classes/trainer#transformers.TrainingArguments)) : Los argumentos de entrenamiento utilizados para instanciar el [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer).

state ([TrainerState](/docs/transformers/main/es/main_classes/callback#transformers.TrainerState)): El estado actual del [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer).

control ([TrainerControl](/docs/transformers/main/es/main_classes/callback#transformers.TrainerControl)) : El objeto que se devuelve al [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer) y que se puede utilizar para tomar algunas decisiones.

model ([PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel) o `torch.nn.Module`): El modelo que se está entrenando.

processing_class ([`PreTrainedTokenizer` o `BaseImageProcessor` o `ProcessorMixin` o `FeatureExtractionMixin`]) : La clase de procesamiento utilizada para codificar los datos. Puede ser un tokenizador, un procesador, un procesador de imágenes o un extractor de características.

optimizer (`torch.optim.Optimizer`) : El optimizador utilizado para los pasos de entrenamiento.

lr_scheduler (`torch.optim.lr_scheduler.LambdaLR`) : El programador utilizado para establecer la tasa de aprendizaje.

train_dataloader (`torch.utils.data.DataLoader`, *opcional*) : El dataloader actual utilizado para el entrenamiento.

eval_dataloader (`torch.utils.data.DataLoader`, *opcional*) : El dataloader actual utilizado para la evaluación.

metrics (`dict[str, float]`) : Las métricas calculadas por la última fase de evaluación. Solo están accesibles en el evento `on_evaluate`.

logs  (`dict[str, float]`) : Los valores que se registran.  Solo están accesibles en el evento `on_log`.

Una clase para objetos que inspeccionarán el estado del bucle de entrenamiento en ciertos eventos y tomarán algunas decisiones. En cada uno de esos eventos, los siguientes argumentos están disponibles:

El objeto `control` es el único que puede ser modificado por el callback, en cuyo caso el evento que lo modifica debe devolver la versión modificada.

Los argumentos `args`, `state` y `control` son posicionales para todos los eventos, mientras que el resto se agrupan en `kwargs`. Puedes desempaquetar los que necesites en la firma del evento. Como ejemplo, consulta el código del simple [PrinterCallback](/docs/transformers/main/es/main_classes/callback#transformers.PrinterCallback).

Ejemplo:

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

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

Evento que se llama al inicio de una época.

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

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

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

Evento que se llama al final de una época.

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

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

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

Evento llamado después de una fase de evaluación.

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

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

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

Evento llamado al final de la inicialización del [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer).

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

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

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

Evento llamado después de registrar los últimos registros.

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

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

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

Evento que se llama después del paso del optimizador pero antes de que los gradientes se pongan a cero. Útil para supervisar los gradientes.

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

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

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

Evento que se llama antes del paso del optimizador pero después del recorte de gradientes. Útil para supervisar los gradientes.

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

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

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

Evento llamado después de una predicción exitosa.

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

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

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

Evento llamado después de un paso de predicción.

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

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

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

Evento que se llama antes de subir el modelo al hub, al inicio de Trainer.push_to_hub y Trainer._push_from_checkpoint.

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

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

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

Evento llamado después de guardar un punto de control.

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

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

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

Evento que se llama al inicio de un paso de entrenamiento. Si se usa acumulación de gradientes, un paso de entrenamiento puede requerir varias entradas.

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

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

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

Evento que se llama al final de un paso de entrenamiento. Si se usa acumulación de gradientes, un paso de entrenamiento puede requerir varias entradas.

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

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

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

Evento que se llama al final de un subpaso durante la acumulación de gradientes.

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

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

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

Evento llamado al inicio del entrenamiento.

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

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

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

Evento llamado al final del entrenamiento.

A continuación se muestra un ejemplo de cómo registrar un callback personalizado con el [Trainer](/docs/transformers/main/es/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())
)
```

Otra forma de registrar un callback es llamar a `trainer.add_callback()` de la siguiente manera:

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

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

**Parámetros:**

epoch (`float`, *opcional*) : Solo se establece durante el entrenamiento y representa la época en la que se encuentra el entrenamiento (la parte decimal indica el porcentaje de la época actual completado).

global_step (`int`, *opcional*, valor predeterminado 0) : Durante el entrenamiento, representa el número de pasos de actualización completados.

max_steps (`int`, *opcional*, valor predeterminado 0) : El número de pasos de actualización que se realizarán durante el entrenamiento actual.

logging_steps (`int`, *opcional*, valor predeterminado 500) : Registra cada X pasos de actualización

eval_steps (`int`, *opcional*) : Ejecutar una evaluación cada X pasos.

save_steps (`int`, *opcional*, valor predeterminado 500) : Guarda un punto de control cada X pasos de actualización.

train_batch_size (`int`, *opcional*) : El tamaño del lote para el dataloader de entrenamiento. Solo es necesario cuando se ha utilizado `auto_find_batch_size`.

num_input_tokens_seen (`int`, *opcional*, valor predeterminado 0) : Al hacer seguimiento de los tokens de entrada, el número de tokens vistos durante el entrenamiento (número de tokens de entrada, no el número de tokens de predicción).

total_flos (`float`, *opcional*, valor predeterminado 0) : El número total de operaciones de coma flotante realizadas por el modelo desde el inicio del entrenamiento (almacenado como flotantes para evitar desbordes).

log_history (`list[dict[str, float]]`, *opcional*) : La lista de registros realizados desde el inicio del entrenamiento.

best_metric (`float`, *opcional*) : Al hacer seguimiento del mejor modelo, el valor de la mejor métrica encontrada hasta el momento.

best_global_step (`int`, *opcional*) : Al hacer seguimiento del mejor modelo, el paso en el que se encontró la mejor métrica. Se utiliza para establecer `best_model_checkpoint`.

best_model_checkpoint (`str`, *opcional*) : Al hacer seguimiento del mejor modelo, el valor del nombre del punto de control del mejor modelo encontrado hasta el momento.

is_local_process_zero (`bool`, *opcional*, valor predeterminado `True`) : Indica si este proceso es el proceso principal local (por ejemplo, en una sola máquina si el entrenamiento se realiza de forma distribuida en varias máquinas).

is_world_process_zero (`bool`, *opcional*, valor predeterminado `True`) : Indica si este proceso es el proceso principal global (cuando se entrena de forma distribuida en varias máquinas, solo será `True` para un proceso).

is_hyper_param_search (`bool`, *opcional*, valor predeterminado `False`) : Indica si estamos en el proceso de una búsqueda de hiperparámetros usando Trainer.hyperparameter_search. Esto afectará la forma en que se registran los datos en TensorBoard.

stateful_callbacks (`list[StatefulTrainerCallback]`, *opcional*) : Callbacks adjuntos al `Trainer` cuyo estado debe guardarse o restaurarse. Los callbacks relevantes deben implementar una función `state` y una función `from_state`.

Una clase que contiene el estado interno de [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer) que se guardará junto con el modelo y el optimizador al crear un punto de control y se pasará a [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback).

En toda esta clase, un paso debe entenderse como un paso de actualización. Al usar acumulación de gradientes, un paso de actualización puede requerir varias pasadas hacia adelante y hacia atrás: si usa `gradient_accumulation_steps=n`, entonces un paso de actualización requiere recorrer *n* lotes.

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

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

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

Calcula y almacena el valor absoluto para los pasos de registro, evaluación y guardado, en función de si se trataba de una proporción o no.

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

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

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

Almacena las referencias iniciales de entrenamiento necesarias en `self`

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

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

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

Cree una instancia a partir del contenido de `json_path`.

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

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

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

Guarde el contenido de esta instancia en formato JSON dentro de `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)
```

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

**Parámetros:**

should_training_stop (`bool`, *opcional*, valor predeterminado `False`) : Indica si el entrenamiento debe interrumpirse. Si es `True`, esta variable no se restablecerá a `False`. El entrenamiento simplemente se detendrá.

should_epoch_stop (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe interrumpir la época actual. Si es `True`, esta variable se restablecerá a `False` al inicio de la siguiente época.

should_save (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo debe guardarse en este paso. Si es `True`, esta variable se restablecerá a `False` al inicio del siguiente paso.

should_evaluate (`bool`, *opcional*, valor predeterminado `False`) : Indica si el modelo debe evaluarse en este paso. Si es `True`, esta variable se restablecerá a `False` al inicio del siguiente paso.

should_log (`bool`, *opcional*, valor predeterminado `False`) : Indica si los registros deben informarse en este paso. Si es `True`, esta variable se restablecerá a `False` al inicio del siguiente paso.

Una clase que gestiona el flujo de control de [Trainer](/docs/transformers/main/es/main_classes/trainer#transformers.Trainer). Esta clase es utilizada por [TrainerCallback](/docs/transformers/main/es/main_classes/callback#transformers.TrainerCallback) para activar algunos interruptores en el bucle de entrenamiento.