# Trainer

La clase [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) ofrece una API para el entrenamiento completo de características en PyTorch y admite el entrenamiento distribuido en varias GPUs/TPUs, la precisión mixta para [GPUs de NVIDIA](https://nvidia.github.io/apex/), [GPUs de AMD](https://rocm.docs.amd.com/en/latest/rocm.html) y [`torch.amp`](https://pytorch.org/docs/stable/amp.html) para PyTorch. [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) va de la mano con la clase [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments), que ofrece una amplia gama de opciones para personalizar cómo se entrena un modelo. Juntas, estas dos clases proporcionan una API de entrenamiento completa.

[Seq2SeqTrainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Seq2SeqTrainer) y [Seq2SeqTrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Seq2SeqTrainingArguments) heredan de las clases [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) y [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments) y están adaptados para entrenar modelos en tareas de secuencia a secuencia, como la resumición o la traducción.

La clase [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) está optimizada para los modelos de 🤗 Transformers y puede presentar comportamientos inesperados cuando se utiliza con otros modelos. Al usarla con su propio modelo, asegúrese de:

- su modelo siempre devuelve tuplas o subclases de [ModelOutput](/docs/transformers/v5.23.0/es/main_classes/output#transformers.utils.ModelOutput)
- su modelo puede calcular la pérdida si se proporciona un argumento `labels` y esa pérdida se devuelve como el primer elemento de la tupla (si su modelo devuelve tuplas)
- su modelo puede aceptar varios argumentos de etiqueta (use `label_names` en [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments) para indicar su nombre al [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer)) pero ninguno de ellos debe llamarse `"label"`

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

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

```python
transformers.Trainer(model: typing.Union[transformers.modeling_utils.PreTrainedModel, torch.nn.Module, NoneType] = None, args: transformers.training_args.TrainingArguments | None = None, data_collator: collections.abc.Callable[[list[typing.Any]], dict[str, typing.Any]] | None = None, train_dataset: Dataset | IterableDataset | datasets.Dataset | None = None, eval_dataset: Dataset | dict[str, Dataset] | datasets.Dataset | None = None, processing_class: transformers.tokenization_utils_base.PreTrainedTokenizerBase | transformers.image_processing_utils.BaseImageProcessor | transformers.feature_extraction_utils.FeatureExtractionMixin | transformers.processing_utils.ProcessorMixin | None = None, model_init: collections.abc.Callable[..., transformers.modeling_utils.PreTrainedModel] | None = None, compute_loss_func: collections.abc.Callable | None = None, compute_metrics: collections.abc.Callable[[transformers.trainer_utils.EvalPrediction], dict] | None = None, callbacks: list[transformers.trainer_callback.TrainerCallback] | None = None, optimizers: tuple[typing.Optional[torch.optim.Optimizer], typing.Optional[torch.optim.lr_scheduler.LambdaLR]] = (None, None), optimizer_cls_and_kwargs: tuple[type[torch.optim.Optimizer], dict[str, typing.Any]] | None = None, preprocess_logits_for_metrics: collections.abc.Callable[[torch.Tensor, torch.Tensor], torch.Tensor] | None = None)
```

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

**Parámetros:**

model ([PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel) o `torch.nn.Module`, *opcional*) : El modelo que se va a entrenar, evaluar o utilizar para las predicciones. Si no se proporciona, se debe pasar un `model_init`.    [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) está optimizado para funcionar con el [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel) que proporciona la biblioteca. Aún así, puedes usar tus propios modelos definidos como `torch.nn.Module` siempre que funcionen de la misma manera que los modelos de 🤗 Transformers.

args ([TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments), *opcional*) : Los argumentos para ajustar el entrenamiento. Si no se proporcionan, se utilizará una instancia básica de [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments) con `output_dir` establecido en un directorio llamado *tmp_trainer* en el directorio actual.

data_collator (`DataCollator`, *opcional*) : La función que se utilizará para formar un lote a partir de una lista de elementos de `train_dataset` o `eval_dataset`. Si no se proporciona `processing_class`, el valor predeterminado será [default_data_collator()](/docs/transformers/v5.23.0/es/main_classes/data_collator#transformers.default_data_collator); en caso contrario, si processing_class es un extractor de características o un tokenizador, se utilizará una instancia de [DataCollatorWithPadding](/docs/transformers/v5.23.0/es/main_classes/data_collator#transformers.DataCollatorWithPadding).

train_dataset (`torch.utils.data.Dataset` | `torch.utils.data.IterableDataset` | `datasets.Dataset`, *opcional*) : El conjunto de datos que se utilizará para el entrenamiento. Si es un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), las columnas no aceptadas por el método `model.forward()` se eliminan automáticamente. Tenga en cuenta que si es un `torch.utils.data.IterableDataset` con cierta aleatorización y está entrenando de forma distribuida, su conjunto de datos iterable debe usar un atributo interno `generator` que sea un `torch.Generator` para la aleatorización, que debe ser idéntico en todos los procesos (y el Trainer establecerá manualmente la semilla de este `generator` en cada época), o bien debe tener un método `set_epoch()` que establezca internamente la semilla de los RNG utilizados. Si el conjunto de datos no implementa `__len__` (por ejemplo, un `IterableDataset` de streaming), se debe establecer `max_steps`, ya que no se puede inferir el número total de pasos de entrenamiento.

eval_dataset (`torch.utils.data.Dataset` | dict[str, `torch.utils.data.Dataset`] | `datasets.Dataset`, *opcional*) : El conjunto de datos que se usará para la evaluación. Si es un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), las columnas no aceptadas por el método `model.forward()` se eliminan automáticamente. Si es un diccionario, se evaluará en cada conjunto de datos añadiendo la clave del diccionario al nombre de la métrica.

processing_class (`PreTrainedTokenizerBase` o `BaseImageProcessor` o `FeatureExtractionMixin` o `ProcessorMixin`, *opcional*) : Clase de procesamiento utilizada para procesar los datos. Si se proporciona, se usará para procesar automáticamente las entradas del modelo y se guardará junto con el modelo para facilitar la reanudación de un entrenamiento interrumpido o la reutilización del modelo afinado.

model_init (`Callable[[], PreTrainedModel]`, *opcional*) : Una función que instancia el modelo a utilizar. Si se proporciona, cada llamada a [train()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.train) comenzará desde una nueva instancia del modelo, tal como la define esta función. La función puede tener cero argumentos, o un único argumento que contenga el objeto de prueba de optuna/Ray Tune, para poder elegir diferentes arquitecturas según los hiperparámetros (como el número de capas, los tamaños de las capas internas, las probabilidades de dropout, etc.).

compute_loss_func (`Callable`, *opcional*) : Una función que acepta las salidas crudas del modelo, las etiquetas y el número de elementos en el lote acumulado completo (batch_size * gradient_accumulation_steps) y devuelve la pérdida. Por ejemplo, consulte la [función de pérdida](https://github.com/huggingface/transformers/blob/052e652d6d53c2b26ffde87e039b723949a53493/src/transformers/trainer.py#L3618) predeterminada utilizada por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer).

compute_metrics (`Callable[[EvalPrediction], Dict]`, *opcional*) : La función que se utilizará para calcular las métricas durante la evaluación. Debe recibir un [EvalPrediction](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.EvalPrediction) y devolver un diccionario de cadenas a valores de métricas. *Nota* Al pasar TrainingArgs con `batch_eval_metrics` establecido en `True`, la función compute_metrics debe recibir un argumento booleano `compute_result`. Esto se activará después del último lote de evaluación para indicar que la función debe calcular y devolver las estadísticas globales de resumen en lugar de acumular las estadísticas a nivel de lote

callbacks (Lista de [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback), *opcional*) : Una lista de callbacks para personalizar el bucle de entrenamiento. Se añadirán a la lista de callbacks predeterminados detallada en [aquí](callback). Si deseas eliminar uno de los callbacks predeterminados, utiliza el método [Trainer.remove_callback()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.remove_callback).

optimizers (`tuple[torch.optim.Optimizer, torch.optim.lr_scheduler.LambdaLR]`, *opcional*, valor predeterminado `(None, None)`) : Una tupla que contiene el optimizador y el programador a utilizar. Por defecto, se usará una instancia de `AdamW` en tu modelo y un programador definido por [get_linear_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) controlado por `args`.

optimizer_cls_and_kwargs (`tuple[Type[torch.optim.Optimizer], dict[str, Any]]`, *opcional*) : Una tupla que contiene la clase de optimizador y los argumentos de palabra clave a utilizar. Anula `optim` y `optim_args` en `args`. No es compatible con el argumento `optimizers`. A diferencia de `optimizers`, este argumento evita la necesidad de colocar los parámetros del modelo en los dispositivos correctos antes de inicializar el Trainer.

preprocess_logits_for_metrics (`Callable[[torch.Tensor, torch.Tensor], torch.Tensor]`, *opcional*) : Una función que preprocesa los logits justo antes de guardarlos en caché en cada paso de evaluación. Debe aceptar dos tensores, los logits y las etiquetas, y devolver los logits una vez procesados según se desee. Las modificaciones realizadas por esta función se reflejarán en las predicciones recibidas por `compute_metrics`. Tenga en cuenta que las etiquetas (segundo parámetro) serán `None` si el conjunto de datos no las tiene.

Trainer es un bucle de entrenamiento y evaluación simple pero completo para PyTorch, optimizado para 🤗 Transformers.

Atributos importantes:

- **model** -- Siempre apunta al modelo principal. Si se utiliza un modelo de transformers, será una subclase de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel).
- **model_wrapped** -- Siempre apunta al modelo más externo en caso de que uno o más módulos envuelvan al modelo original. Este es el modelo que debe usarse para la pasada hacia adelante. Por ejemplo, bajo `DeepSpeed`, el modelo interno se envuelve en `DeepSpeed` y luego de nuevo en `torch.nn.DistributedDataParallel`. Si el modelo interno no ha sido envuelto, entonces `self.model_wrapped` es igual a `self.model`.
- **is_model_parallel** -- Indica si un modelo se ha cambiado a un modo de paralelismo de modelo (a diferencia del paralelismo de datos, esto significa que algunas de las capas del modelo se dividen en diferentes GPUs).
- **place_model_on_device** -- Indica si se debe colocar el modelo automáticamente en el dispositivo. El valor predeterminado es `True`, a menos que esté activo el paralelismo de modelos, DeepSpeed, FSDP, la evaluación completa en fp16/bf16 o SageMaker MP. Se puede anular mediante la herencia de `TrainingArguments` y la sobrescritura de la propiedad `place_model_on_device`.
- **is_in_train** -- Indica si un modelo está ejecutando actualmente `train` (por ejemplo, cuando se llama a `evaluate` durante `train`)
- **loss_is_scaled_for_ga** -- Indica si la pérdida devuelta por `compute_loss` ya está escalada para la acumulación de gradientes. `True`: `training_step` la utiliza tal cual. `False`: `training_step` la divide entre el número de pasos de acumulación de gradientes. `None` (valor predeterminado): la pérdida se considera escalada si se normalizó por `num_items_in_batch`, es decir, si el modelo acepta argumentos de pérdida o se pasa un `compute_loss_func`. Las subclases que calculan su propia pérdida deben establecerlo.

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

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

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

**Parámetros:**

callback (`type` o [`~transformers.TrainerCallback]`) : Una clase [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback) o una instancia de [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback). En el primer caso, se instanciará un miembro de esa clase.

Agregue un callback a la lista actual de [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback).

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

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

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

Un envoltorio auxiliar que crea un gestor de contexto adecuado para `autocast` mientras le proporciona los argumentos deseados, según la situación. Nos basamos en accelerate para autocast, por lo que no hacemos nada aquí.

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

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

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

Llama a `model_init` para obtener una nueva instancia del modelo, opcionalmente condicionada a un ensayo de hiperparámetros.

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

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

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

**Parámetros:**

model (`nn.Module`) : El modelo para el que se debe calcular la pérdida.

inputs (`dict[str, torch.Tensor | Any]`) : Los datos de entrada para el modelo.

return_outputs (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben devolver las salidas del modelo junto con la pérdida.

num_items_in_batch (Optional[torch.Tensor], *opcional*) : El número de elementos en el lote. Si no se pasa, la pérdida se calcula usando la lógica de reducción de tamaño de lote predeterminada.

**Devuelve:**

La pérdida del modelo junto con su salida si return_outputs se estableció en True

Cómo se calcula la pérdida por Trainer. Por defecto, todos los modelos devuelven la pérdida en el primer elemento.

Subclase y sobrescribe para un comportamiento personalizado. Si calculas tu propia pérdida, establece `loss_is_scaled_for_ga` para indicar si ya está escalada para la acumulación de gradientes: `False` si es una media por lote (el Trainer luego la divide por el número de pasos de acumulación de gradientes), `True` si ya la normalizaste sobre el lote acumulado completo.

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

```python
compute_loss_context_manager()
```

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

Un envoltorio auxiliar para agrupar administradores de contexto.

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

```python
create_accelerator_and_postprocess()
```

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

Cree el acelerador y realice la configuración posterior a la creación (FSDP, DeepSpeed, etc.).

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

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

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

**Parámetros:**

language (`str`, *opcional*) : El idioma del modelo (si aplica)

license (`str`, *opcional*) : La licencia del modelo. Si el modelo original dado al `Trainer` proviene de un repositorio en el Hub, se usará por defecto la licencia del modelo preentrenado utilizado.

tags (`str` o `list[str]`, *opcional*) : Algunas etiquetas que se incluirán en los metadatos de la tarjeta del modelo.

model_name (`str`, *opcional*) : El nombre del modelo.

finetuned_from (`str`, *opcional*) : El nombre del modelo utilizado para afinar este modelo (si aplica). Por defecto, será el nombre del repositorio del modelo original proporcionado al `Trainer` (si proviene del Hub).

tasks (`str` o `list[str]`, *opcional*) : Uno o varios identificadores de tareas, que se incluirán en los metadatos de la tarjeta del modelo.

dataset_tags (`str` o `list[str]`, *opcional*) : Una o varias etiquetas de conjunto de datos, que se incluirán en los metadatos de la tarjeta del modelo.

dataset (`str` o `list[str]`, *opcional*) : Uno o varios identificadores de conjuntos de datos, que se incluirán en los metadatos de la tarjeta del modelo.

dataset_args (`str` o `list[str]`, *opcional*) : Uno o varios argumentos de conjunto de datos, que se incluirán en los metadatos de la tarjeta del modelo.

Crea un borrador de una tarjeta de modelo utilizando la información disponible en el `Trainer`.

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

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

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

**Devuelve:** `torch.optim.Optimizer`

La instancia del optimizador.

Configura el optimizador.

Proporcionamos un valor predeterminado razonable que funciona bien. Si desea usar algo diferente, puede pasar una tupla en la inicialización de Trainer a través de `optimizers`, o crear una subclase y sobrescribir este método en ella.

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

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

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

Configura el optimizador y el programador de la tasa de aprendizaje.

Proporcionamos un valor predeterminado razonable que funciona bien. Si desea usar algo diferente, puede pasar una tupla en la inicialización de Trainer a través de `optimizers`, o crear una subclase y sobrescribir este método (o `create_optimizer` y/o `create_scheduler`) en una subclase.

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

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

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

**Parámetros:**

num_training_steps (int) : El número de pasos de entrenamiento a realizar.

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

La instancia del programador de tasa de aprendizaje.

Configura el programador. El optimizador del entrenador debe haberse configurado antes de llamar a este método o bien pasarse como argumento.

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

```python
end()
```

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

Finaliza los trackers y destruye el grupo de procesos distribuidos.

Llámalo una sola vez, al final de un script, después de todo lo que necesite a los otros procesos: [train()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.train), [evaluate()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.evaluate), [predict()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.predict), [save_model()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.save_model) y [push_to_hub()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.push_to_hub) se comunican entre procesos y fallarán una vez que el grupo haya desaparecido.

Ejemplo:

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

#### evaluar[[transformers.Trainer.evaluate]]

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

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

**Parámetros:**

eval_dataset (`Dataset` | dict[str, `Dataset`], *opcional*) : Pasa un dataset si deseas sobrescribir `self.eval_dataset`. Si es un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), las columnas no aceptadas por el método `model.forward()` se eliminan automáticamente. Si es un diccionario, se evaluará en cada dataset, añadiendo la clave del diccionario al nombre de la métrica.    Si pasas un diccionario con los nombres de los datasets como claves y los datasets como valores, evaluate ejecutará evaluaciones separadas en cada dataset. Esto puede ser útil para monitorear cómo afecta el entrenamiento a otros datasets o simplemente para obtener una evaluación más detallada. Cuando se usa con `load_best_model_at_end`, asegúrate de que `metric_for_best_model` haga referencia a exactamente uno de los datasets. Por ejemplo, si pasas `{"data1": data1, "data2": data2}` para dos datasets `data1` y `data2`, podrías especificar `metric_for_best_model="eval_data1_loss"` para usar la pérdida en `data1` y `metric_for_best_model="eval_data2_loss"` para la pérdida en `data2`.

ignore_keys (`list[str]`, *opcional*) : Una lista de claves en la salida de su modelo (si es un diccionario) que deben ignorarse al recopilar predicciones.

metric_key_prefix (`str`, *opcional*, valor predeterminado `"eval"`) : Un prefijo opcional que se usará como prefijo de la clave de las métricas. Por ejemplo, la métrica "bleu" se llamará "eval_bleu" si el prefijo es "eval" (predeterminado)

**Devuelve:**

Un diccionario que contiene la pérdida de evaluación y las métricas potenciales calculadas a partir de las predicciones. El diccionario también contiene el número de época, que proviene del estado de entrenamiento.

Ejecuta la evaluación y devuelve las métricas.

El script de invocación será responsable de proporcionar un método para calcular las métricas, ya que dependen de la tarea (pásalo al argumento `compute_metrics` de init).

También puede subclasear y sobrescribir este método para inyectar un comportamiento personalizado.

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

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

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

Bucle de predicción/evaluación, compartido por `Trainer.evaluate()` y `Trainer.predict()`.

Funciona tanto con etiquetas como sin ellas.

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

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

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

**Parámetros:**

inputs (`dict[str, torch.Tensor | Any]`) : Las entradas y los objetivos del modelo.

**Devuelve:** `int`

El número de operaciones de punto flotante.

Para los modelos que heredan de [PreTrainedModel](/docs/transformers/v5.23.0/es/main_classes/model#transformers.PreTrainedModel), utiliza ese método para calcular el número de operaciones de punto flotante de cada pasada de retropropagación + propagación hacia adelante. Si se utiliza otro modelo, implemente dicho método en el modelo o cree una subclase y anule este método.

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

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

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

Recoge un número especificado de lotes del iterador de la época y, opcionalmente, cuenta el número de elementos en los lotes para escalar adecuadamente la pérdida.

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

```python
get_cp_size()
```

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

Obtener el tamaño de paralelismo de contexto

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

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

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

Obtén todos los nombres de parámetros a los que se aplicará el decaimiento de peso.

Esta función filtra los parámetros de dos maneras:
1. Por tipo de capa (instancias de capas especificadas en ALL_LAYERNORM_LAYERS)
2. Por patrones de nombres de parámetros (que contienen 'bias' o una variación de 'norm')

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

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

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

**Parámetros:**

eval_dataset (`str` o `torch.utils.data.Dataset`, *opcional*) : Si es una `str`, se usará `self.eval_dataset[eval_dataset]` como conjunto de evaluación. Si es un `Dataset`, se reemplazará `self.eval_dataset`. Si es un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), las columnas no aceptadas por el método `model.forward()` se eliminan automáticamente.

Devuelve el `~torch.utils.data.DataLoader` de evaluación.

Subclase este método y sobrescríbelo si deseas inyectar algún comportamiento personalizado.

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

```python
get_learning_rates()
```

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

Devuelve la tasa de aprendizaje de cada parámetro de self.optimizer.

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

```python
get_num_trainable_parameters()
```

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

Obtén el número de parámetros entrenables.

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

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

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

**Parámetros:**

args (`transformers.training_args.TrainingArguments`) : Los argumentos de entrenamiento para la sesión de entrenamiento.

model (`PreTrainedModel`, *opcional*) : El modelo que se está entrenando. Es obligatorio para algunos optimizadores (GaLore, Apollo, LOMO).

**Devuelve:**

Una tupla que contiene la clase del optimizador y un diccionario de argumentos de palabras clave del optimizador.

Devuelve la clase de optimizador y los parámetros del optimizador en función de los argumentos de entrenamiento.

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

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

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

**Parámetros:**

param (`str` o `torch.nn.parameter.Parameter`, *opcional*) : El parámetro para el que se debe devolver el grupo de optimizador.

Devuelve el grupo de optimizador para un parámetro si se proporciona, en caso contrario devuelve todos los grupos de optimizador para los parámetros.

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

```python
get_sp_size()
```

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

Obtener el tamaño de paralelismo de secuencia

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

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

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

**Parámetros:**

test_dataset (`torch.utils.data.Dataset`, *opcional*) : El conjunto de datos de prueba que se utilizará. Si es un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), las columnas no aceptadas por el método `model.forward()` se eliminan automáticamente.

Devuelve el `~torch.utils.data.DataLoader` de prueba.

Subclase este método y sobrescríbelo si deseas inyectar algún comportamiento personalizado.

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

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

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

Calcula el tamaño total del lote (micro_batch * grad_accum * dp_world_size).

Cuentas con todas las dimensiones de paralelismo: TP, CP y SP.

Fórmula: dp_world_size = world_size // (tp_size * cp_size * sp_size)

Donde:
- TP (Paralelismo de tensores): Las capas del modelo se dividen entre varias GPU
- CP (Paralelismo de contexto): Secuencias divididas mediante Ring Attention (FSDP2)
- SP (Paralelismo de secuencias): Secuencias divididas mediante ALST/Ulysses (DeepSpeed)

Todas las dimensiones son independientes y multiplicativas: world_size = dp_size * tp_size * cp_size * sp_size

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

```python
get_tp_size()
```

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

Obtenga el tamaño de paralelismo de tensores desde la configuración del modelo o de DeepSpeed.

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

```python
get_train_dataloader()
```

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

Devuelve el `~torch.utils.data.DataLoader` de entrenamiento.

No se usará ningún muestreador si `train_dataset` no implementa `__len__`; en caso contrario, se usará un muestreador aleatorio (adaptado al entrenamiento distribuido si es necesario).

Subclase este método y sobrescríbelo si deseas inyectar algún comportamiento personalizado.

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

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

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

**Parámetros:**

hp_space (`Callable[["optuna.Trial"], dict[str, float]]`, *opcional*) : Una función que define el espacio de búsqueda de hiperparámetros. Por defecto, será `default_hp_space_optuna()` o `default_hp_space_ray()` según el backend que utilices.

compute_objective (`Callable[[dict[str, float]], float]`, *opcional*) : Una función que calcula el objetivo a minimizar o maximizar a partir de las métricas devueltas por el método `evaluate`. Por defecto, se usará `default_compute_objective()`.

n_trials (`int`, *opcional*, valor predeterminado 100) : El número de ejecuciones de prueba para realizar la prueba.

direction (`str` o `list[str]`, *opcional*, valor predeterminado `"minimize"`) : Si es una optimización de un solo objetivo, direction es `str`, puede ser `"minimize"` o `"maximize"`, debe elegir `"minimize"` al optimizar la pérdida de validación y `"maximize"` al optimizar una o varias métricas. Si es una optimización de múltiples objetivos, direction es `list[str]`, puede ser una lista de `"minimize"` y `"maximize"`, debe elegir `"minimize"` al optimizar la pérdida de validación y `"maximize"` al optimizar una o varias métricas.

backend (`str` o `~training_utils.HPSearchBackend`, *opcional*) : El backend que se usará para la búsqueda de hiperparámetros. Por defecto, se usará optuna o Ray Tune, dependiendo de cuál esté instalado. Si ambos están instalados, se usará optuna por defecto.

hp_name (`Callable[["optuna.Trial"], str]]`, *opcional*) : Una función que define el nombre del ensayo/ejecución. El valor predeterminado es None.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabras clave adicionales para cada backend:  - `optuna`: parámetros de [optuna.study.create_study](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.create_study.html) y también los parámetros `timeout`, `n_jobs` y `gc_after_trial` de [optuna.study.Study.optimize](https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.Study.html#optuna.study.Study.optimize) - `ray`: parámetros de [tune.run](https://docs.ray.io/en/latest/tune/api_docs/execution.html#tune-run). Si `resources_per_trial` no se establece en `kwargs`, el valor predeterminado es 1 núcleo de CPU y 1 GPU (si está disponible). Si `progress_reporter` no se establece en `kwargs`, se utiliza [ray.tune.CLIReporter](https://docs.ray.io/en/latest/tune/api/doc/ray.tune.CLIReporter.html).

**Devuelve:** [`trainer_utils.BestRun` o `list[trainer_utils.BestRun]`]

Toda la información sobre la mejor ejecución o las mejores ejecuciones para la optimización multiobjetivo. El resumen del experimento se puede encontrar en el atributo `run_summary` para el backend de Ray.

Inicie una búsqueda de hiperparámetros con `optuna` o `Ray Tune`. La cantidad optimizada la determina `compute_objective`, que por defecto es una función que devuelve la pérdida de evaluación cuando no se proporciona ninguna métrica, o la suma de todas las métricas en caso contrario.

Para usar este método, debes haber proporcionado un `model_init` al inicializar tu [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer): es necesario reinicializar el modelo en cada nueva ejecución. Esto es incompatible con el argumento `optimizers`, por lo que necesitas subclasear [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) y sobrescribir el método [create_optimizer_and_scheduler()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.create_optimizer_and_scheduler) para un optimizador/planificador personalizado.

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

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

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

**Parámetros:**

token (`str`, *opcional*) : Token con permiso de escritura. El valor predeterminado es `self.args.hub_token`.

private (`bool`, *opcional*) : Si se debe hacer privada la repositorio al crearse. El valor predeterminado es `self.args.hub_private_repo`. No tiene efecto si la repositorio ya existe.

Inicializa un repositorio git en `self.args.hub_model_id`.

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

```python
is_local_process_zero()
```

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

Si este proceso es o no 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[[transformers.Trainer.is_world_process_zero]]

```python
is_world_process_zero()
```

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

Si este proceso es o no el proceso principal global (cuando se entrena de forma distribuida en varias máquinas, esto solo será `True` para un proceso).

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

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

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

**Parámetros:**

logs (`dict[str, float]`) : Los valores que se registrarán.

start_time (`Optional[float]`) : El inicio del entrenamiento.

Registra `logs` en los distintos objetos que supervisan el entrenamiento.

Subclase este método y sobrescríbelo para inyectar un comportamiento personalizado.

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

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

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

**Parámetros:**

split (`str`) : Nombre del modo/división: uno de `train`, `eval`, `test`

metrics (`dict[str, float]`) : Las métricas devueltas por train/evaluate/predictmetrics: dict de métricas

Registra las métricas de una manera especialmente formateada.

En un entorno distribuido, esto se realiza solo para un proceso con rango 0.

Notas sobre los informes de memoria:

Para obtener un informe del uso de memoria, es necesario instalar `psutil`. Puedes hacerlo con `pip install psutil`.

Ahora, cuando se ejecuta este método, se mostrará un informe que incluirá:

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

**Comprensión de los informes:**

- el primer segmento, por ejemplo, `train__`, indica para qué etapa son las métricas. Los informes que comienzan con `init_` se añadirán a la primera etapa que se ejecute. De modo que, si solo se ejecuta la evaluación, el uso de memoria de `__init__` se reportará junto con las métricas de `eval_`.
- el tercer segmento, que es `cpu` o `gpu`, indica si se trata de la métrica de RAM general o de la memoria de gpu0.
- `*_alloc_delta` - es la diferencia en el contador de memoria usada/allocada entre el final y el inicio de la etapa; puede ser negativa si una función liberó más memoria de la que asignó.
- `*_peaked_delta` - es cualquier memoria adicional que se consumió y luego se liberó - en relación con el contador de memoria asignada actual - nunca es negativa. Al revisar las métricas de cualquier etapa, se suma `alloc_delta` + `peaked_delta` y se sabe cuánta memoria se necesitó para completar esa etapa.

El informe se genera únicamente para el proceso de rango 0 y la gpu 0 (si hay una gpu). Por lo general, esto es suficiente, ya que el proceso principal realiza la mayor parte del trabajo, pero podría no ser así si se usa paralelismo de modelo, ya que otras GPUs pueden usar una cantidad diferente de memoria de gpu. Esto tampoco es lo mismo con DataParallel, donde la gpu0 puede requerir mucha más memoria que el resto, ya que almacena los gradientes y los estados del optimizador para todas las GPUs participantes. Quizás en el futuro estos informes evolucionen para medir también esos valores.

La métrica de RAM de CPU mide el RSS (Resident Set Size), que incluye tanto la memoria exclusiva del proceso como la memoria compartida con otros procesos. Es importante tener en cuenta que no incluye la memoria intercambiada (swapped out), por lo que los informes podrían ser imprecisos.

La memoria máxima de la CPU se mide mediante un hilo de muestreo. Debido al GIL de Python, es posible que se pierda parte de la memoria máxima si ese hilo no tuvo la oportunidad de ejecutarse cuando se alcanzó el mayor uso de memoria. Por lo tanto, este informe puede ser inferior a la realidad. El uso de `tracemalloc` habría reportado la memoria máxima exacta, pero no informa sobre las asignaciones de memoria fuera de Python. Así, si alguna extensión de C++ o CUDA asignó su propia memoria, no se reportará. Por esta razón, se descartó en favor del enfoque de muestreo de memoria, que lee el uso actual de memoria del proceso.

La asignación de GPU y el informe de memoria pico se realizan con `torch.cuda.memory_allocated()` y `torch.cuda.max_memory_allocated()`. Esta métrica solo informa sobre "deltas" para las asignaciones específicas de PyTorch, ya que el sistema de gestión de memoria de `torch.cuda` no rastrea ninguna memoria asignada fuera de PyTorch. Por ejemplo, la primera llamada a CUDA suele cargar los kernels de CUDA, lo que puede requerir entre 0,5 y 2 GB de memoria de GPU.

Tenga en cuenta que este rastreador no tiene en cuenta las asignaciones de memoria que se producen fuera de las llamadas a `__init__`, `train`, `evaluate` y `predict` de [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer).

Como las llamadas a `evaluation` pueden producirse durante `train`, no podemos manejar invocaciones anidadas porque `torch.cuda.max_memory_allocated` es un contador único; por lo tanto, si se restablece mediante una llamada anidada de eval, el rastreador de `train` informará datos incorrectos. Si este [problema de pytorch](https://github.com/pytorch/pytorch/issues/16266) se resuelve, será posible modificar esta clase para que sea reentrante. Hasta entonces, solo rastrearemos el nivel externo de los métodos `train`, `evaluate` y `predict`. Esto significa que si `eval` se llama durante `train`, será este último el que contabilice su uso de memoria y el de aquél.

Esto también significa que si cualquier otra herramienta que se utilice junto con [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) llama a `torch.cuda.reset_peak_memory_stats`, las estadísticas de memoria máxima de la GPU podrían ser inválidas. Y [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer) alterará el comportamiento normal de cualquier herramienta de este tipo que dependa de llamar a `torch.cuda.reset_peak_memory_stats` por sí misma.

Para obtener el mejor rendimiento, es posible que desee desactivar el perfilado de memoria en las ejecuciones de producción.

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

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

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

**Parámetros:**

metrics (`dict[str, float]`) : Las métricas devueltas por train/evaluate/predict

**Devuelve:** métricas (`dict[str, float]`)

Las métricas reformateadas

Reformatea los valores de las métricas de Trainer a un formato legible para humanos.

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

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

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

Función auxiliar para obtener el número de muestras en un `~torch.utils.data.DataLoader` accediendo a su dataset. Si dataloader.dataset no existe o no tiene longitud, estima el valor lo mejor que puede

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

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

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

**Parámetros:**

callback (`type` o [`~transformers.TrainerCallback]`) : Una clase [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback) o una instancia de [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback). En el primer caso, se eliminará el primer miembro de esa clase encontrado en la lista de callbacks.

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

El callback eliminado, si se encuentra.

Elimina un callback de la lista actual de [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback) y lo devuelve.

Si no se encuentra el callback, devuelve `None` (y no se lanza ningún error).

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

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

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

**Parámetros:**

test_dataset (`Dataset`) : Conjunto de datos sobre el que se ejecutarán las predicciones. Si es un `datasets.Dataset`, las columnas no aceptadas por el método `model.forward()` se eliminan automáticamente.

ignore_keys (`list[str]`, *opcional*) : Una lista de claves en la salida de su modelo (si es un diccionario) que deben ignorarse al recopilar predicciones.

metric_key_prefix (`str`, *opcional*, valor predeterminado `"test"`) : Un prefijo opcional que se usará como prefijo de la clave de las métricas. Por ejemplo, la métrica "bleu" se llamará "test_bleu" si el prefijo es "test" (predeterminado)

Ejecuta la predicción y devuelve las predicciones y las métricas potenciales.

Dependiendo del conjunto de datos y de tu caso de uso, tu conjunto de datos de prueba puede contener etiquetas. En ese caso, este método también devolverá métricas, como en `evaluate()`.

Si tus predicciones o etiquetas tienen una longitud de secuencia diferente (por ejemplo, porque estás aplicando relleno dinámico en una tarea de clasificación de tokens), las predicciones se rellenarán (a la derecha) para permitir su concatenación en un solo array. El índice de relleno es -100.

Devuelve: *NamedTuple* Una namedtuple con las siguientes claves:

- predictions (`np.ndarray`): Las predicciones sobre `test_dataset`.
- label_ids (`np.ndarray`, *opcional*): Las etiquetas (si el conjunto de datos las contenía).
- metrics (`dict[str, float]`, *opcional*): El diccionario potencial de métricas (si el conjunto de datos contenía etiquetas).

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

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

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

**Parámetros:**

model (`nn.Module`) : El modelo a evaluar.

inputs (`dict[str, torch.Tensor | Any]`) : Las entradas y los objetivos del modelo. El diccionario se desempaquetará antes de pasarse al modelo. La mayoría de los modelos esperan los objetivos bajo el argumento `labels`. Consulte la documentación de su modelo para conocer todos los argumentos aceptados.

prediction_loss_only (`bool`) : Indica si se debe devolver solo la pérdida.

ignore_keys (`list[str]`, *opcional*) : Una lista de claves en la salida de su modelo (si es un diccionario) que deben ignorarse al recopilar predicciones.

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

Una tupla con la pérdida, los logits y las etiquetas (cada uno opcional).

Realiza un paso de evaluación en `model` usando `inputs`.

Subclase y sobrescribe para inyectar comportamiento personalizado.

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

```python
push_to_hub(commit_message: str | None = 'End of training', blocking: bool = True, token: str | None = None, revision: str | None = None, private: bool | None = None, **kwargs)
```

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

**Parámetros:**

commit_message (`str`, *opcional*, por defecto `"End of training"`) : Mensaje para el commit al hacer push.

blocking (`bool`, *opcional*, valor predeterminado `True`) : Indica si la función debe devolver el control solo cuando se haya completado el `git push`.

token (`str`, *opcional*, valor predeterminado `None`) : Token con permiso de escritura para sobrescribir los argumentos originales de Trainer.

revision (`str`, *opcional*) : La revisión de git desde la que se realizará el commit. El valor predeterminado es el final de la rama "main".

private (`bool`, *opcional*) : Indica si se debe hacer privada la repositorio al crearse. El valor predeterminado es `args.hub_private_repo`. No tiene efecto si la repositorio ya existe.

kwargs (`dict[str, Any]`, *opcional*) : Argumentos de palabra clave adicionales que se pasan a [create_model_card()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.create_model_card).

**Devuelve:**

La URL del repositorio donde se subió el modelo si `blocking=False`, o un objeto `Future` que sigue el progreso del commit si `blocking=True`.

Sube `self.model` y `self.processing_class` al hub de modelos de 🤗 en el repositorio `self.args.hub_model_id`.

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

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

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

**Parámetros:**

callback (`type` o [`~transformers.TrainerCallback]`) : Una clase [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback) o una instancia de [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback). En el primer caso, se eliminará el primer miembro de esa clase encontrado en la lista de callbacks.

Eliminar un callback de la lista actual de [TrainerCallback](/docs/transformers/v5.23.0/es/main_classes/callback#transformers.TrainerCallback).

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

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

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

**Parámetros:**

split (`str`) : Nombre del modo/división: uno de `train`, `eval`, `test`, `all`

metrics (`dict[str, float]`) : Las métricas devueltas por train/evaluate/predict

combined (`bool`, *opcional*, valor predeterminado `True`) : Crea métricas combinadas actualizando `all_results.json` con las métricas de esta llamada

Guarde las métricas en un archivo json para esa división, por ejemplo, `train_results.json`.

En un entorno distribuido, esto se realiza solo para un proceso con rango 0.

Para comprender las métricas, lea la docstring de [log_metrics()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.log_metrics). La única diferencia es que en el método actual se guardan números crudos sin formatear.

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

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

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

Guardará el modelo, por lo que podrás recargarlo usando `from_pretrained()`.

Solo se guardará desde el proceso principal.

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

```python
save_state()
```

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

Guarda el estado del Trainer, ya que Trainer.save_model solo guarda el tokenizer con el modelo.

En un entorno distribuido, esto se realiza solo para un proceso con rango 0.

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

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

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

Calcula y devuelve los siguientes valores:
- `num_train_epochs`
- `num_update_steps_per_epoch`
- `num_examples`
- `num_train_samples`
- `total_train_batch_size`
- `steps_in_epoch` (lotes totales por época)
- `max_steps`

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

```python
store_flos()
```

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

Almacene el número de operaciones de punto flotante que se utilizaron en el modelo.

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

```python
train(resume_from_checkpoint: str | bool | None = None, trial: optuna.Trial | dict[str, Any] | None = None, ignore_keys_for_eval: list[str] | None = None)
```

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

**Parámetros:**

resume_from_checkpoint (`str` o `bool`, *opcional*) : Si es una `str`, ruta local a un punto de control guardado por una instancia anterior de [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer). Si es un `bool` y es igual a `True`, carga el último punto de control en *args.output_dir* guardado por una instancia anterior de [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer). Si está presente, el entrenamiento se reanudará desde los estados del modelo/optimizador/planificador cargados aquí.

trial (`optuna.Trial` o `dict[str, Any]`, *opcional*) : La ejecución del ensayo o el diccionario de hiperparámetros para la búsqueda de hiperparámetros.

ignore_keys_for_eval (`list[str]`, *opcional*) : Una lista de claves en la salida de su modelo (si es un diccionario) que deben ignorarse al recopilar predicciones para la evaluación durante el entrenamiento.

**Devuelve:** `TrainOutput`

Objeto que contiene el número de pasos globales, la pérdida de entrenamiento y las métricas.

Punto de entrada principal del entrenamiento.

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

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

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

**Parámetros:**

model (`nn.Module`) : El modelo que se va a entrenar.

inputs (`dict[str, torch.Tensor | Any]`) : Las entradas y los objetivos del modelo. El diccionario se desempaquetará antes de pasarse al modelo. La mayoría de los modelos esperan los objetivos bajo el argumento `labels`. Consulte la documentación de su modelo para conocer todos los argumentos aceptados.

**Devuelve:** `torch.Tensor`

El tensor con la pérdida de entrenamiento en este lote.

Realiza un paso de entrenamiento en un lote de entradas.

Subclase y sobrescribe para inyectar comportamiento personalizado.

## Seq2SeqTrainer[[transformers.Seq2SeqTrainer]]

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

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

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

#### evaluar[[transformers.Seq2SeqTrainer.evaluate]]

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

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

**Parámetros:**

eval_dataset (`Dataset`, *opcional*) : Pasa un dataset si deseas sobrescribir `self.eval_dataset`. Si es un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), las columnas no aceptadas por el método `model.forward()` se eliminan automáticamente. Debe implementar el método `__len__`.

ignore_keys (`list[str]`, *opcional*) : Una lista de claves en la salida de su modelo (si es un diccionario) que deben ignorarse al recopilar predicciones.

metric_key_prefix (`str`, *opcional*, valor predeterminado `"eval"`) : Un prefijo opcional que se usará como prefijo de la clave de las métricas. Por ejemplo, la métrica "bleu" se llamará "eval_bleu" si el prefijo es `"eval"` (predeterminado)

max_length (`int`, *opcional*) : La longitud máxima objetivo a utilizar al predecir con el método generate.

num_beams (`int`, *opcional*) : Número de haces para la búsqueda por haces que se utilizará al predecir con el método generate. 1 significa que no se realiza búsqueda por haces.

gen_kwargs : Palabras clave adicionales específicas de `generate`.

**Devuelve:**

Un diccionario que contiene la pérdida de evaluación y las métricas potenciales calculadas a partir de las predicciones. El diccionario también contiene el número de época, que proviene del estado de entrenamiento.

Ejecuta la evaluación y devuelve las métricas.

El script de invocación será responsable de proporcionar un método para calcular las métricas, ya que dependen de la tarea (pásalo al argumento `compute_metrics` de init).

También puede subclasear y sobrescribir este método para inyectar un comportamiento personalizado.

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

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

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

**Parámetros:**

test_dataset (`Dataset`) : Dataset sobre el que se ejecutarán las predicciones. Si es un [Dataset](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset), las columnas no aceptadas por el método `model.forward()` se eliminan automáticamente. Debe implementar el método `__len__`

ignore_keys (`list[str]`, *opcional*) : Una lista de claves en la salida de su modelo (si es un diccionario) que deben ignorarse al recopilar predicciones.

metric_key_prefix (`str`, *opcional*, valor predeterminado `"eval"`) : Un prefijo opcional que se usará como prefijo de la clave de las métricas. Por ejemplo, la métrica "bleu" se llamará "eval_bleu" si el prefijo es `"eval"` (predeterminado)

max_length (`int`, *opcional*) : La longitud máxima objetivo a utilizar al predecir con el método generate.

num_beams (`int`, *opcional*) : Número de haces para la búsqueda por haces que se utilizará al predecir con el método generate. 1 significa que no se realiza búsqueda por haces.

gen_kwargs : Palabras clave adicionales específicas de `generate`.

Ejecuta la predicción y devuelve las predicciones y las métricas potenciales.

Dependiendo del conjunto de datos y de tu caso de uso, tu conjunto de datos de prueba puede contener etiquetas. En ese caso, este método también devolverá métricas, como en `evaluate()`.

Si tus predicciones o etiquetas tienen longitudes de secuencia diferentes (por ejemplo, porque estás aplicando relleno dinámico en una tarea de clasificación de tokens), las predicciones se rellenarán (a la derecha) para permitir su concatenación en un solo array. El índice de relleno es -100.

Devuelve: *NamedTuple* Una namedtuple con las siguientes claves:

- predictions (`np.ndarray`): Las predicciones sobre `test_dataset`.
- label_ids (`np.ndarray`, *opcional*): Las etiquetas (si el conjunto de datos las contenía).
- metrics (`dict[str, float]`, *opcional*): El diccionario potencial de métricas (si el conjunto de datos contenía etiquetas).

## TrainingArguments[[transformers.TrainingArguments]]

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

```python
transformers.TrainingArguments(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 5e-05, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool = False, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 500, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: typing.Any | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1)
```

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

**Parámetros:**

output_dir (`str`, *opcional*, valor predeterminado `"trainer_output"`) : El directorio de salida donde se escribirán las predicciones del modelo y los puntos de control.

**Duración del entrenamiento y tamaño del lote:**

per_device_train_batch_size (`int`, *opcional*, valor predeterminado 8) : El tamaño del lote *por dispositivo*. El **tamaño de lote global** se calcula como: `per_device_train_batch_size * number_of_devices` en configuraciones multi-GPU o distribuidas.

num_train_epochs(`float`, *opcional*, valor predeterminado 3.0) : Número total de épocas de entrenamiento a realizar (si no es un número entero, se ejecutará el porcentaje correspondiente a la parte decimal de la última época antes de detener el entrenamiento).

max_steps (`int`, *opcional*, valor predeterminado: -1) : Anula `num_train_epochs`. Si se establece en un número positivo, indica el número total de pasos de entrenamiento a realizar. Para un conjunto de datos finito, el entrenamiento se repite a través del conjunto de datos (si se agota todos los datos) hasta alcanzar `max_steps`. Debe establecerse en un valor positivo cuando el conjunto de datos de entrenamiento no implementa `__len__` (por ejemplo, un conjunto de datos de streaming), ya que en ese caso no se puede inferir el número total de pasos y se necesita para acotar el bucle de entrenamiento y configurar el programador de la tasa de aprendizaje.

**Tasa de aprendizaje y programador:**

learning_rate (`float`, *opcional*, valor predeterminado 5e-5) : La tasa de aprendizaje inicial del optimizador. Normalmente, esta es la tasa de aprendizaje máxima al usar un programador con calentamiento.

lr_scheduler_type (`str` o [SchedulerType](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.SchedulerType), *opcional*, valor predeterminado `"linear"`) : El tipo de programador de tasa de aprendizaje a utilizar. Consulte [SchedulerType](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.SchedulerType) para ver todos los valores posibles. Opciones comunes: - "linear" = [get_linear_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) - "cosine" = [get_cosine_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_cosine_schedule_with_warmup) - "constant" =  [get_constant_schedule()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_constant_schedule) - "constant_with_warmup" = [get_constant_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_constant_schedule_with_warmup)

lr_scheduler_kwargs (`dict` o `str`, *opcional*, valor predeterminado `None`) : Los argumentos adicionales para el lr_scheduler. Consulte la documentación de cada scheduler para conocer los valores posibles.

warmup_steps (`int` o `float`, *opcional*, valor predeterminado 0) : Número de pasos para un calentamiento lineal desde 0 hasta `learning_rate`. El calentamiento ayuda a estabilizar el entrenamiento en la fase inicial. Puede ser: - Un entero: número exacto de pasos de calentamiento - Un float en el rango [0, 1): se interpreta como la proporción de los pasos totales de entrenamiento

**Optimizador:**

optim (`str` o `training_args.OptimizerNames`, *opcional*, valor predeterminado `"adamw_torch"` (para torch>=2.8 `"adamw_torch_fused"`)) : El optimizador a utilizar. Opciones comunes: - `"adamw_torch"`: AdamW de PyTorch (predeterminado recomendado) - `"adamw_torch_fused"`: Núcleo de AdamW fusionado - `"adamw_hf"`: Implementación de AdamW de HuggingFace - `"sgd"`: Descenso de gradiente estocástico con momento - `"adafactor"`: Optimizador eficiente en memoria para modelos grandes - `"adamw_8bit"`: AdamW de 8 bits (requiere bitsandbytes) Consulte `OptimizerNames` para la lista completa.

optim_args (`str`, *opcional*) : Argumentos opcionales que se proporcionan a optimizadores como AnyPrecisionAdamW, AdEMAMix y GaLore.

weight_decay (`float`, *opcional*, valor predeterminado 0) : Coeficiente de decaimiento de peso aplicado por el optimizador (no por la función de pérdida). Añade regularización L2 para evitar el sobreajuste penalizando los pesos grandes. Se excluye automáticamente de los parámetros de sesgo y LayerNorm. Valores típicos: 0.01 (estándar), 0.1 (regularización más fuerte), 0.0 (sin regularización).

adam_beta1 (`float`, *opcional*, valor predeterminado 0.9) : La tasa de decaimiento exponencial para las estimaciones del primer momento (momentum) en optimizadores basados en Adam. Controla la cantidad de historial de gradientes que se conserva.

adam_beta2 (`float`, *opcional*, valor predeterminado 0.999) : Tasa de decaimiento exponencial para las estimaciones del segundo momento (varianza) en optimizadores basados en Adam. Controla la escalado adaptativo de la tasa de aprendizaje.

adam_epsilon (`float`, *opcional*, valor predeterminado 1e-8) : Valor de epsilon para la estabilidad numérica en optimizadores basados en Adam. Evita la división por cero en el denominador de la regla de actualización.

optim_target_modules (`Union[str, list[str]]`, *opcional*) : Los módulos objetivo a optimizar, es decir, los nombres de los módulos que desea entrenar. Actualmente se utiliza para el [algoritmo GaLore](https://huggingface.co/papers/2403.03507) y el [algoritmo APOLLO](https://huggingface.co/papers/2412.05270). Consulte [implementación de GaLore](https://github.com/jiaweizzhao/GaLore) y [implementación de APOLLO](https://github.com/zhuhanqing/APOLLO) para más detalles. Debe asegurarse de pasar un optimizador GaLore o APOLLO válido, por ejemplo, uno de los siguientes: "apollo_adamw", "galore_adamw", "galore_adamw_8bit", "galore_adafactor", y asegurarse de que los módulos objetivo sean únicamente módulos `nn.Linear`.

**Regularización y estabilidad del entrenamiento:**

gradient_accumulation_steps (`int`, *opcional*, valor predeterminado: 1) : Número de pasos de actualización para acumular gradientes antes de realizar un paso de retropropagación/actualización. Simula tamaños de lote más grandes sin memoria adicional. Tamaño de lote efectivo = `per_device_train_batch_size × num_devices × gradient_accumulation_steps`. > [!TIP] > Al usar acumulación de gradientes, un "paso" se cuenta como un paso con retropropagación. Por lo tanto, el registro, la evaluación y el guardado se realizarán cada `gradient_accumulation_steps × xxx_step` ejemplos de entrenamiento.

average_tokens_across_devices (`bool`, *opcional*, valor predeterminado `True`) : Indica si se promedian los tokens entre dispositivos. Si está habilitado, se usará all_reduce para sincronizar num_tokens_in_batch para un cálculo preciso de la pérdida. Referencia: https://github.com/huggingface/transformers/issues/34242

max_grad_norm (`float`, *opcional*, valor predeterminado 1.0) : Norma máxima del gradiente para el recorte de gradientes. Se aplica después de la propagación hacia atrás, antes del paso del optimizador. Previene la explosión de gradientes reduciendo la escala de los gradientes cuando su norma global supera este umbral. Establezca 0 para desactivar el recorte. Valores típicos: 1.0 (estándar), 0.5 (más conservador), 5.0 (menos agresivo).

label_smoothing_factor (`float`, *opcional*, valor predeterminado 0.0) : Factor de suavizado de etiquetas para evitar la sobreconfianza. Sustituye las dianas duras 0/1 por dianas suaves: 0 se convierte en `ε/num_labels` y 1 en `1 - ε + ε/num_labels`, donde ε = `label_smoothing_factor`. Cero significa que no se aplica suavizado. Rango típico: de 0.0 a 0.1.

**Entrenamiento con precisión mixta:**

bf16 (`bool`, *opcional*, valor predeterminado `False`) : Habilita el entrenamiento con precisión mixta bfloat16 (BF16). Generalmente se prefiere sobre FP16 debido a su mejor estabilidad numérica y a que no requiere escalado de pérdida.

fp16 (`bool`, *opcional*, valor predeterminado `False`) : Habilita el entrenamiento con precisión mixta float16 (FP16). Considere usar BF16 en su lugar si su hardware lo admite.

bf16_full_eval (`bool`, *opcional*, valor predeterminado `False`) : Utiliza precisión BF16 completa para la evaluación (no solo precisión mixta). Es más rápido y ahorra memoria, pero puede afectar ligeramente los valores de las métricas. Solo se aplica durante la evaluación.

fp16_full_eval (`bool`, *opcional*, valor predeterminado `False`) : Utiliza precisión FP16 completa para la evaluación (no solo precisión mixta). Es más rápido y ahorra memoria, pero puede afectar ligeramente los valores de las métricas. Solo se aplica durante la evaluación.

tf32 (`bool`, *opcional*) : Habilita el modo TensorFloat-32 (TF32) en GPUs Ampere y más recientes. TF32 utiliza una precisión de 19 bits para las multiplicaciones de matrices (en lugar de los 23 bits de FP32), lo que proporciona una aceleración de hasta 8x con una pérdida de precisión despreciable. El valor predeterminado depende de la versión de PyTorch. Consulte la [documentación de TF32](https://huggingface.co/docs/transformers/perf_train_gpu_one#tf32).

**Checkpointing de activaciones:**

activation_checkpointing (`bool`, *opcional*, valor predeterminado `False`) : Habilita el checkpointing de activaciones para intercambiar cómputo por memoria. Reduce el uso de memoria liberando las activaciones durante la pasada hacia adelante y recalculándolas durante la pasada hacia atrás. Permite entrenar modelos o tamaños de lote más grandes a costa de un entrenamiento aproximadamente un 20 % más lento.

activation_checkpointing_kwargs (`dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasan a `activation_checkpointing_enable()`. `every_n_layers` realiza el checkpoint solo de cada n-ésima capa del decodificador en lugar de todas; `1` es el comportamiento habitual de todo o nada, y los valores más grandes devuelven algo de memoria a cambio de velocidad. `offload` mantiene las activaciones guardadas en memoria de host fijada, lo que libera `layers x sequence x hidden` bytes de memoria del dispositivo y hace que el paso sea más lento. Cualquier otra clave se reenvía a `torch.utils.checkpoint.checkpoint`.

gradient_checkpointing (`bool`, *opcional*) : Alias obsoleto de `activation_checkpointing`, se eliminará en v6.

gradient_checkpointing_kwargs (`dict`, *opcional*) : Alias obsoleto de `activation_checkpointing_kwargs`, se eliminará en v6.

**Compilación:**

torch_compile (`bool`, *opcional*, valor predeterminado `False`) : Compila el modelo usando `torch.compile()` de PyTorch 2.0 para un entrenamiento más rápido. Puede proporcionar una aceleración del 20-50 % sin cambios en el código. Utiliza la configuración de compilación predeterminada a menos que se especifique `torch_compile_backend` o `torch_compile_mode`.

torch_compile_backend (`str`, *opcional*) : Backend para `torch.compile()`. Si se establece, habilita automáticamente `torch_compile`. Las opciones incluyen `"inductor"` (predeterminado), `"aot_eager"`, `"cudagraphs"`. Los backends varían según la versión de PyTorch; consulte la documentación de PyTorch para ver las opciones disponibles.

torch_compile_mode (`str`, *opcional*) : Modo de compilación para `torch.compile()`. Si se establece, habilita automáticamente `torch_compile`. Opciones: `"default"`, `"reduce-overhead"` (minimizar la sobrecarga de Python), `"max-autotune"` (optimización agresiva, tiempo de compilación más lento).

**Núcleos:**

use_liger_kernel (`bool`, *opcional*, valor predeterminado `False`) : Habilita las optimizaciones de [Liger Kernel](https://github.com/linkedin/Liger-Kernel). Aumenta el rendimiento en multi-GPU en un ~20 % y reduce el uso de memoria en un ~60 %. Funciona con Flash Attention, FSDP y DeepSpeed. Actualmente, es compatible con los modelos Llama, Mistral, Mixtral y Gemma.

liger_kernel_config (`Optional[dict]`, *opcional*) : Configuración para Liger Kernel. Se pasa como kwargs a `_apply_liger_kernel_to_instance()`. Las opciones suelen incluir: `"rope"`, `"swiglu"`, `"cross_entropy"`, `"fused_linear_cross_entropy"`, `"rms_norm"`. Si es `None`, se utiliza la configuración predeterminada.

**Optimizaciones adicionales:**

use_cache (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe habilitar la caché para el modelo. Para el entrenamiento, generalmente no es necesario, salvo en algunos métodos de PEFT que utilizan `past_key_values`.

neftune_noise_alpha (`Optional[float]`) : Si no es `None`, esto activará las incrustaciones de ruido de NEFTune. Esto puede mejorar drásticamente el rendimiento del modelo para el ajuste fino de instrucciones. Consulta el [artículo original](https://huggingface.co/papers/2310.05914) y el [código original](https://github.com/neelsjain/NEFTune). Admite `PreTrainedModel` de transformers y también `PeftModel` de peft. El artículo original utilizó valores en el rango [5.0, 15.0].

torch_empty_cache_steps (`int`, *opcional*) : Número de pasos a esperar antes de llamar a `torch.<device>.empty_cache()`. Si se deja sin establecer o se establece en None, la caché no se vaciará. Esto puede ayudar a evitar errores de memoria insuficiente de CUDA reduciendo el uso pico de VRAM, a costa de un [rendimiento aproximadamente un 10% más lento](https://github.com/huggingface/transformers/issues/31372).

auto_find_batch_size (`bool`, *opcional*, valor predeterminado `False`) : Si se debe encontrar automáticamente un tamaño de lote de entrenamiento que quepa en la memoria mediante decaimiento exponencial, evitando errores de memoria insuficiente de CUDA. El tamaño de lote de evaluación no se ajusta.

**Registro y supervisión del entrenamiento:**

logging_strategy (`str` o [IntervalStrategy](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.IntervalStrategy), *opcional*, valor predeterminado `"steps"`) : La estrategia de registro que se adoptará durante el entrenamiento. Los valores posibles son: - `"no"`: No se realiza ningún registro durante el entrenamiento. - `"epoch"`: El registro se realiza al final de cada época. - `"steps"`: El registro se realiza cada `logging_steps`.

logging_steps (`int` o `float`, *opcional*, valor predeterminado: 500) : Número de pasos de actualización entre dos registros si `logging_strategy="steps"`. Debe ser un entero o un flotante en el rango `[0,1)`. Si es menor que 1, se interpretará como la proporción de los pasos totales de entrenamiento.

logging_first_step (`bool`, *opcional*, valor predeterminado `False`) : Indica si se registran o no los primeros `global_step`.

log_on_each_node (`bool`, *opcional*, valor predeterminado `True`) : En el entrenamiento distribuido multinodo, si se registran los registros usando `log_level` una vez por nodo o solo en el nodo principal.

logging_nan_inf_filter (`bool`, *opcional*, valor predeterminado `True`) : Filtra las pérdidas NaN e Inf al registrar. Si `True`, reemplaza las pérdidas de entrenamiento NaN/Inf con el promedio de las pérdidas válidas recientes y excluye los lotes NaN/Inf (p. ej., lotes sin tokens de etiqueta) de la pérdida de evaluación. No afecta el cálculo de gradientes, solo el registro.

include_num_input_tokens_seen (`Optional[Union[str, bool]]`, *opcional*, valor predeterminado: "no") : Indica si se debe registrar el número de tokens de entrada vistos. Debe ser uno de ["all", "non_padding", "no"] o un valor booleano que se mapea a "all" o "no". Puede ser más lento en el entrenamiento distribuido, ya que se deben llamar operaciones de gather.

**Registro:**

log_level (`str`, *opcional*, valor predeterminado `passive`) : Nivel de registro para el proceso principal. Opciones: `"debug"`, `"info"`, `"warning"`, `"error"`, `"critical"` o `"passive"` (no cambia el nivel de registro actual de Transformers, que por defecto es `"warning"`)

log_level_replica (`str`, *opcional*, valor predeterminado `"warning"`) : Nivel de registro para los procesos de réplica en el entrenamiento distribuido. Mismas opciones que `log_level`.

disable_tqdm (`bool`, *opcional*) : Desactiva las barras de progreso de tqdm. El valor predeterminado es `True` si `log_level` es warning o inferior, y `False` en caso contrario.

**Integración de seguimiento de experimentos:**

report_to (`str` o `list[str]`, *opcional*, valor predeterminado `"none"`) : La lista de integraciones a las que se enviarán los resultados y los registros. Las plataformas admitidas son `"azure_ml"`, `"clearml"`, `"codecarbon"`, `"comet_ml"`, `"dagshub"`, `"dvclive"`, `"flyte"`, `"mlflow"`, `"swanlab"`, `"tensorboard"`, `"trackio"` y `"wandb"`. Use `"all"` para enviar informes a todas las integraciones instaladas y `"none"` para no usar ninguna integración.

run_name (`str`, *opcional*) : Un descriptor para la ejecución. Se utiliza típicamente para el registro en [trackio](https://github.com/gradio-app/trackio), [wandb](https://www.wandb.com/), [mlflow](https://www.mlflow.org/), [comet](https://www.comet.com/site) y [swanlab](https://swanlab.cn).

project (`str`, *opcional*, valor predeterminado `"huggingface"`) : El nombre del proyecto que se usará para el registro. Actualmente, solo lo utiliza Trackio.

trackio_space_id (`str` o `None`, *opcional*, valor predeterminado `None`) : El ID del Space de Hugging Face que se usará para el registro en vivo de Trackio con un Space basado en Gradio. Debe ser un nombre completo de Space como `'username/reponame'` o `'orgname/reponame'`, o simplemente `'reponame'` (el Space se crea en el espacio de nombres del usuario actualmente conectado). Si es `None`, las métricas se registran solo en un directorio **local** (sin Space en el Hub). Ese Space de Gradio tiene acceso de **lectura y escritura** al **Bucket** de Trackio, lo cual es lo que se desea mientras el entrenamiento está **en curso**, por ejemplo, al **reanudar** una ejecución parcial o **agregar registros** de varias máquinas. El Space será **público** a menos que se establezca `hub_private_repo=True` o el valor predeterminado de su organización sea crear Spaces privados.

trackio_bucket_id (`str` o `None`, *opcional*, valor predeterminado `None`) : id de Bucket de Hugging Face opcional para Trackio. Si no se establece, Trackio lo deriva. Se utiliza junto con un Space de Gradio (`trackio_space_id`) y al desplegar un Space estático (`trackio_static_space_id` no es `False`).

trackio_static_space_id (`str`, `False` o `None`, *opcional*, valor predeterminado `None`) : El ID del Hugging Face Space que se usará para el Space estático creado una vez finalizado el entrenamiento. Debe ser un nombre completo de Space como `'username/reponame'` o `'orgname/reponame'`, o simplemente `'reponame'` (el Space se crea en el espacio de nombres del usuario actualmente conectado). Si es False, no se creará ningún Space estático. Si es None y el modelo se sube al Hub, se creará un Space estático con un nombre predeterminado y se enlazará desde la tarjeta del modelo. El Space será público a menos que establezcas `hub_private_repo=True` o el valor predeterminado de tu organización sea crear Spaces privados.

**Evaluación:**

eval_strategy (`str` o [IntervalStrategy](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.IntervalStrategy), *opcional*, valor predeterminado `"no"`) : Cuándo ejecutar la evaluación. Opciones: - `"no"`: No se realiza evaluación durante el entrenamiento - `"steps"`: Evaluar cada `eval_steps` - `"epoch"`: Evaluar al final de cada época

eval_steps (`int` o `float`, *opcional*) : Número de pasos de actualización entre dos evaluaciones si `eval_strategy="steps"`. Si no se establece, tomará por defecto el mismo valor que `logging_steps`. Debe ser un entero o un float en el rango `[0,1)`. Si es menor que 1, se interpretará como la proporción de los pasos totales de entrenamiento.

eval_delay (`float`, *opcional*) : Número de épocas o pasos que se deben esperar antes de que se pueda realizar la primera evaluación, según el eval_strategy.

per_device_eval_batch_size (`int`, *opcional*, valor predeterminado: 8) : El tamaño de lote por núcleo de acelerador/CPU del dispositivo para la evaluación.

prediction_loss_only (`bool`, *opcional*, valor predeterminado `False`) : Al realizar la evaluación y generar predicciones, solo devuelve la pérdida.

eval_on_start (`bool`, *opcional*, valor predeterminado `False`) : Si se debe realizar un paso de evaluación (verificación de coherencia) antes del entrenamiento para asegurarse de que los pasos de validación funcionen correctamente.

eval_do_concat_batches (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben concatenar recursivamente las entradas, pérdidas, etiquetas y predicciones entre lotes. Si es `False`, se almacenarán como listas, manteniendo cada lote separado.

eval_use_gather_object (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe ejecutar de forma recursiva la recopilación de objetos en una lista, tupla o diccionario anidado de objetos desde todos los dispositivos. Esto solo debe activarse si los usuarios no están devolviendo únicamente tensores, y PyTorch desaconseja activamente esta opción. Es útil cuando la estructura de las etiquetas no es estándar, como en tareas de visión por computadora.

eval_accumulation_steps (`int`, *opcional*) : Número de pasos de predicción para acumular los tensores de salida antes de mover los resultados a la CPU. Si no se establece, todas las predicciones se acumulan en el acelerador del dispositivo antes de moverse a la CPU (más rápido, pero requiere más memoria).

**Cálculo de métricas:**

include_for_metrics (`list[str]`, *opcional*, valor predeterminado `[]`) : Incluye datos adicionales en la función `compute_metrics` si son necesarios para el cálculo de métricas. Opciones posibles para añadir a la lista `include_for_metrics`: - `"inputs"`: Datos de entrada pasados al modelo, destinados al cálculo de métricas dependientes de la entrada. - `"loss"`: Valores de pérdida calculados durante la evaluación, destinados al cálculo de métricas dependientes de la pérdida.

batch_eval_metrics (`bool`, *opcional*, valor predeterminado `False`) : Si se establece en `True`, la evaluación llamará a compute_metrics al final de cada batch para acumular estadísticas en lugar de guardar todos los logits de evaluación en memoria. Cuando se establece en `True`, debe pasar una función compute_metrics que reciba un argumento booleano `compute_result`; al pasarle `True`, se activará el resumen global final de estadísticas a partir de las estadísticas de resumen a nivel de batch que haya acumulado sobre el conjunto de evaluación.

**Puntos de control y guardado:**

save_only_model (`bool`, *opcional*, valor predeterminado `False`) : Guarda solo los pesos del modelo, no el estado del optimizador/planificador/RNG. Reduce significativamente el tamaño del punto de control, pero impide reanudar el entrenamiento desde dicho punto de control. Úsalo cuando solo necesites el modelo entrenado para inferencia, no para continuar el entrenamiento. Con esta opción establecida en `True`, solo puedes cargar el modelo mediante `from_pretrained`.

save_strategy (`str` o `SaveStrategy`, *opcional*, valor predeterminado `"steps"`) : La estrategia de guardado de puntos de control a adoptar durante el entrenamiento. Los valores posibles son: - `"no"`: No se realiza ningún guardado durante el entrenamiento. - `"epoch"`: El guardado se realiza al final de cada época. - `"steps"`: El guardado se realiza cada `save_steps`. - `"best"`: El guardado se realiza cada vez que se alcanza una nueva `best_metric`.

save_steps (`int` o `float`, *opcional*, valor predeterminado: 500) : Número de pasos de actualización entre dos guardados de puntos de control si `save_strategy="steps"`. Debe ser un entero o un flotante en el rango `[0,1)`. Si es menor que 1, se interpretará como la proporción de los pasos totales de entrenamiento.

save_on_each_node (`bool`, *opcional*, valor predeterminado `False`) : Al realizar entrenamiento distribuido multinodo, si se deben guardar los modelos y puntos de control en cada nodo o solo en el principal. No se debe activar cuando los distintos nodos utilizan el mismo almacenamiento, ya que los archivos se guardarán con los mismos nombres en cada nodo.

save_total_limit (`int`, *opcional*) : Número máximo de puntos de control que se conservarán. Elimina los puntos de control más antiguos de `output_dir`. Cuando `load_best_model_at_end=True`, siempre se conserva el mejor punto de control, además de los más recientes. Por ejemplo, `save_total_limit=5` conserva los 4 más recientes y el mejor.

enable_jit_checkpoint (`bool`, *opcional*, valor predeterminado `False`) : Habilita el checkpointing Just-In-Time ante la señal SIGTERM para una terminación ordenada en cargas de trabajo preemibles. **Importante**: Configure el período de apagado ordenado de su orquestador para permitir un tiempo suficiente. En Kubernetes, establezca `terminationGracePeriodSeconds` (el valor predeterminado de 30 s suele ser insuficiente). En Slurm, use `--signal=TERM@<seconds>`. El período de gracia requerido debe ser ≥ al tiempo de la iteración más larga + el tiempo de guardado del checkpoint.

**Integración con Hugging Face Hub:**

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hub cada vez que se guarda. Si se activa, `output_dir` iniciará un directorio git sincronizado con el repositorio (determinado por `hub_model_id`) y el contenido se enviará cada vez que se active un guardado (según tu `save_strategy`). Llamar a [save_model()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.save_model) también activará un envío.

hub_token (`str`, *opcional*) : El token que se usará para subir el modelo al Hub. Por defecto, se utilizará el token de la carpeta de caché obtenido con `hf auth login`.

hub_private_repo (`bool`, *opcional*) : Indica si se debe hacer privada la repository. Si es `None` (valor predeterminado), la repository será pública a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si la repository ya existe. Si se informa a Trackio con la implementación en Hugging Face Spaces habilitada, la misma lógica determina si el Space es privado.

hub_model_id (`str`, *opcional*) : El nombre del repositorio que se mantendrá sincronizado con el *output_dir* local. Puede ser un ID de modelo simple, en cuyo caso el modelo se publicará en su espacio de nombres. En caso contrario, debe ser el nombre completo del repositorio, por ejemplo `"user_name/model"`, lo que le permite publicar en una organización de la que es miembro con `"organization_name/model"`. El valor predeterminado será `user_name/output_dir_name`, donde *output_dir_name* es el nombre de `output_dir`.

hub_strategy (`str` o `HubStrategy`, *opcional*, valor predeterminado `"every_save"`) : Define qué y cuándo se envía a Hub. Opciones: - `"end"`: Enviar solo al final del entrenamiento - `"every_save"`: Enviar en cada guardado (asíncrono para no bloquear el entrenamiento) - `"checkpoint"`: Como `"every_save"` más enviar el último punto de control a la subcarpeta `"last-checkpoint"` para facilitar la reanudación - `"all_checkpoints"`: Enviar todos los puntos de control a medida que aparecen

hub_always_push (`bool`, *opcional*, valor predeterminado `False`) : A menos que este valor sea `True`, `Trainer` omitirá el envío de un punto de control si el envío anterior no ha finalizado.

hub_revision (`str`, *opcional*) : La revisión que se utilizará al enviar al Hub. Puede ser el nombre de una rama, una etiqueta o un hash de commit.

**Seguimiento óptimo de modelos:**

load_best_model_at_end (`bool`, *opcional*, valor predeterminado `False`) : Carga el mejor punto de control al final del entrenamiento. Requiere que `eval_strategy` esté configurado. Cuando está habilitado, el mejor punto de control se guarda siempre (ver `save_total_limit`).  Cuando `True`, `save_strategy` debe coincidir con `eval_strategy` (a menos que `save_strategy` sea `"best"`), y si se usa `"steps"`, `save_steps` debe ser un múltiplo de `eval_steps`.

metric_for_best_model (`str`, *opcional*) : Métrica a utilizar para comparar modelos cuando `load_best_model_at_end=True`. Debe ser un nombre de métrica devuelto por la evaluación, con o sin el prefijo `"eval_"`. El valor predeterminado es `"loss"`. Si se establece este parámetro, `greater_is_better` se establecerá en `True` por defecto, a menos que el nombre termine en `"loss"`. Ejemplos: `"accuracy"`, `"f1"`, `"eval_bleu"`.

greater_is_better (`bool`, *opcional*) : Indica si valores más altos de la métrica son mejores. El valor predeterminado se basa en `metric_for_best_model`: `True` si el nombre de la métrica no termina en `"loss"`, `False` en caso contrario.

**Reanudar el entrenamiento:**

ignore_data_skip (`bool`, *opcional*, valor predeterminado `False`) : Al reanudar el entrenamiento, omite el avance rápido a través del conjunto de datos para alcanzar el estado anterior. Si es `True`, el entrenamiento comienza desde el principio del conjunto de datos (reanudación más rápida, pero los resultados no coincidirán con el entrenamiento interrumpido). Si es `False`, omite los datos ya vistos (reanudación más lenta, pero continuación exacta).

restore_callback_states_from_checkpoint (`bool`, *opcional*, valor predeterminado `False`) : Restaura los estados de los callbacks desde el checkpoint al reanudar. Si es `True`, sobrescribirá los callbacks pasados a Trainer si existen en el checkpoint.

**Reproducibilidad:**

full_determinism (`bool`, *opcional*, valor predeterminado `False`) : Si es `True`, se llama a [enable_full_determinism()](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.enable_full_determinism) en lugar de [set_seed()](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.set_seed) para garantizar resultados reproducibles en el entrenamiento distribuido. Importante: esto afectará negativamente el rendimiento, por lo que solo debe usarse para depuración.

seed (`int`, *opcional*, valor predeterminado 42) : Semilla aleatoria que se establecerá al inicio del entrenamiento. Para garantizar la reproducibilidad entre ejecuciones, use la función `~Trainer.model_init` para instanciar el modelo si tiene algunos parámetros inicializados aleatoriamente.

data_seed (`int`, *opcional*) : Semilla aleatoria que se usará con los muestreadores de datos. Si no se establece, los generadores aleatorios para el muestreo de datos usarán la misma semilla que `seed`. Esto se puede usar para garantizar la reproducibilidad del muestreo de datos, de forma independiente de la semilla del modelo.

**Configuración del hardware:**

use_cpu (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar la CPU. Si se establece en False, se utilizará el dispositivo/backend de torch disponible.

**Configuración de Accelerate:**

accelerator_config (`str`, `dict` o `AcceleratorConfig`, *opcional*) : Configuración para la integración interna de Accelerate. Puede ser: - Ruta al archivo de configuración JSON: `"accelerator_config.json"` - Diccionario con opciones de configuración - Instancia de `AcceleratorConfig` Opciones clave: - `split_batches` (`bool`, valor predeterminado `False`): Si se dividen los lotes entre dispositivos. Si es `True`, el tamaño real del lote es el mismo en todos los dispositivos (el total debe ser divisible por num_processes). Si es `False`, cada dispositivo recibe el tamaño de lote especificado. - `dispatch_batches` (`bool`): Si es `True`, solo el proceso principal itera a través del dataloader y envía los lotes a los dispositivos. El valor predeterminado es `True` para `IterableDataset` y `False` en caso contrario. - `even_batches` (`bool`, valor predeterminado `True`): Duplica muestras desde el inicio del conjunto de datos para garantizar que todos los workers reciban tamaños de lote iguales. - `use_seedable_sampler` (`bool`, valor predeterminado `True`): Utiliza un muestreador aleatorio completamente sembrable para la reproducibilidad. - `use_configured_state` (`bool`, valor predeterminado `False`): Utiliza un `AcceleratorState`/`PartialState` preinicializado en lugar de crear uno nuevo. Puede causar problemas con el ajuste de hiperparámetros.

parallelism_config (`ParallelismConfig`, *opcional*) : Configuración de paralelismo para la ejecución de entrenamiento. Requiere Accelerate `1.10.1`

**Cargador de datos:**

dataloader_drop_last (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe descartar el último lote incompleto (si la longitud del conjunto de datos no es divisible por el tamaño del lote) o no.

dataloader_num_workers (`int`, *opcional*, valor predeterminado 0) : Número de subprocesos para usar en la carga de datos (solo PyTorch). 0 significa que los datos se cargarán en el proceso principal.

dataloader_pin_memory (`bool`, *opcional*, valor predeterminado `True`) : Si se desea fijar la memoria en los cargadores de datos o no. El valor predeterminado será `True`.

dataloader_persistent_workers (`bool`, *opcional*, valor predeterminado `False`) : Si es True, el data loader no cerrará los procesos de worker después de que un dataset se haya consumido una vez. Esto permite mantener vivas las instancias de Dataset de los workers. Puede acelerar el entrenamiento, pero aumentará el uso de RAM. El valor predeterminado será `False`.

dataloader_prefetch_factor (`int`, *opcional*) : Número de lotes que cada worker carga de antemano. 2 significa que habrá un total de 2 * num_workers lotes precargados en todos los workers.

dataloader_multiprocessing_context (`str`, *opcional*) : El método de inicio de multiprocesamiento a utilizar para los trabajadores de carga de datos (`"fork"`, `"spawn"` o `"forkserver"`). El valor predeterminado es el método de inicio predeterminado de PyTorch, excepto en MPS con `dataloader_num_workers > 1`, donde el valor predeterminado es `"fork"`. Utilice `"spawn"` al transmitir desde fuentes cuyos objetos no son seguros para fork (por ejemplo, HDFS a través de `pyarrow`). Bajo `"spawn"`, cualquier `collate_fn` personalizado o código de conjunto de datos debe ser importable a nivel de módulo (sin lambdas/closures).

dataloader_in_order (`bool`, *opcional*, valor predeterminado `True`) : Si `True`, el data loader genera lotes en el orden en que se enviaron los workers. Establezca `False` para generar los lotes en cuanto estén listos, lo que puede reducir la latencia de cola en cargas de trabajo de streaming de `IterableDataset`. Requiere PyTorch >= 2.6.

remove_unused_columns (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben eliminar automáticamente las columnas que no utiliza el método forward del modelo.

label_names (`list[str]`, *opcional*) : La lista de claves en su diccionario de entradas que corresponden a las etiquetas. Eventualmente, el valor predeterminado será la lista de nombres de argumentos aceptados por el modelo que contengan la palabra "label", excepto si el modelo utilizado es uno de los `XxxForQuestionAnswering`, en cuyo caso también incluirá las claves `["start_positions", "end_positions"]`. Solo debe especificar `label_names` si está usando nombres de etiquetas personalizados o si el `forward` de su modelo consume múltiples tensores de etiquetas (p. ej., QA extractivo).

train_sampling_strategy (`str`, *opcional*, valor predeterminado `"random"`) : El muestreador que se usará para el dataloader de entrenamiento. Los valores posibles son:  - `"random"`: Usa `RandomSampler` (predeterminado). - `"sequential"`: Usa `SequentialSampler`. - `"group_by_length"`: Usa `LengthGroupedSampler` para agrupar muestras de longitud aproximadamente igual (para minimizar el padding y ser más eficiente). - `"batch_rebalance"`: Usa `BatchRebalanceSampler` para equilibrar el coste de tokens con padding entre dispositivos y pasos de acumulación de gradientes dentro de cada lote efectivo, reduciendo el desperdicio de padding y la memoria pico en comparación con `"group_by_length"`. Actualmente solo se admite para entrenamiento paralelo de datos (el paralelismo de tensores aún no se admite).  Nota: Al usar un `IterableDataset`, este argumento se ignora.

length_column_name (`str`, *opcional*, valor predeterminado `"length"`) : Nombre de la columna para longitudes precalculadas. Si la columna existe, el agrupamiento por longitud usará estos valores en lugar de calcularlos al iniciar el entrenamiento. Se ignora a menos que `train_sampling_strategy` sea `"group_by_length"`o `"batch_rebalance"` y el conjunto de datos sea una instancia de `Dataset`.

**DDP (DistributedDataParallel):**

ddp_find_unused_parameters (`bool`, *opcional*) : Al usar entrenamiento distribuido, el valor de la bandera `find_unused_parameters` que se pasa a `DistributedDataParallel`. Será `False` por defecto si se usa gradient checkpointing, `True` en caso contrario.

ddp_bucket_cap_mb (`int`, *opcional*) : Al usar entrenamiento distribuido, el valor de la bandera `bucket_cap_mb` pasada a `DistributedDataParallel`.

ddp_broadcast_buffers (`bool`, *opcional*) : Al usar entrenamiento distribuido, el valor de la bandera `broadcast_buffers` que se pasa a `DistributedDataParallel`. Será `False` por defecto si se usa gradient checkpointing, `True` en caso contrario.

ddp_static_graph (`bool`, *opcional*) : Al usar entrenamiento distribuido, el valor de la bandera `static_graph` pasada a `DistributedDataParallel`.

ddp_backend (`str`, *opcional*) : El backend a utilizar para el entrenamiento distribuido. Debe ser uno de `"nccl"`, `"mpi"`, `"xccl"`, `"gloo"`, `"hccl"`.

ddp_timeout (`int`, *opcional*, valor predeterminado 1800) : El tiempo de espera para las llamadas a `torch.distributed.init_process_group`, utilizado para evitar tiempos de espera de los sockets de GPU al realizar operaciones lentas en ejecuciones distribuidas. Consulte la [documentación de PyTorch](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) para obtener más información.

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

fsdp (`bool`, *opcional*, valor predeterminado `None`) : Habilita PyTorch Fully Sharded Data Parallel (FSDP) para el entrenamiento distribuido. Pasa `True` para habilitar FSDP.

fsdp_config (`str` o `dict`, *opcional*) : Configuración para cuando `fsdp` está habilitado. Pase una ruta a un archivo de configuración JSON, como `fsdp_config.json`, o un diccionario ya cargado. Claves admitidas: - version (`int`, *opcional*, valor predeterminado `2`): La versión de FSDP a utilizar (`2` para FSDP2, `1` para el FSDP1 heredado). - reshard_after_forward (`bool`, *opcional*, valor predeterminado `True`): Si se deben re-fragmentar los parámetros después de la pasada hacia adelante. Establezca `False` para mantener los parámetros reunidos entre las pasadas hacia adelante y hacia atrás, lo que evita el re-all-gather y utiliza más memoria de pico. - cpu_offload (`bool`, *opcional*, valor predeterminado `False`): Descarga los parámetros y gradientes a la CPU cuando no se utilizan para ahorrar memoria de GPU. - activation_checkpointing (`bool`, *opcional*, valor predeterminado `False`): Establezca `True` para reducir la memoria recalculando las activaciones durante la pasada hacia atrás. Al usar FSDP, prefiera esto al argumento de entrenamiento `activation_checkpointing`, que introduce un all-gather redundante en la pasada hacia atrás. - cpu_ram_efficient_loading (`bool`, *opcional*, valor predeterminado `False`): Establezca `True` para cargar el checkpoint preentrenado solo en el primer proceso. Los demás procesos inician con pesos vacíos y reciben los pesos mediante broadcast. - state_dict_type (`str`, *opcional*, valor predeterminado `"FULL_STATE_DICT"`): Formato del checkpoint: `"FULL_STATE_DICT"` (un solo archivo compatible con HF) o `"SHARDED_STATE_DICT"` (un archivo por rank, más rápido para modelos grandes). - auto_wrap_policy (`str`, *opcional*, valor predeterminado `"TRANSFORMER_BASED_WRAP"`): Política de auto-wrap a utilizar. Elija `"TRANSFORMER_BASED_WRAP"`, `"SIZE_BASED_WRAP"` o `"NO_WRAP"`. - transformer_layer_cls_to_wrap (`list[str]`, *opcional*): Nombres de las clases de capas de Transformer (distingue mayúsculas y minúsculas) para envolver, p. ej. `LlamaDecoderLayer`. Generalmente no es necesario: la política de wrap recurre a `_no_split_modules` del modelo, que cubre la mayoría de los modelos de transformers. - min_num_params (`int`, *opcional*, valor predeterminado `0`): Número mínimo de parámetros por módulo para el auto-wrap basado en tamaño (se usa con `auto_wrap_policy="SIZE_BASED_WRAP"`). - xla (`bool`, *opcional*, valor predeterminado `False`): Si se debe utilizar el entrenamiento PyTorch/XLA Fully Sharded Data Parallel. Experimental. - xla_fsdp_settings (`dict`, *opcional*): Diccionario de parámetros de envoltura de XLA FSDP. Para una lista completa de opciones, consulte el [código fuente de XLA FSDP](https://github.com/pytorch/xla/blob/master/torch_xla/distributed/fsdp/xla_fully_sharded_data_parallel.py). - xla_fsdp_grad_ckpt (`bool`, *opcional*, valor predeterminado `False`): Establezca `True` para usar gradient checkpointing en cada capa envuelta por XLA FSDP anidada. Requiere `xla=True` y una política de auto-envoltura (`min_num_params` o `transformer_layer_cls_to_wrap`).

**DeepSpeed:**

deepspeed (`str` o `dict`, *opcional*) : Habilita la integración de [DeepSpeed](https://github.com/deepspeedai/DeepSpeed). El valor es: - Ruta al archivo de configuración JSON de DeepSpeed: `"ds_config.json"` - Configuración cargada como diccionario > [!TIP] > Si se usa la inicialización ZeRO, instancie su modelo *después* de inicializar `TrainingArguments`; de lo contrario, ZeRO no se aplicará.

**Depuración y perfilado (experimental):**

debug (`str` o lista de `DebugOption`, *opcional*, valor predeterminado `""`) : Habilita una o más funciones de depuración. Esta es una función experimental. Las opciones posibles son: - "underflow_overflow": detecta desbordes en las entradas/salidas del modelo e informa de los últimos fotogramas que provocaron el evento - "tpu_metrics_debug": imprime métricas de depuración en TPU

skip_memory_metrics (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe omitir la adición de informes del perfilador de memoria a las métricas. Se omite de forma predeterminada porque ralentiza la velocidad de entrenamiento y evaluación.

**Banderas de script externo (no utilizadas por Trainer):**

do_train (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe ejecutar el entrenamiento o no. Este argumento no se utiliza directamente por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer); está destinado a ser utilizado por sus scripts de entrenamiento/evaluación.

do_eval (`bool`, *opcional*) : Indica si se debe ejecutar la evaluación en el conjunto de validación. Se establecerá en `True` si `eval_strategy` es diferente de `"no"`. Este argumento no se utiliza directamente por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer); está destinado a ser utilizado por sus scripts de entrenamiento/evaluación.

do_predict (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben ejecutar predicciones en el conjunto de prueba o no. Este argumento no se utiliza directamente por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer); está destinado a ser utilizado por sus scripts de entrenamiento/evaluación.

resume_from_checkpoint (`str`, *opcional*) : La ruta a una carpeta con un punto de control válido para su modelo. Este argumento no se utiliza directamente por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer); está destinado a ser utilizado por sus scripts de entrenamiento/evaluación.

Clase de configuración para controlar todos los aspectos del entrenamiento del modelo con Trainer. TrainingArguments centraliza todos los hiperparámetros, configuraciones de optimización, preferencias de registro y decisiones de infraestructura necesarias para el entrenamiento.

[HfArgumentParser](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.HfArgumentParser) puede convertir esta clase en argumentos de [argparse](https://docs.python.org/3/library/argparse#module-argparse) que se pueden especificar en la línea de comandos.

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

```python
get_process_log_level()
```

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

Devuelve el nivel de registro que se debe utilizar en función de si este proceso es el proceso principal del nodo 0, el proceso principal de un nodo distinto de 0, o un proceso no principal.

Para el proceso principal, el nivel de registro predeterminado es el nivel de registro establecido (`logging.WARNING` si no se hizo nada) a menos que se sobrescriba con el argumento `log_level`.

Para los procesos de réplica, el nivel de registro predeterminado es `logging.WARNING` a menos que se sobrescriba con el argumento `log_level_replica`.

La elección entre la configuración del proceso principal y la del proceso réplica se realiza según el valor devuelto por `should_log`.

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

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

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

Obtener el número de pasos utilizados para un calentamiento lineal.

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

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

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

**Parámetros:**

local (`bool`, *opcional*, valor predeterminado `True`) : si `True`, primero significa el proceso de rango 0 de cada nodo; si `False`, primero significa el proceso de rango 0 del nodo de rango 0. En un entorno multinodo con un sistema de archivos compartido, probablemente querrá usar `local=False` para que solo el proceso principal del primer nodo realice el procesamiento. Sin embargo, si el sistema de archivos no es compartido, el proceso principal de cada nodo deberá realizar el procesamiento, que es el comportamiento predeterminado.

desc (`str`, *opcional*, valor predeterminado `"work"`) : una descripción del trabajo que se utilizará en los registros de depuración

Un administrador de contexto para el entorno distribuido de torch en el que se necesita hacer algo en el proceso principal, mientras se bloquean las réplicas, y al terminar, se liberan las réplicas.

Un uso de este tipo es la función `map` de `datasets`, que para ser eficiente debe ejecutarse una sola vez en el proceso principal, el cual, al completarse, guarda una versión en caché de los resultados y que luego se carga automáticamente en las réplicas.

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

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

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

**Parámetros:**

drop_last (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe descartar el último lote incompleto (si la longitud del conjunto de datos no es divisible por el tamaño del lote) o no.

num_workers (`int`, *opcional*, valor predeterminado 0) : Número de subprocesos para usar en la carga de datos (solo PyTorch). 0 significa que los datos se cargarán en el proceso principal.

pin_memory (`bool`, *opcional*, valor predeterminado `True`) : Si se desea fijar la memoria en los cargadores de datos o no. El valor predeterminado será `True`.

persistent_workers (`bool`, *opcional*, valor predeterminado `False`) : Si es True, el data loader no cerrará los procesos de worker después de que un dataset se haya consumido una vez. Esto permite mantener vivas las instancias de Dataset de los workers. Puede acelerar el entrenamiento, pero aumentará el uso de RAM. El valor predeterminado será `False`.

prefetch_factor (`int`, *opcional*) : Número de lotes que cada worker carga de antemano. 2 significa que habrá un total de 2 * num_workers lotes precargados en todos los workers.

multiprocessing_context (`str`, *opcional*) : El método de inicio de multiprocesamiento que se usará para los trabajadores de carga de datos (`"fork"`, `"spawn"` o `"forkserver"`). Por defecto, se utiliza el método de inicio predeterminado de PyTorch. Use `"spawn"` cuando se realice streaming desde fuentes cuyos objetos no son seguros para fork (p. ej., HDFS a través de `pyarrow`). Bajo `"spawn"`, cualquier código personalizado de `collate_fn` o de dataset debe ser importable a nivel de módulo (sin lambdas ni closures).

in_order (`bool`, *opcional*, valor predeterminado `True`) : Si `True`, el data loader genera lotes en el orden en que se enviaron los workers. Establezca `False` para generar los lotes en cuanto estén listos, lo que puede reducir la latencia de cola en cargas de trabajo de streaming de `IterableDataset`. Requiere PyTorch >= 2.6.

auto_find_batch_size (`bool`, *opcional*, valor predeterminado `False`) : Si se debe encontrar automáticamente un tamaño de lote que quepa en memoria mediante decaimiento exponencial, evitando errores de memoria insuficiente de CUDA. Requiere que accelerate esté instalado (`pip install accelerate`)

ignore_data_skip (`bool`, *opcional*, valor predeterminado `False`) : Al reanudar el entrenamiento, indica si se deben omitir las épocas y lotes para que la carga de datos se encuentre en la misma etapa que en el entrenamiento anterior. Si se establece en `True`, el entrenamiento comenzará más rápido (ya que el paso de omisión puede tardar mucho tiempo), pero no producirá los mismos resultados que habría obtenido el entrenamiento interrumpido.

sampler_seed (`int`, *opcional*) : Semilla aleatoria que se usará con los muestreadores de datos. Si no se establece, los generadores aleatorios para el muestreo de datos usarán la misma semilla que `self.seed`. Esto se puede usar para garantizar la reproducibilidad del muestreo de datos, de forma independiente de la semilla del modelo.

Un método que agrupa todos los argumentos vinculados a la creación de los dataloaders.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

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

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

**Parámetros:**

strategy (`str` o [IntervalStrategy](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.IntervalStrategy), *opcional*, valor predeterminado `"no"`) : La estrategia de evaluación a adoptar durante el entrenamiento. Los valores posibles son:  - `"no"`: No se realiza ninguna evaluación durante el entrenamiento. - `"steps"`: Se realiza (y registra) la evaluación cada `steps`. - `"epoch"`: Se realiza la evaluación al final de cada epoch.  Establecer una `strategy` diferente de `"no"` establecerá `self.do_eval` en `True`.

steps (`int`, *opcional*, valor predeterminado 500) : Número de pasos de actualización entre dos evaluaciones si `strategy="steps"`.

batch_size (`int` *opcional*, valor predeterminado: 8) : El tamaño de lote por dispositivo (GPU/núcleo de TPU/CPU...) utilizado para la evaluación.

accumulation_steps (`int`, *opcional*) : Número de pasos de predicción para los que acumular los tensores de salida antes de mover los resultados a la CPU. Si no se establece, todas las predicciones se acumulan en la GPU/TPU antes de moverse a la CPU (más rápido, pero requiere más memoria).

delay (`float`, *opcional*) : Número de épocas o pasos que se deben esperar antes de que se pueda realizar la primera evaluación, según el eval_strategy.

loss_only (`bool`, *opcional*, valor predeterminado `False`) : Ignora todas las salidas excepto la pérdida.

Un método que agrupa todos los argumentos vinculados a la evaluación.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

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

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

**Parámetros:**

strategy (`str` o [IntervalStrategy](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.IntervalStrategy), *opcional*, valor predeterminado `"steps"`) : La estrategia de registro que se adoptará durante el entrenamiento. Los valores posibles son:  - `"no"`: No se realiza ningún registro durante el entrenamiento. - `"epoch"`: El registro se realiza al final de cada época. - `"steps"`: El registro se realiza cada `logging_steps`.

steps (`int`, *opcional*, valor predeterminado 500) : Número de pasos de actualización entre dos registros si `strategy="steps"`.

level (`str`, *opcional*, valor predeterminado `"passive"`) : Nivel de registro del logger a utilizar en el proceso principal. Las opciones posibles son los niveles de registro como cadenas: `"debug"`, `"info"`, `"warning"`, `"error"` y `"critical"`, además de un nivel `"passive"` que no establece nada y permite que la aplicación defina el nivel.

report_to (`str` o `list[str]`, *opcional*, valor predeterminado `"none"`) : La lista de integraciones a las que se enviarán los resultados y los registros. Las plataformas admitidas son `"azure_ml"`, `"clearml"`, `"codecarbon"`, `"comet_ml"`, `"dagshub"`, `"dvclive"`, `"flyte"`, `"mlflow"`, `"swanlab"`, `"tensorboard"`, `"trackio"` y `"wandb"`. Use `"all"` para enviar informes a todas las integraciones instaladas y `"none"` para no usar ninguna integración.

first_step (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben registrar y evaluar el primer `global_step` o no.

nan_inf_filter (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben filtrar las pérdidas `nan` e `inf` para el registro. Si se establece en `True`, se filtra la pérdida de cada paso que sea `nan` o `inf` y se toma la pérdida media de la ventana de registro actual. `nan_inf_filter` solo influye en el registro de los valores de pérdida; no modifica el comportamiento con el que se calcula o aplica el gradiente al modelo.

on_each_node (`bool`, *opcional*, valor predeterminado `True`) : En el entrenamiento distribuido multinodo, si se registran los registros usando `log_level` una vez por nodo o solo en el nodo principal.

replica_level (`str`, *opcional*, valor predeterminado `"passive"`) : Nivel de registro del logger a usar en las réplicas. Mismas opciones que `log_level`

Un método que agrupa todos los argumentos relacionados con el registro.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

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

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

**Parámetros:**

name (`str` o [SchedulerType](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.SchedulerType), *opcional*, valor predeterminado `"linear"`) : El tipo de programador a utilizar. Consulte la documentación de [SchedulerType](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.SchedulerType) para ver todos los valores posibles.

num_epochs(`float`, *opcional*, valor predeterminado 3.0) : Número total de épocas de entrenamiento a realizar (si no es un número entero, se ejecutará el porcentaje correspondiente a la parte decimal de la última época antes de detener el entrenamiento).

max_steps (`int`, *opcional*, valor predeterminado: -1) : Si se establece en un número positivo, indica el número total de pasos de entrenamiento a realizar. Anula a `num_train_epochs`. Para un conjunto de datos finito, el entrenamiento se repite a través del conjunto de datos (si se agota todos los datos) hasta alcanzar `max_steps`. Debe establecerse en un valor positivo cuando el conjunto de datos de entrenamiento no implementa `__len__` (por ejemplo, un conjunto de datos de streaming), ya que en ese caso no se puede inferir el número total de pasos y es necesario para acotar el bucle de entrenamiento y configurar el programador de la tasa de aprendizaje.

warmup_steps (`float`, *opcional*, valor predeterminado 0) : Número de pasos utilizados para un calentamiento lineal desde 0 hasta `learning_rate`. Debe ser un entero o un float en el rango `[0,1)`. Si es menor que 1, se interpretará como la proporción de pasos utilizados para un calentamiento lineal desde 0 hasta `learning_rate`.

Un método que agrupa todos los argumentos vinculados al programador de la tasa de aprendizaje y sus hiperparámetros.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

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

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

**Parámetros:**

name (`str` o `training_args.OptimizerNames`, *opcional*, valor predeterminado `"adamw_torch"`) : El optimizador a utilizar: `"adamw_torch"`, `"adamw_torch_fused"`, `"adamw_anyprecision"` o `"adafactor"`.

learning_rate (`float`, *opcional*, valor predeterminado 5e-5) : La tasa de aprendizaje inicial.

weight_decay (`float`, *opcional*, valor predeterminado 0) : El decaimiento de peso que se aplicará (si no es cero) a todas las capas, excepto a los pesos de los sesgos y de LayerNorm.

beta1 (`float`, *opcional*, valor predeterminado 0.9) : El hiperparámetro beta1 para el optimizador adam o sus variantes.

beta2 (`float`, *opcional*, valor predeterminado 0.999) : El hiperparámetro beta2 para el optimizador adam o sus variantes.

epsilon (`float`, *opcional*, valor predeterminado 1e-8) : El hiperparámetro epsilon para el optimizador adam o sus variantes.

args (`str`, *opcional*) : Argumentos opcionales que se proporcionan a AnyPrecisionAdamW (útil solo cuando `optim="adamw_anyprecision"`).

Un método que agrupa todos los argumentos vinculados al optimizador y sus hiperparámetros.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

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

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

**Parámetros:**

model_id (`str`) : El nombre del repositorio que se mantendrá sincronizado con el *output_dir* local. Puede ser un ID de modelo simple, en cuyo caso el modelo se publicará en tu espacio de nombres. En caso contrario, debe ser el nombre completo del repositorio, por ejemplo `"user_name/model"`, lo que te permite publicar en una organización de la que eres miembro con `"organization_name/model"`.

strategy (`str` o `HubStrategy`, *opcional*, valor predeterminado `"every_save"`) : Define el alcance de lo que se envía al Hub y cuándo. Los valores posibles son:  - `"end"`: envía el modelo, su configuración, la processing_class, por ejemplo, el tokenizer (si se pasa al [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer)) y un borrador de la tarjeta del modelo cuando se llama al método [save_model()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.save_model). - `"every_save"`: envía el modelo, su configuración, la processing_class, por ejemplo, el tokenizer (si se pasa al [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer)) y un borrador de la tarjeta del modelo cada vez que se guarda el modelo. Los envíos son asíncronos para no bloquear el entrenamiento, y si los guardados son muy frecuentes, solo se intenta un nuevo envío si el anterior ha finalizado. Se realiza un último envío con el modelo final al terminar el entrenamiento. - `"checkpoint"`: igual que `"every_save"`, pero también se envía el último checkpoint en una subcarpeta llamada last-checkpoint, lo que permite reanudar el entrenamiento fácilmente con `trainer.train(resume_from_checkpoint="last-checkpoint")`. - `"all_checkpoints"`: igual que `"checkpoint"`, pero se envían todos los checkpoints tal como aparecen en la carpeta de salida (de modo que obtendrás una carpeta de checkpoint por cada carpeta en tu repositorio final)

token (`str`, *opcional*) : El token que se usará para subir el modelo al Hub. Por defecto, se utilizará el token de la carpeta de caché obtenido con `hf auth login`.

private_repo (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe hacer privada la repository. Si es `None` (valor predeterminado), la repository será pública a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si la repository ya existe.

always_push (`bool`, *opcional*, valor predeterminado `False`) : A menos que este valor sea `True`, `Trainer` omitirá el envío de un punto de control si el envío anterior no ha finalizado.

revision (`str`, *opcional*) : La revisión que se utilizará al enviar al Hub. Puede ser el nombre de una rama, una etiqueta o un hash de commit.

Un método que agrupa todos los argumentos relacionados con la sincronización de puntos de control con el Hub.

Al llamar a este método, `self.push_to_hub` se establecerá en `True`, lo que significa que `output_dir` iniciará un directorio git sincronizado con el repositorio (determinado por `model_id`) y el contenido se enviará cada vez que se active un guardado (según tu `self.save_strategy`). Llamar a [save_model()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.save_model) también activará un envío.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

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

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

**Parámetros:**

strategy (`str` o [IntervalStrategy](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.IntervalStrategy), *opcional*, valor predeterminado `"steps"`) : La estrategia de guardado de puntos de control a adoptar durante el entrenamiento. Los valores posibles son:  - `"no"`: No se realiza ningún guardado durante el entrenamiento. - `"epoch"`: El guardado se realiza al final de cada época. - `"steps"`: El guardado se realiza cada `save_steps`.

steps (`int`, *opcional*, valor predeterminado 500) : Número de pasos de actualización entre dos guardados de puntos de control si `strategy="steps"`.

total_limit (`int`, *opcional*) : Si se pasa un valor, limitará la cantidad total de puntos de control. Elimina los puntos de control más antiguos en `output_dir`.

on_each_node (`bool`, *opcional*, valor predeterminado `False`) : Al realizar entrenamiento distribuido multinodo, si se deben guardar los modelos y puntos de control en cada nodo o solo en el principal. No se debe activar cuando los distintos nodos utilizan el mismo almacenamiento, ya que los archivos se guardarán con los mismos nombres en cada nodo.

Un método que agrupa todos los argumentos relacionados con el guardado de puntos de control.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

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

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

**Parámetros:**

batch_size (`int` *opcional*, valor predeterminado: 8) : El tamaño del lote por dispositivo (GPU/núcleo de TPU/CPU...) utilizado para las pruebas.

loss_only (`bool`, *opcional*, valor predeterminado `False`) : Ignora todas las salidas excepto la pérdida.

Un método que agrupa todos los argumentos básicos relacionados con las pruebas en un conjunto de datos de validación.

Llamar a este método establecerá automáticamente `self.do_predict` en `True`.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

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

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

**Parámetros:**

learning_rate (`float`, *opcional*, valor predeterminado 5e-5) : La tasa de aprendizaje inicial para el optimizador.

batch_size (`int` *opcional*, valor predeterminado: 8) : El tamaño del lote por dispositivo (GPU/núcleo de TPU/CPU...) utilizado para el entrenamiento.

weight_decay (`float`, *opcional*, valor predeterminado 0) : El decaimiento de peso que se aplicará (si no es cero) a todas las capas, excepto a los pesos de los sesgos y de LayerNorm, en el optimizador.

num_epochs (`float`, *opcional*, valor predeterminado 3.0) : Número total de épocas de entrenamiento a realizar (si no es un número entero, se ejecutará el porcentaje correspondiente a la parte decimal de la última época antes de detener el entrenamiento).

max_steps (`int`, *opcional*, valor predeterminado: -1) : Si se establece en un número positivo, indica el número total de pasos de entrenamiento a realizar. Anula a `num_train_epochs`. Para un conjunto de datos finito, el entrenamiento se repite a través del conjunto de datos (si se agota todos los datos) hasta alcanzar `max_steps`. Debe establecerse en un valor positivo cuando el conjunto de datos de entrenamiento no implementa `__len__` (por ejemplo, un conjunto de datos de streaming), ya que en ese caso no se puede inferir el número total de pasos y es necesario para acotar el bucle de entrenamiento y configurar el programador de la tasa de aprendizaje.

gradient_accumulation_steps (`int`, *opcional*, valor predeterminado: 1) : Número de pasos de actualización para acumular los gradientes antes de realizar un paso de retropropagación/actualización. Al usar la acumulación de gradientes, un paso se cuenta como un paso con retropropagación. Por lo tanto, el registro, la evaluación y el guardado se realizarán cada `gradient_accumulation_steps * xxx_step` ejemplos de entrenamiento.

seed (`int`, *opcional*, valor predeterminado 42) : Semilla aleatoria que se establecerá al inicio del entrenamiento. Para garantizar la reproducibilidad entre ejecuciones, use la función `~Trainer.model_init` para instanciar el modelo si tiene algunos parámetros inicializados aleatoriamente.

activation_checkpointing (`bool`, *opcional*, valor predeterminado `False`) : Si es True, se utiliza el checkpointing de activaciones para ahorrar memoria a costa de una pasada inversa más lenta.

gradient_checkpointing (`bool`, *opcional*) : Alias obsoleto de `activation_checkpointing`, se eliminará en v6.

Un método que agrupa todos los argumentos básicos relacionados con el entrenamiento.

Llamar a este método establecerá automáticamente `self.do_train` en `True`.

Ejemplo:

```py
>>> from transformers import TrainingArguments

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

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

```python
to_dict()
```

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

Serializa esta instancia reemplazando `Enum` por sus valores (para admitir la serialización JSON). Ofusca los valores de los tokens eliminando su valor.

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

```python
to_json_string()
```

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

Serializa esta instancia en una cadena JSON.

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

```python
to_sanitized_dict()
```

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

Serialización saneada para usar con los hparams de TensorBoard

## Seq2SeqTrainingArguments[[transformers.Seq2SeqTrainingArguments]]

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

```python
transformers.Seq2SeqTrainingArguments(output_dir: str | None = None, per_device_train_batch_size: int = 8, num_train_epochs: float = 3.0, max_steps: int = -1, learning_rate: float = 5e-05, lr_scheduler_type: transformers.trainer_utils.SchedulerType | str = 'linear', lr_scheduler_kwargs: dict | str | None = None, warmup_steps: float = 0, optim: transformers.training_args.OptimizerNames | str = 'adamw_torch_fused', optim_args: str | None = None, weight_decay: float = 0.0, adam_beta1: float = 0.9, adam_beta2: float = 0.999, adam_epsilon: float = 1e-08, optim_target_modules: None | str | list[str] = None, gradient_accumulation_steps: int = 1, average_tokens_across_devices: bool = True, max_grad_norm: float = 1.0, label_smoothing_factor: float = 0.0, bf16: bool = False, fp16: bool = False, bf16_full_eval: bool = False, fp16_full_eval: bool = False, tf32: bool | None = None, activation_checkpointing: bool | None = None, activation_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, gradient_checkpointing: bool | None = None, gradient_checkpointing_kwargs: dict[str, typing.Any] | str | None = None, torch_compile: bool = False, torch_compile_backend: str | None = None, torch_compile_mode: str | None = None, use_liger_kernel: bool = False, liger_kernel_config: dict[str, bool] | None = None, use_cache: bool = False, neftune_noise_alpha: float | None = None, torch_empty_cache_steps: int | None = None, auto_find_batch_size: bool = False, logging_strategy: transformers.trainer_utils.IntervalStrategy | str = 'steps', logging_steps: float = 500, logging_first_step: bool = False, log_on_each_node: bool = True, logging_nan_inf_filter: bool = True, include_num_input_tokens_seen: str | bool = 'no', log_level: str = 'passive', log_level_replica: str = 'warning', disable_tqdm: bool | None = None, report_to: None | str | list[str] = 'none', run_name: str | None = None, project: str = 'huggingface', trackio_space_id: str | None = None, trackio_bucket_id: str | None = None, trackio_static_space_id: typing.Union[str, NoneType, typing.Literal[False]] = None, eval_strategy: transformers.trainer_utils.IntervalStrategy | str = 'no', eval_steps: float | None = None, eval_delay: float = 0, per_device_eval_batch_size: int = 8, prediction_loss_only: bool = False, eval_on_start: bool = False, eval_do_concat_batches: bool = True, eval_use_gather_object: bool = False, eval_accumulation_steps: int | None = None, include_for_metrics: list[str] = <factory>, batch_eval_metrics: bool = False, save_only_model: bool = False, save_strategy: transformers.trainer_utils.SaveStrategy | str = 'steps', save_steps: float = 500, save_on_each_node: bool = False, save_total_limit: int | None = None, enable_jit_checkpoint: bool = False, push_to_hub: bool = False, hub_token: str | None = None, hub_private_repo: bool | None = None, hub_model_id: str | None = None, hub_strategy: transformers.trainer_utils.HubStrategy | str = 'every_save', hub_always_push: bool = False, hub_revision: str | None = None, load_best_model_at_end: bool = False, metric_for_best_model: str | None = None, greater_is_better: bool | None = None, ignore_data_skip: bool = False, restore_callback_states_from_checkpoint: bool = False, full_determinism: bool = False, seed: int = 42, data_seed: int | None = None, use_cpu: bool = False, accelerator_config: dict | str | None = None, parallelism_config: typing.Any | None = None, dataloader_drop_last: bool = False, dataloader_num_workers: int = 0, dataloader_pin_memory: bool = True, dataloader_persistent_workers: bool = False, dataloader_prefetch_factor: int | None = None, dataloader_multiprocessing_context: str | None = None, dataloader_in_order: bool = True, remove_unused_columns: bool = True, label_names: list[str] | None = None, train_sampling_strategy: str = 'random', length_column_name: str = 'length', ddp_find_unused_parameters: bool | None = None, ddp_bucket_cap_mb: int | None = None, ddp_broadcast_buffers: bool | None = None, ddp_static_graph: bool | None = None, ddp_backend: str | None = None, ddp_timeout: int = 1800, fsdp: str | None = None, fsdp_config: dict[str, typing.Any] | str | None = None, deepspeed: dict | str | None = None, debug: str | list[transformers.debug_utils.DebugOption] = '', skip_memory_metrics: bool = True, do_train: bool = False, do_eval: bool = False, do_predict: bool = False, resume_from_checkpoint: str | None = None, local_rank: int = -1, sortish_sampler: bool = False, predict_with_generate: bool = False, generation_max_length: int | None = None, generation_num_beams: int | None = None, generation_config: str | pathlib.Path | transformers.generation.configuration_utils.GenerationConfig | None = None)
```

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

**Parámetros:**

output_dir (`str`, *opcional*, valor predeterminado `"trainer_output"`) : El directorio de salida donde se escribirán las predicciones del modelo y los puntos de control.

**Duración del entrenamiento y tamaño del lote:**

per_device_train_batch_size (`int`, *opcional*, valor predeterminado 8) : El tamaño del lote *por dispositivo*. El **tamaño de lote global** se calcula como: `per_device_train_batch_size * number_of_devices` en configuraciones multi-GPU o distribuidas.

num_train_epochs(`float`, *opcional*, valor predeterminado 3.0) : Número total de épocas de entrenamiento a realizar (si no es un número entero, se ejecutará el porcentaje correspondiente a la parte decimal de la última época antes de detener el entrenamiento).

max_steps (`int`, *opcional*, valor predeterminado: -1) : Anula `num_train_epochs`. Si se establece en un número positivo, indica el número total de pasos de entrenamiento a realizar. Para un conjunto de datos finito, el entrenamiento se repite a través del conjunto de datos (si se agota todos los datos) hasta alcanzar `max_steps`. Debe establecerse en un valor positivo cuando el conjunto de datos de entrenamiento no implementa `__len__` (por ejemplo, un conjunto de datos de streaming), ya que en ese caso no se puede inferir el número total de pasos y se necesita para acotar el bucle de entrenamiento y configurar el programador de la tasa de aprendizaje.

**Tasa de aprendizaje y programador:**

learning_rate (`float`, *opcional*, valor predeterminado 5e-5) : La tasa de aprendizaje inicial del optimizador. Normalmente, esta es la tasa de aprendizaje máxima al usar un programador con calentamiento.

lr_scheduler_type (`str` o [SchedulerType](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.SchedulerType), *opcional*, valor predeterminado `"linear"`) : El tipo de programador de tasa de aprendizaje a utilizar. Consulte [SchedulerType](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.SchedulerType) para ver todos los valores posibles. Opciones comunes: - "linear" = [get_linear_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup) - "cosine" = [get_cosine_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_cosine_schedule_with_warmup) - "constant" =  [get_constant_schedule()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_constant_schedule) - "constant_with_warmup" = [get_constant_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_constant_schedule_with_warmup)

lr_scheduler_kwargs (`dict` o `str`, *opcional*, valor predeterminado `None`) : Los argumentos adicionales para el lr_scheduler. Consulte la documentación de cada scheduler para conocer los valores posibles.

warmup_steps (`int` o `float`, *opcional*, valor predeterminado 0) : Número de pasos para un calentamiento lineal desde 0 hasta `learning_rate`. El calentamiento ayuda a estabilizar el entrenamiento en la fase inicial. Puede ser: - Un entero: número exacto de pasos de calentamiento - Un float en el rango [0, 1): se interpreta como la proporción de los pasos totales de entrenamiento

**Optimizador:**

optim (`str` o `training_args.OptimizerNames`, *opcional*, valor predeterminado `"adamw_torch"` (para torch>=2.8 `"adamw_torch_fused"`)) : El optimizador a utilizar. Opciones comunes: - `"adamw_torch"`: AdamW de PyTorch (predeterminado recomendado) - `"adamw_torch_fused"`: Núcleo de AdamW fusionado - `"adamw_hf"`: Implementación de AdamW de HuggingFace - `"sgd"`: Descenso de gradiente estocástico con momento - `"adafactor"`: Optimizador eficiente en memoria para modelos grandes - `"adamw_8bit"`: AdamW de 8 bits (requiere bitsandbytes) Consulte `OptimizerNames` para la lista completa.

optim_args (`str`, *opcional*) : Argumentos opcionales que se proporcionan a optimizadores como AnyPrecisionAdamW, AdEMAMix y GaLore.

weight_decay (`float`, *opcional*, valor predeterminado 0) : Coeficiente de decaimiento de peso aplicado por el optimizador (no por la función de pérdida). Añade regularización L2 para evitar el sobreajuste penalizando los pesos grandes. Se excluye automáticamente de los parámetros de sesgo y LayerNorm. Valores típicos: 0.01 (estándar), 0.1 (regularización más fuerte), 0.0 (sin regularización).

adam_beta1 (`float`, *opcional*, valor predeterminado 0.9) : La tasa de decaimiento exponencial para las estimaciones del primer momento (momentum) en optimizadores basados en Adam. Controla la cantidad de historial de gradientes que se conserva.

adam_beta2 (`float`, *opcional*, valor predeterminado 0.999) : Tasa de decaimiento exponencial para las estimaciones del segundo momento (varianza) en optimizadores basados en Adam. Controla la escalado adaptativo de la tasa de aprendizaje.

adam_epsilon (`float`, *opcional*, valor predeterminado 1e-8) : Valor de epsilon para la estabilidad numérica en optimizadores basados en Adam. Evita la división por cero en el denominador de la regla de actualización.

optim_target_modules (`Union[str, list[str]]`, *opcional*) : Los módulos objetivo a optimizar, es decir, los nombres de los módulos que desea entrenar. Actualmente se utiliza para el [algoritmo GaLore](https://huggingface.co/papers/2403.03507) y el [algoritmo APOLLO](https://huggingface.co/papers/2412.05270). Consulte [implementación de GaLore](https://github.com/jiaweizzhao/GaLore) y [implementación de APOLLO](https://github.com/zhuhanqing/APOLLO) para más detalles. Debe asegurarse de pasar un optimizador GaLore o APOLLO válido, por ejemplo, uno de los siguientes: "apollo_adamw", "galore_adamw", "galore_adamw_8bit", "galore_adafactor", y asegurarse de que los módulos objetivo sean únicamente módulos `nn.Linear`.

**Regularización y estabilidad del entrenamiento:**

gradient_accumulation_steps (`int`, *opcional*, valor predeterminado: 1) : Número de pasos de actualización para acumular gradientes antes de realizar un paso de retropropagación/actualización. Simula tamaños de lote más grandes sin memoria adicional. Tamaño de lote efectivo = `per_device_train_batch_size × num_devices × gradient_accumulation_steps`. > [!TIP] > Al usar acumulación de gradientes, un "paso" se cuenta como un paso con retropropagación. Por lo tanto, el registro, la evaluación y el guardado se realizarán cada `gradient_accumulation_steps × xxx_step` ejemplos de entrenamiento.

average_tokens_across_devices (`bool`, *opcional*, valor predeterminado `True`) : Indica si se promedian los tokens entre dispositivos. Si está habilitado, se usará all_reduce para sincronizar num_tokens_in_batch para un cálculo preciso de la pérdida. Referencia: https://github.com/huggingface/transformers/issues/34242

max_grad_norm (`float`, *opcional*, valor predeterminado 1.0) : Norma máxima del gradiente para el recorte de gradientes. Se aplica después de la propagación hacia atrás, antes del paso del optimizador. Previene la explosión de gradientes reduciendo la escala de los gradientes cuando su norma global supera este umbral. Establezca 0 para desactivar el recorte. Valores típicos: 1.0 (estándar), 0.5 (más conservador), 5.0 (menos agresivo).

label_smoothing_factor (`float`, *opcional*, valor predeterminado 0.0) : Factor de suavizado de etiquetas para evitar la sobreconfianza. Sustituye las dianas duras 0/1 por dianas suaves: 0 se convierte en `ε/num_labels` y 1 en `1 - ε + ε/num_labels`, donde ε = `label_smoothing_factor`. Cero significa que no se aplica suavizado. Rango típico: de 0.0 a 0.1.

**Entrenamiento con precisión mixta:**

bf16 (`bool`, *opcional*, valor predeterminado `False`) : Habilita el entrenamiento con precisión mixta bfloat16 (BF16). Generalmente se prefiere sobre FP16 debido a su mejor estabilidad numérica y a que no requiere escalado de pérdida.

fp16 (`bool`, *opcional*, valor predeterminado `False`) : Habilita el entrenamiento con precisión mixta float16 (FP16). Considere usar BF16 en su lugar si su hardware lo admite.

bf16_full_eval (`bool`, *opcional*, valor predeterminado `False`) : Utiliza precisión BF16 completa para la evaluación (no solo precisión mixta). Es más rápido y ahorra memoria, pero puede afectar ligeramente los valores de las métricas. Solo se aplica durante la evaluación.

fp16_full_eval (`bool`, *opcional*, valor predeterminado `False`) : Utiliza precisión FP16 completa para la evaluación (no solo precisión mixta). Es más rápido y ahorra memoria, pero puede afectar ligeramente los valores de las métricas. Solo se aplica durante la evaluación.

tf32 (`bool`, *opcional*) : Habilita el modo TensorFloat-32 (TF32) en GPUs Ampere y más recientes. TF32 utiliza una precisión de 19 bits para las multiplicaciones de matrices (en lugar de los 23 bits de FP32), lo que proporciona una aceleración de hasta 8x con una pérdida de precisión despreciable. El valor predeterminado depende de la versión de PyTorch. Consulte la [documentación de TF32](https://huggingface.co/docs/transformers/perf_train_gpu_one#tf32).

**Checkpointing de activaciones:**

activation_checkpointing (`bool`, *opcional*, valor predeterminado `False`) : Habilita el checkpointing de activaciones para intercambiar cómputo por memoria. Reduce el uso de memoria liberando las activaciones durante la pasada hacia adelante y recalculándolas durante la pasada hacia atrás. Permite entrenar modelos o tamaños de lote más grandes a costa de un entrenamiento aproximadamente un 20 % más lento.

activation_checkpointing_kwargs (`dict`, *opcional*, valor predeterminado `None`) : Argumentos de palabra clave que se pasan a `activation_checkpointing_enable()`. `every_n_layers` realiza el checkpoint solo de cada n-ésima capa del decodificador en lugar de todas; `1` es el comportamiento habitual de todo o nada, y los valores más grandes devuelven algo de memoria a cambio de velocidad. `offload` mantiene las activaciones guardadas en memoria de host fijada, lo que libera `layers x sequence x hidden` bytes de memoria del dispositivo y hace que el paso sea más lento. Cualquier otra clave se reenvía a `torch.utils.checkpoint.checkpoint`.

gradient_checkpointing (`bool`, *opcional*) : Alias obsoleto de `activation_checkpointing`, se eliminará en v6.

gradient_checkpointing_kwargs (`dict`, *opcional*) : Alias obsoleto de `activation_checkpointing_kwargs`, se eliminará en v6.

**Compilación:**

torch_compile (`bool`, *opcional*, valor predeterminado `False`) : Compila el modelo usando `torch.compile()` de PyTorch 2.0 para un entrenamiento más rápido. Puede proporcionar una aceleración del 20-50 % sin cambios en el código. Utiliza la configuración de compilación predeterminada a menos que se especifique `torch_compile_backend` o `torch_compile_mode`.

torch_compile_backend (`str`, *opcional*) : Backend para `torch.compile()`. Si se establece, habilita automáticamente `torch_compile`. Las opciones incluyen `"inductor"` (predeterminado), `"aot_eager"`, `"cudagraphs"`. Los backends varían según la versión de PyTorch; consulte la documentación de PyTorch para ver las opciones disponibles.

torch_compile_mode (`str`, *opcional*) : Modo de compilación para `torch.compile()`. Si se establece, habilita automáticamente `torch_compile`. Opciones: `"default"`, `"reduce-overhead"` (minimizar la sobrecarga de Python), `"max-autotune"` (optimización agresiva, tiempo de compilación más lento).

**Núcleos:**

use_liger_kernel (`bool`, *opcional*, valor predeterminado `False`) : Habilita las optimizaciones de [Liger Kernel](https://github.com/linkedin/Liger-Kernel). Aumenta el rendimiento en multi-GPU en un ~20 % y reduce el uso de memoria en un ~60 %. Funciona con Flash Attention, FSDP y DeepSpeed. Actualmente, es compatible con los modelos Llama, Mistral, Mixtral y Gemma.

liger_kernel_config (`Optional[dict]`, *opcional*) : Configuración para Liger Kernel. Se pasa como kwargs a `_apply_liger_kernel_to_instance()`. Las opciones suelen incluir: `"rope"`, `"swiglu"`, `"cross_entropy"`, `"fused_linear_cross_entropy"`, `"rms_norm"`. Si es `None`, se utiliza la configuración predeterminada.

**Optimizaciones adicionales:**

use_cache (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe habilitar la caché para el modelo. Para el entrenamiento, generalmente no es necesario, salvo en algunos métodos de PEFT que utilizan `past_key_values`.

neftune_noise_alpha (`Optional[float]`) : Si no es `None`, esto activará las incrustaciones de ruido de NEFTune. Esto puede mejorar drásticamente el rendimiento del modelo para el ajuste fino de instrucciones. Consulta el [artículo original](https://huggingface.co/papers/2310.05914) y el [código original](https://github.com/neelsjain/NEFTune). Admite `PreTrainedModel` de transformers y también `PeftModel` de peft. El artículo original utilizó valores en el rango [5.0, 15.0].

torch_empty_cache_steps (`int`, *opcional*) : Número de pasos a esperar antes de llamar a `torch.<device>.empty_cache()`. Si se deja sin establecer o se establece en None, la caché no se vaciará. Esto puede ayudar a evitar errores de memoria insuficiente de CUDA reduciendo el uso pico de VRAM, a costa de un [rendimiento aproximadamente un 10% más lento](https://github.com/huggingface/transformers/issues/31372).

auto_find_batch_size (`bool`, *opcional*, valor predeterminado `False`) : Si se debe encontrar automáticamente un tamaño de lote de entrenamiento que quepa en la memoria mediante decaimiento exponencial, evitando errores de memoria insuficiente de CUDA. El tamaño de lote de evaluación no se ajusta.

**Registro y supervisión del entrenamiento:**

logging_strategy (`str` o [IntervalStrategy](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.IntervalStrategy), *opcional*, valor predeterminado `"steps"`) : La estrategia de registro que se adoptará durante el entrenamiento. Los valores posibles son: - `"no"`: No se realiza ningún registro durante el entrenamiento. - `"epoch"`: El registro se realiza al final de cada época. - `"steps"`: El registro se realiza cada `logging_steps`.

logging_steps (`int` o `float`, *opcional*, valor predeterminado: 500) : Número de pasos de actualización entre dos registros si `logging_strategy="steps"`. Debe ser un entero o un flotante en el rango `[0,1)`. Si es menor que 1, se interpretará como la proporción de los pasos totales de entrenamiento.

logging_first_step (`bool`, *opcional*, valor predeterminado `False`) : Indica si se registran o no los primeros `global_step`.

log_on_each_node (`bool`, *opcional*, valor predeterminado `True`) : En el entrenamiento distribuido multinodo, si se registran los registros usando `log_level` una vez por nodo o solo en el nodo principal.

logging_nan_inf_filter (`bool`, *opcional*, valor predeterminado `True`) : Filtra las pérdidas NaN e Inf al registrar. Si `True`, reemplaza las pérdidas de entrenamiento NaN/Inf con el promedio de las pérdidas válidas recientes y excluye los lotes NaN/Inf (p. ej., lotes sin tokens de etiqueta) de la pérdida de evaluación. No afecta el cálculo de gradientes, solo el registro.

include_num_input_tokens_seen (`Optional[Union[str, bool]]`, *opcional*, valor predeterminado: "no") : Indica si se debe registrar el número de tokens de entrada vistos. Debe ser uno de ["all", "non_padding", "no"] o un valor booleano que se mapea a "all" o "no". Puede ser más lento en el entrenamiento distribuido, ya que se deben llamar operaciones de gather.

**Registro:**

log_level (`str`, *opcional*, valor predeterminado `passive`) : Nivel de registro para el proceso principal. Opciones: `"debug"`, `"info"`, `"warning"`, `"error"`, `"critical"` o `"passive"` (no cambia el nivel de registro actual de Transformers, que por defecto es `"warning"`)

log_level_replica (`str`, *opcional*, valor predeterminado `"warning"`) : Nivel de registro para los procesos de réplica en el entrenamiento distribuido. Mismas opciones que `log_level`.

disable_tqdm (`bool`, *opcional*) : Desactiva las barras de progreso de tqdm. El valor predeterminado es `True` si `log_level` es warning o inferior, y `False` en caso contrario.

**Integración de seguimiento de experimentos:**

report_to (`str` o `list[str]`, *opcional*, valor predeterminado `"none"`) : La lista de integraciones a las que se enviarán los resultados y los registros. Las plataformas admitidas son `"azure_ml"`, `"clearml"`, `"codecarbon"`, `"comet_ml"`, `"dagshub"`, `"dvclive"`, `"flyte"`, `"mlflow"`, `"swanlab"`, `"tensorboard"`, `"trackio"` y `"wandb"`. Use `"all"` para enviar informes a todas las integraciones instaladas y `"none"` para no usar ninguna integración.

run_name (`str`, *opcional*) : Un descriptor para la ejecución. Se utiliza típicamente para el registro en [trackio](https://github.com/gradio-app/trackio), [wandb](https://www.wandb.com/), [mlflow](https://www.mlflow.org/), [comet](https://www.comet.com/site) y [swanlab](https://swanlab.cn).

project (`str`, *opcional*, valor predeterminado `"huggingface"`) : El nombre del proyecto que se usará para el registro. Actualmente, solo lo utiliza Trackio.

trackio_space_id (`str` o `None`, *opcional*, valor predeterminado `None`) : El ID del Space de Hugging Face que se usará para el registro en vivo de Trackio con un Space basado en Gradio. Debe ser un nombre completo de Space como `'username/reponame'` o `'orgname/reponame'`, o simplemente `'reponame'` (el Space se crea en el espacio de nombres del usuario actualmente conectado). Si es `None`, las métricas se registran solo en un directorio **local** (sin Space en el Hub). Ese Space de Gradio tiene acceso de **lectura y escritura** al **Bucket** de Trackio, lo cual es lo que se desea mientras el entrenamiento está **en curso**, por ejemplo, al **reanudar** una ejecución parcial o **agregar registros** de varias máquinas. El Space será **público** a menos que se establezca `hub_private_repo=True` o el valor predeterminado de su organización sea crear Spaces privados.

trackio_bucket_id (`str` o `None`, *opcional*, valor predeterminado `None`) : id de Bucket de Hugging Face opcional para Trackio. Si no se establece, Trackio lo deriva. Se utiliza junto con un Space de Gradio (`trackio_space_id`) y al desplegar un Space estático (`trackio_static_space_id` no es `False`).

trackio_static_space_id (`str`, `False` o `None`, *opcional*, valor predeterminado `None`) : El ID del Hugging Face Space que se usará para el Space estático creado una vez finalizado el entrenamiento. Debe ser un nombre completo de Space como `'username/reponame'` o `'orgname/reponame'`, o simplemente `'reponame'` (el Space se crea en el espacio de nombres del usuario actualmente conectado). Si es False, no se creará ningún Space estático. Si es None y el modelo se sube al Hub, se creará un Space estático con un nombre predeterminado y se enlazará desde la tarjeta del modelo. El Space será público a menos que establezcas `hub_private_repo=True` o el valor predeterminado de tu organización sea crear Spaces privados.

**Evaluación:**

eval_strategy (`str` o [IntervalStrategy](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.IntervalStrategy), *opcional*, valor predeterminado `"no"`) : Cuándo ejecutar la evaluación. Opciones: - `"no"`: No se realiza evaluación durante el entrenamiento - `"steps"`: Evaluar cada `eval_steps` - `"epoch"`: Evaluar al final de cada época

eval_steps (`int` o `float`, *opcional*) : Número de pasos de actualización entre dos evaluaciones si `eval_strategy="steps"`. Si no se establece, tomará por defecto el mismo valor que `logging_steps`. Debe ser un entero o un float en el rango `[0,1)`. Si es menor que 1, se interpretará como la proporción de los pasos totales de entrenamiento.

eval_delay (`float`, *opcional*) : Número de épocas o pasos que se deben esperar antes de que se pueda realizar la primera evaluación, según el eval_strategy.

per_device_eval_batch_size (`int`, *opcional*, valor predeterminado: 8) : El tamaño de lote por núcleo de acelerador/CPU del dispositivo para la evaluación.

prediction_loss_only (`bool`, *opcional*, valor predeterminado `False`) : Al realizar la evaluación y generar predicciones, solo devuelve la pérdida.

eval_on_start (`bool`, *opcional*, valor predeterminado `False`) : Si se debe realizar un paso de evaluación (verificación de coherencia) antes del entrenamiento para asegurarse de que los pasos de validación funcionen correctamente.

eval_do_concat_batches (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben concatenar recursivamente las entradas, pérdidas, etiquetas y predicciones entre lotes. Si es `False`, se almacenarán como listas, manteniendo cada lote separado.

eval_use_gather_object (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe ejecutar de forma recursiva la recopilación de objetos en una lista, tupla o diccionario anidado de objetos desde todos los dispositivos. Esto solo debe activarse si los usuarios no están devolviendo únicamente tensores, y PyTorch desaconseja activamente esta opción. Es útil cuando la estructura de las etiquetas no es estándar, como en tareas de visión por computadora.

eval_accumulation_steps (`int`, *opcional*) : Número de pasos de predicción para acumular los tensores de salida antes de mover los resultados a la CPU. Si no se establece, todas las predicciones se acumulan en el acelerador del dispositivo antes de moverse a la CPU (más rápido, pero requiere más memoria).

**Cálculo de métricas:**

include_for_metrics (`list[str]`, *opcional*, valor predeterminado `[]`) : Incluye datos adicionales en la función `compute_metrics` si son necesarios para el cálculo de métricas. Opciones posibles para añadir a la lista `include_for_metrics`: - `"inputs"`: Datos de entrada pasados al modelo, destinados al cálculo de métricas dependientes de la entrada. - `"loss"`: Valores de pérdida calculados durante la evaluación, destinados al cálculo de métricas dependientes de la pérdida.

batch_eval_metrics (`bool`, *opcional*, valor predeterminado `False`) : Si se establece en `True`, la evaluación llamará a compute_metrics al final de cada batch para acumular estadísticas en lugar de guardar todos los logits de evaluación en memoria. Cuando se establece en `True`, debe pasar una función compute_metrics que reciba un argumento booleano `compute_result`; al pasarle `True`, se activará el resumen global final de estadísticas a partir de las estadísticas de resumen a nivel de batch que haya acumulado sobre el conjunto de evaluación.

**Puntos de control y guardado:**

save_only_model (`bool`, *opcional*, valor predeterminado `False`) : Guarda solo los pesos del modelo, no el estado del optimizador/planificador/RNG. Reduce significativamente el tamaño del punto de control, pero impide reanudar el entrenamiento desde dicho punto de control. Úsalo cuando solo necesites el modelo entrenado para inferencia, no para continuar el entrenamiento. Con esta opción establecida en `True`, solo puedes cargar el modelo mediante `from_pretrained`.

save_strategy (`str` o `SaveStrategy`, *opcional*, valor predeterminado `"steps"`) : La estrategia de guardado de puntos de control a adoptar durante el entrenamiento. Los valores posibles son: - `"no"`: No se realiza ningún guardado durante el entrenamiento. - `"epoch"`: El guardado se realiza al final de cada época. - `"steps"`: El guardado se realiza cada `save_steps`. - `"best"`: El guardado se realiza cada vez que se alcanza una nueva `best_metric`.

save_steps (`int` o `float`, *opcional*, valor predeterminado: 500) : Número de pasos de actualización entre dos guardados de puntos de control si `save_strategy="steps"`. Debe ser un entero o un flotante en el rango `[0,1)`. Si es menor que 1, se interpretará como la proporción de los pasos totales de entrenamiento.

save_on_each_node (`bool`, *opcional*, valor predeterminado `False`) : Al realizar entrenamiento distribuido multinodo, si se deben guardar los modelos y puntos de control en cada nodo o solo en el principal. No se debe activar cuando los distintos nodos utilizan el mismo almacenamiento, ya que los archivos se guardarán con los mismos nombres en cada nodo.

save_total_limit (`int`, *opcional*) : Número máximo de puntos de control que se conservarán. Elimina los puntos de control más antiguos de `output_dir`. Cuando `load_best_model_at_end=True`, siempre se conserva el mejor punto de control, además de los más recientes. Por ejemplo, `save_total_limit=5` conserva los 4 más recientes y el mejor.

enable_jit_checkpoint (`bool`, *opcional*, valor predeterminado `False`) : Habilita el checkpointing Just-In-Time ante la señal SIGTERM para una terminación ordenada en cargas de trabajo preemibles. **Importante**: Configure el período de apagado ordenado de su orquestador para permitir un tiempo suficiente. En Kubernetes, establezca `terminationGracePeriodSeconds` (el valor predeterminado de 30 s suele ser insuficiente). En Slurm, use `--signal=TERM@<seconds>`. El período de gracia requerido debe ser ≥ al tiempo de la iteración más larga + el tiempo de guardado del checkpoint.

**Integración con Hugging Face Hub:**

push_to_hub (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe subir el modelo al Hub cada vez que se guarda. Si se activa, `output_dir` iniciará un directorio git sincronizado con el repositorio (determinado por `hub_model_id`) y el contenido se enviará cada vez que se active un guardado (según tu `save_strategy`). Llamar a [save_model()](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer.save_model) también activará un envío.

hub_token (`str`, *opcional*) : El token que se usará para subir el modelo al Hub. Por defecto, se utilizará el token de la carpeta de caché obtenido con `hf auth login`.

hub_private_repo (`bool`, *opcional*) : Indica si se debe hacer privada la repository. Si es `None` (valor predeterminado), la repository será pública a menos que el valor predeterminado de la organización sea privado. Este valor se ignora si la repository ya existe. Si se informa a Trackio con la implementación en Hugging Face Spaces habilitada, la misma lógica determina si el Space es privado.

hub_model_id (`str`, *opcional*) : El nombre del repositorio que se mantendrá sincronizado con el *output_dir* local. Puede ser un ID de modelo simple, en cuyo caso el modelo se publicará en su espacio de nombres. En caso contrario, debe ser el nombre completo del repositorio, por ejemplo `"user_name/model"`, lo que le permite publicar en una organización de la que es miembro con `"organization_name/model"`. El valor predeterminado será `user_name/output_dir_name`, donde *output_dir_name* es el nombre de `output_dir`.

hub_strategy (`str` o `HubStrategy`, *opcional*, valor predeterminado `"every_save"`) : Define qué y cuándo se envía a Hub. Opciones: - `"end"`: Enviar solo al final del entrenamiento - `"every_save"`: Enviar en cada guardado (asíncrono para no bloquear el entrenamiento) - `"checkpoint"`: Como `"every_save"` más enviar el último punto de control a la subcarpeta `"last-checkpoint"` para facilitar la reanudación - `"all_checkpoints"`: Enviar todos los puntos de control a medida que aparecen

hub_always_push (`bool`, *opcional*, valor predeterminado `False`) : A menos que este valor sea `True`, `Trainer` omitirá el envío de un punto de control si el envío anterior no ha finalizado.

hub_revision (`str`, *opcional*) : La revisión que se utilizará al enviar al Hub. Puede ser el nombre de una rama, una etiqueta o un hash de commit.

**Seguimiento óptimo de modelos:**

load_best_model_at_end (`bool`, *opcional*, valor predeterminado `False`) : Carga el mejor punto de control al final del entrenamiento. Requiere que `eval_strategy` esté configurado. Cuando está habilitado, el mejor punto de control se guarda siempre (ver `save_total_limit`).  Cuando `True`, `save_strategy` debe coincidir con `eval_strategy` (a menos que `save_strategy` sea `"best"`), y si se usa `"steps"`, `save_steps` debe ser un múltiplo de `eval_steps`.

metric_for_best_model (`str`, *opcional*) : Métrica a utilizar para comparar modelos cuando `load_best_model_at_end=True`. Debe ser un nombre de métrica devuelto por la evaluación, con o sin el prefijo `"eval_"`. El valor predeterminado es `"loss"`. Si se establece este parámetro, `greater_is_better` se establecerá en `True` por defecto, a menos que el nombre termine en `"loss"`. Ejemplos: `"accuracy"`, `"f1"`, `"eval_bleu"`.

greater_is_better (`bool`, *opcional*) : Indica si valores más altos de la métrica son mejores. El valor predeterminado se basa en `metric_for_best_model`: `True` si el nombre de la métrica no termina en `"loss"`, `False` en caso contrario.

**Reanudar el entrenamiento:**

ignore_data_skip (`bool`, *opcional*, valor predeterminado `False`) : Al reanudar el entrenamiento, omite el avance rápido a través del conjunto de datos para alcanzar el estado anterior. Si es `True`, el entrenamiento comienza desde el principio del conjunto de datos (reanudación más rápida, pero los resultados no coincidirán con el entrenamiento interrumpido). Si es `False`, omite los datos ya vistos (reanudación más lenta, pero continuación exacta).

restore_callback_states_from_checkpoint (`bool`, *opcional*, valor predeterminado `False`) : Restaura los estados de los callbacks desde el checkpoint al reanudar. Si es `True`, sobrescribirá los callbacks pasados a Trainer si existen en el checkpoint.

**Reproducibilidad:**

full_determinism (`bool`, *opcional*, valor predeterminado `False`) : Si es `True`, se llama a [enable_full_determinism()](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.enable_full_determinism) en lugar de [set_seed()](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.set_seed) para garantizar resultados reproducibles en el entrenamiento distribuido. Importante: esto afectará negativamente el rendimiento, por lo que solo debe usarse para depuración.

seed (`int`, *opcional*, valor predeterminado 42) : Semilla aleatoria que se establecerá al inicio del entrenamiento. Para garantizar la reproducibilidad entre ejecuciones, use la función `~Trainer.model_init` para instanciar el modelo si tiene algunos parámetros inicializados aleatoriamente.

data_seed (`int`, *opcional*) : Semilla aleatoria que se usará con los muestreadores de datos. Si no se establece, los generadores aleatorios para el muestreo de datos usarán la misma semilla que `seed`. Esto se puede usar para garantizar la reproducibilidad del muestreo de datos, de forma independiente de la semilla del modelo.

**Configuración del hardware:**

use_cpu (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar la CPU. Si se establece en False, se utilizará el dispositivo/backend de torch disponible.

**Configuración de Accelerate:**

accelerator_config (`str`, `dict` o `AcceleratorConfig`, *opcional*) : Configuración para la integración interna de Accelerate. Puede ser: - Ruta al archivo de configuración JSON: `"accelerator_config.json"` - Diccionario con opciones de configuración - Instancia de `AcceleratorConfig` Opciones clave: - `split_batches` (`bool`, valor predeterminado `False`): Si se dividen los lotes entre dispositivos. Si es `True`, el tamaño real del lote es el mismo en todos los dispositivos (el total debe ser divisible por num_processes). Si es `False`, cada dispositivo recibe el tamaño de lote especificado. - `dispatch_batches` (`bool`): Si es `True`, solo el proceso principal itera a través del dataloader y envía los lotes a los dispositivos. El valor predeterminado es `True` para `IterableDataset` y `False` en caso contrario. - `even_batches` (`bool`, valor predeterminado `True`): Duplica muestras desde el inicio del conjunto de datos para garantizar que todos los workers reciban tamaños de lote iguales. - `use_seedable_sampler` (`bool`, valor predeterminado `True`): Utiliza un muestreador aleatorio completamente sembrable para la reproducibilidad. - `use_configured_state` (`bool`, valor predeterminado `False`): Utiliza un `AcceleratorState`/`PartialState` preinicializado en lugar de crear uno nuevo. Puede causar problemas con el ajuste de hiperparámetros.

parallelism_config (`ParallelismConfig`, *opcional*) : Configuración de paralelismo para la ejecución de entrenamiento. Requiere Accelerate `1.10.1`

**Cargador de datos:**

dataloader_drop_last (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe descartar el último lote incompleto (si la longitud del conjunto de datos no es divisible por el tamaño del lote) o no.

dataloader_num_workers (`int`, *opcional*, valor predeterminado 0) : Número de subprocesos para usar en la carga de datos (solo PyTorch). 0 significa que los datos se cargarán en el proceso principal.

dataloader_pin_memory (`bool`, *opcional*, valor predeterminado `True`) : Si se desea fijar la memoria en los cargadores de datos o no. El valor predeterminado será `True`.

dataloader_persistent_workers (`bool`, *opcional*, valor predeterminado `False`) : Si es True, el data loader no cerrará los procesos de worker después de que un dataset se haya consumido una vez. Esto permite mantener vivas las instancias de Dataset de los workers. Puede acelerar el entrenamiento, pero aumentará el uso de RAM. El valor predeterminado será `False`.

dataloader_prefetch_factor (`int`, *opcional*) : Número de lotes que cada worker carga de antemano. 2 significa que habrá un total de 2 * num_workers lotes precargados en todos los workers.

dataloader_multiprocessing_context (`str`, *opcional*) : El método de inicio de multiprocesamiento a utilizar para los trabajadores de carga de datos (`"fork"`, `"spawn"` o `"forkserver"`). El valor predeterminado es el método de inicio predeterminado de PyTorch, excepto en MPS con `dataloader_num_workers > 1`, donde el valor predeterminado es `"fork"`. Utilice `"spawn"` al transmitir desde fuentes cuyos objetos no son seguros para fork (por ejemplo, HDFS a través de `pyarrow`). Bajo `"spawn"`, cualquier `collate_fn` personalizado o código de conjunto de datos debe ser importable a nivel de módulo (sin lambdas/closures).

dataloader_in_order (`bool`, *opcional*, valor predeterminado `True`) : Si `True`, el data loader genera lotes en el orden en que se enviaron los workers. Establezca `False` para generar los lotes en cuanto estén listos, lo que puede reducir la latencia de cola en cargas de trabajo de streaming de `IterableDataset`. Requiere PyTorch >= 2.6.

remove_unused_columns (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben eliminar automáticamente las columnas que no utiliza el método forward del modelo.

label_names (`list[str]`, *opcional*) : La lista de claves en su diccionario de entradas que corresponden a las etiquetas. Eventualmente, el valor predeterminado será la lista de nombres de argumentos aceptados por el modelo que contengan la palabra "label", excepto si el modelo utilizado es uno de los `XxxForQuestionAnswering`, en cuyo caso también incluirá las claves `["start_positions", "end_positions"]`. Solo debe especificar `label_names` si está usando nombres de etiquetas personalizados o si el `forward` de su modelo consume múltiples tensores de etiquetas (p. ej., QA extractivo).

train_sampling_strategy (`str`, *opcional*, valor predeterminado `"random"`) : El muestreador que se usará para el dataloader de entrenamiento. Los valores posibles son:  - `"random"`: Usa `RandomSampler` (predeterminado). - `"sequential"`: Usa `SequentialSampler`. - `"group_by_length"`: Usa `LengthGroupedSampler` para agrupar muestras de longitud aproximadamente igual (para minimizar el padding y ser más eficiente). - `"batch_rebalance"`: Usa `BatchRebalanceSampler` para equilibrar el coste de tokens con padding entre dispositivos y pasos de acumulación de gradientes dentro de cada lote efectivo, reduciendo el desperdicio de padding y la memoria pico en comparación con `"group_by_length"`. Actualmente solo se admite para entrenamiento paralelo de datos (el paralelismo de tensores aún no se admite).  Nota: Al usar un `IterableDataset`, este argumento se ignora.

length_column_name (`str`, *opcional*, valor predeterminado `"length"`) : Nombre de la columna para longitudes precalculadas. Si la columna existe, el agrupamiento por longitud usará estos valores en lugar de calcularlos al iniciar el entrenamiento. Se ignora a menos que `train_sampling_strategy` sea `"group_by_length"`o `"batch_rebalance"` y el conjunto de datos sea una instancia de `Dataset`.

**DDP (DistributedDataParallel):**

ddp_find_unused_parameters (`bool`, *opcional*) : Al usar entrenamiento distribuido, el valor de la bandera `find_unused_parameters` que se pasa a `DistributedDataParallel`. Será `False` por defecto si se usa gradient checkpointing, `True` en caso contrario.

ddp_bucket_cap_mb (`int`, *opcional*) : Al usar entrenamiento distribuido, el valor de la bandera `bucket_cap_mb` pasada a `DistributedDataParallel`.

ddp_broadcast_buffers (`bool`, *opcional*) : Al usar entrenamiento distribuido, el valor de la bandera `broadcast_buffers` que se pasa a `DistributedDataParallel`. Será `False` por defecto si se usa gradient checkpointing, `True` en caso contrario.

ddp_static_graph (`bool`, *opcional*) : Al usar entrenamiento distribuido, el valor de la bandera `static_graph` pasada a `DistributedDataParallel`.

ddp_backend (`str`, *opcional*) : El backend a utilizar para el entrenamiento distribuido. Debe ser uno de `"nccl"`, `"mpi"`, `"xccl"`, `"gloo"`, `"hccl"`.

ddp_timeout (`int`, *opcional*, valor predeterminado 1800) : El tiempo de espera para las llamadas a `torch.distributed.init_process_group`, utilizado para evitar tiempos de espera de los sockets de GPU al realizar operaciones lentas en ejecuciones distribuidas. Consulte la [documentación de PyTorch](https://pytorch.org/docs/stable/distributed.html#torch.distributed.init_process_group) para obtener más información.

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

fsdp (`bool`, *opcional*, valor predeterminado `None`) : Habilita PyTorch Fully Sharded Data Parallel (FSDP) para el entrenamiento distribuido. Pasa `True` para habilitar FSDP.

fsdp_config (`str` o `dict`, *opcional*) : Configuración para cuando `fsdp` está habilitado. Pase una ruta a un archivo de configuración JSON, como `fsdp_config.json`, o un diccionario ya cargado. Claves admitidas: - version (`int`, *opcional*, valor predeterminado `2`): La versión de FSDP a utilizar (`2` para FSDP2, `1` para el FSDP1 heredado). - reshard_after_forward (`bool`, *opcional*, valor predeterminado `True`): Si se deben re-fragmentar los parámetros después de la pasada hacia adelante. Establezca `False` para mantener los parámetros reunidos entre las pasadas hacia adelante y hacia atrás, lo que evita el re-all-gather y utiliza más memoria de pico. - cpu_offload (`bool`, *opcional*, valor predeterminado `False`): Descarga los parámetros y gradientes a la CPU cuando no se utilizan para ahorrar memoria de GPU. - activation_checkpointing (`bool`, *opcional*, valor predeterminado `False`): Establezca `True` para reducir la memoria recalculando las activaciones durante la pasada hacia atrás. Al usar FSDP, prefiera esto al argumento de entrenamiento `activation_checkpointing`, que introduce un all-gather redundante en la pasada hacia atrás. - cpu_ram_efficient_loading (`bool`, *opcional*, valor predeterminado `False`): Establezca `True` para cargar el checkpoint preentrenado solo en el primer proceso. Los demás procesos inician con pesos vacíos y reciben los pesos mediante broadcast. - state_dict_type (`str`, *opcional*, valor predeterminado `"FULL_STATE_DICT"`): Formato del checkpoint: `"FULL_STATE_DICT"` (un solo archivo compatible con HF) o `"SHARDED_STATE_DICT"` (un archivo por rank, más rápido para modelos grandes). - auto_wrap_policy (`str`, *opcional*, valor predeterminado `"TRANSFORMER_BASED_WRAP"`): Política de auto-wrap a utilizar. Elija `"TRANSFORMER_BASED_WRAP"`, `"SIZE_BASED_WRAP"` o `"NO_WRAP"`. - transformer_layer_cls_to_wrap (`list[str]`, *opcional*): Nombres de las clases de capas de Transformer (distingue mayúsculas y minúsculas) para envolver, p. ej. `LlamaDecoderLayer`. Generalmente no es necesario: la política de wrap recurre a `_no_split_modules` del modelo, que cubre la mayoría de los modelos de transformers. - min_num_params (`int`, *opcional*, valor predeterminado `0`): Número mínimo de parámetros por módulo para el auto-wrap basado en tamaño (se usa con `auto_wrap_policy="SIZE_BASED_WRAP"`). - xla (`bool`, *opcional*, valor predeterminado `False`): Si se debe utilizar el entrenamiento PyTorch/XLA Fully Sharded Data Parallel. Experimental. - xla_fsdp_settings (`dict`, *opcional*): Diccionario de parámetros de envoltura de XLA FSDP. Para una lista completa de opciones, consulte el [código fuente de XLA FSDP](https://github.com/pytorch/xla/blob/master/torch_xla/distributed/fsdp/xla_fully_sharded_data_parallel.py). - xla_fsdp_grad_ckpt (`bool`, *opcional*, valor predeterminado `False`): Establezca `True` para usar gradient checkpointing en cada capa envuelta por XLA FSDP anidada. Requiere `xla=True` y una política de auto-envoltura (`min_num_params` o `transformer_layer_cls_to_wrap`).

**DeepSpeed:**

deepspeed (`str` o `dict`, *opcional*) : Habilita la integración de [DeepSpeed](https://github.com/deepspeedai/DeepSpeed). El valor es: - Ruta al archivo de configuración JSON de DeepSpeed: `"ds_config.json"` - Configuración cargada como diccionario > [!TIP] > Si se usa la inicialización ZeRO, instancie su modelo *después* de inicializar `TrainingArguments`; de lo contrario, ZeRO no se aplicará.

**Depuración y perfilado (experimental):**

debug (`str` o lista de `DebugOption`, *opcional*, valor predeterminado `""`) : Habilita una o más funciones de depuración. Esta es una función experimental. Las opciones posibles son: - "underflow_overflow": detecta desbordes en las entradas/salidas del modelo e informa de los últimos fotogramas que provocaron el evento - "tpu_metrics_debug": imprime métricas de depuración en TPU

skip_memory_metrics (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe omitir la adición de informes del perfilador de memoria a las métricas. Se omite de forma predeterminada porque ralentiza la velocidad de entrenamiento y evaluación.

**Banderas de script externo (no utilizadas por Trainer):**

do_train (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe ejecutar el entrenamiento o no. Este argumento no se utiliza directamente por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer); está destinado a ser utilizado por sus scripts de entrenamiento/evaluación.

do_eval (`bool`, *opcional*) : Indica si se debe ejecutar la evaluación en el conjunto de validación. Se establecerá en `True` si `eval_strategy` es diferente de `"no"`. Este argumento no se utiliza directamente por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer); está destinado a ser utilizado por sus scripts de entrenamiento/evaluación.

do_predict (`bool`, *opcional*, valor predeterminado `False`) : Indica si se deben ejecutar predicciones en el conjunto de prueba o no. Este argumento no se utiliza directamente por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer); está destinado a ser utilizado por sus scripts de entrenamiento/evaluación.

resume_from_checkpoint (`str`, *opcional*) : La ruta a una carpeta con un punto de control válido para su modelo. Este argumento no se utiliza directamente por [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer); está destinado a ser utilizado por sus scripts de entrenamiento/evaluación.

sortish_sampler (`bool`, *opcional*, valor predeterminado `False`) : Indica si se debe usar un *sortish sampler* o no. Por ahora, solo es posible si los subyacentes datasets son *Seq2SeqDataset*, pero estará disponible de forma general en un futuro próximo. Ordena las entradas según sus longitudes para minimizar el tamaño del padding, con un poco de aleatoriedad para el conjunto de entrenamiento.

predict_with_generate (`bool`, *opcional*, valor predeterminado `False`) : Si se debe usar generate para calcular métricas generativas (ROUGE, BLEU).

generation_max_length (`int`, *opcional*) : El `max_length` a utilizar en cada bucle de evaluación cuando `predict_with_generate=True`. Por defecto, se usará el valor de `max_length` de la configuración del modelo.

generation_num_beams (`int`, *opcional*) : El `num_beams` a utilizar en cada bucle de evaluación cuando `predict_with_generate=True`. Por defecto, se usará el valor de `num_beams` de la configuración del modelo.

generation_config (`str` o `Path` o [GenerationConfig](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig), *opcional*) : Permite cargar un [GenerationConfig](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig) desde el método `from_pretrained`. Puede ser:  - una cadena, el *model id* de una configuración de modelo preentrenado alojada en un repositorio de modelos en huggingface.co. - una ruta a un *directorio* que contiene un archivo de configuración guardado usando el método [save_pretrained()](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig.save_pretrained), p. ej., `./my_model_directory/`. - un objeto [GenerationConfig](/docs/transformers/v5.23.0/es/main_classes/text_generation#transformers.GenerationConfig).

Clase de configuración para controlar todos los aspectos del entrenamiento del modelo con Trainer. TrainingArguments centraliza todos los hiperparámetros, configuraciones de optimización, preferencias de registro y decisiones de infraestructura necesarias para el entrenamiento.

[HfArgumentParser](/docs/transformers/v5.23.0/es/internal/trainer_utils#transformers.HfArgumentParser) puede convertir esta clase en argumentos de [argparse](https://docs.python.org/3/library/argparse#module-argparse) que se pueden especificar en la línea de comandos.

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

```python
to_dict()
```

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

Serializa esta instancia reemplazando `Enum` por sus valores y `GenerationConfig` por diccionarios (para admitir la serialización JSON). Ofusca los valores de los tokens eliminando su valor.