# Optimización

El módulo `.optimization` proporciona:

- un optimizador con decaimiento de pesos fijo que se puede utilizar para ajustar modelos, y
- varias programaciones en forma de objetos de programación que heredan de `_LRSchedule`:
- una clase de acumulación de gradientes para acumular los gradientes de varios lotes

## AdaFactor[[transformers.Adafactor]]

#### transformers.Adafactor[[transformers.Adafactor]]

```python
transformers.Adafactor(params, lr = None, eps = (1e-30, 0.001), clip_threshold = 1.0, decay_rate = -0.8, beta1 = None, weight_decay = 0.0, scale_parameter = True, relative_step = True, warmup_init = False)
```

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

**Parámetros:**

params (`Iterable[nn.parameter.Parameter]`) : Iterable de parámetros para optimizar o diccionarios que definen grupos de parámetros.

lr (`float`, *opcional*) : La tasa de aprendizaje externa.

eps (`tuple[float, float]`, *opcional*, valor predeterminado `(1e-30, 0.001)`) : Constantes de regularización para el gradiente cuadrado y la escala de parámetros, respectivamente

clip_threshold (`float`, *opcional*, valor predeterminado 1.0) : Umbral de la raíz cuadrada media del gradiente final de actualización

decay_rate (`float`, *opcional*, valor predeterminado -0.8) : Coeficiente utilizado para calcular las medias móviles de los cuadrados

beta1 (`float`, *opcional*) : Coeficiente utilizado para calcular las medias móviles del gradiente

weight_decay (`float`, *opcional*, valor predeterminado 0.0) : Decaimiento de peso (penalización L2)

scale_parameter (`bool`, *opcional*, valor predeterminado `True`) : Si es True, la tasa de aprendizaje se escala por la raíz media cuadrada

relative_step (`bool`, *opcional*, valor predeterminado `True`) : Si es True, se calcula una tasa de aprendizaje dependiente del tiempo en lugar de una tasa de aprendizaje externa

warmup_init (`bool`, *opcional*, valor predeterminado `False`) : El cálculo del ritmo de aprendizaje dependiente del tiempo depende de si se está utilizando la inicialización de calentamiento

La implementación de AdaFactor en PyTorch puede usarse como un reemplazo directo del código original de fairseq para Adam: https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py

Artículo: *Adafactor: Adaptive Learning Rates with Sublinear Memory Cost* https://huggingface.co/papers/1804.04235 Tenga en cuenta que este optimizador ajusta internamente la tasa de aprendizaje en función de las opciones `scale_parameter`, `relative_step` y `warmup_init`. Para utilizar un programa de tasa de aprendizaje manual (externo), debe establecer `scale_parameter=False` y `relative_step=False`.

Esta implementación maneja valores de baja precisión (FP16, bfloat), pero no la hemos probado a fondo.

Configuraciones recomendadas para el ajuste fino de T5 (https://discuss.huggingface.co/t/t5-finetuning-tips/684/3):

- No se recomienda el entrenamiento sin LR warmup ni clip_threshold.

  - usar un calentamiento de LR programado hasta una LR fija
  - use clip_threshold=1.0 (https://huggingface.co/papers/1804.04235)
- Desactivar actualizaciones relativas
- Use scale_parameter=False
- Las operaciones adicionales del optimizador, como el recorte de gradientes, no deben usarse junto con Adafactor

Ejemplo:

```python
Adafactor(model.parameters(), scale_parameter=False, relative_step=False, warmup_init=False, lr=1e-3)
```

Otros informaron que la siguiente combinación funciona bien:

```python
Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
```

Al usar `lr=None` con [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer), es muy probable que necesites usar `AdafactorSchedule`

scheduler de la siguiente manera:

```python
from transformers.optimization import Adafactor, AdafactorSchedule

optimizer = Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
lr_scheduler = AdafactorSchedule(optimizer)
trainer = Trainer(..., optimizers=(optimizer, lr_scheduler))
```

Uso:

```python
# replace AdamW with Adafactor
optimizer = Adafactor(
    model.parameters(),
    lr=1e-3,
    eps=(1e-30, 1e-3),
    clip_threshold=1.0,
    decay_rate=-0.8,
    beta1=None,
    weight_decay=0.0,
    relative_step=False,
    scale_parameter=False,
    warmup_init=False,
)
```

#### paso[[transformers.Adafactor.step]]

```python
step(closure = None)
```

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

**Parámetros:**

closure (callable, opcional) : Un cierre que reevalúa el modelo y devuelve la pérdida.

Realiza un paso de optimización

## Programas

### SchedulerType[[transformers.SchedulerType]]

#### transformers.SchedulerType[[transformers.SchedulerType]]

```python
transformers.SchedulerType(value, names = None, module = None, qualname = None, type = None, start = 1, boundary = None)
```

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

Nombres de programadores para el parámetro `lr_scheduler_type` en [TrainingArguments](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.TrainingArguments). De forma predeterminada, utiliza "linear". Internamente, esto recupera el programador `get_linear_schedule_with_warmup` de [Trainer](/docs/transformers/v5.23.0/es/main_classes/trainer#transformers.Trainer). Tipos de programador:
- "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)
- "cosine_with_restarts" = [get_cosine_with_hard_restarts_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_cosine_with_hard_restarts_schedule_with_warmup)
- "polynomial" = [get_polynomial_decay_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_polynomial_decay_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)
- "inverse_sqrt" = [get_inverse_sqrt_schedule()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_inverse_sqrt_schedule)
- "reduce_lr_on_plateau" = [get_reduce_on_plateau_schedule()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_reduce_on_plateau_schedule)
- "cosine_with_min_lr" = [get_cosine_with_min_lr_schedule_with_warmup()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_cosine_with_min_lr_schedule_with_warmup)
- "cosine_warmup_with_min_lr" = [get_cosine_with_min_lr_schedule_with_warmup_lr_rate()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate)
- "warmup_stable_decay" = [get_wsd_schedule()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_wsd_schedule)
- "greedy" = [get_greedy_schedule()](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.get_greedy_schedule)

### get_scheduler[[transformers.get_scheduler]]

#### transformers.get_scheduler[[transformers.get_scheduler]]

```python
transformers.get_scheduler(name: str | SchedulerType, optimizer: Optimizer, num_warmup_steps: int | None = None, num_training_steps: int | None = None, scheduler_specific_kwargs: dict | None = None)
```

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

**Parámetros:**

name (`str` o `SchedulerType`) : El nombre del scheduler a utilizar.

optimizer (`torch.optim.Optimizer`) : El optimizador que se utilizará durante el entrenamiento.

num_warmup_steps (`int`, *opcional*) : El número de pasos de calentamiento a realizar. No todos los programadores lo requieren (de ahí que el argumento sea opcional); la función generará un error si no se establece y el tipo de programador lo exige.

num_training_steps (`int``, *opcional*) : El número de pasos de entrenamiento a realizar. No todos los programadores lo requieren (de ahí que el argumento sea opcional); la función generará un error si no se establece y el tipo de programador lo exige.

scheduler_specific_kwargs (`dict`, *opcional*) : Parámetros adicionales para programadores como cosine with restarts. Si el tipo de programador y los parámetros del programador no coinciden, la función del programador generará un TypeError.

API unificada para obtener cualquier programador a partir de su nombre.

### get_constant_schedule[[transformers.get_constant_schedule]]

#### transformers.get_constant_schedule[[transformers.get_constant_schedule]]

```python
transformers.get_constant_schedule(optimizer: Optimizer, last_epoch: int = -1)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje constante, utilizando la tasa de aprendizaje establecida en optimizer.

### get_constant_schedule_with_warmup[[transformers.get_constant_schedule_with_warmup]]

#### transformers.get_constant_schedule_with_warmup[[transformers.get_constant_schedule_with_warmup]]

```python
transformers.get_constant_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, last_epoch: int = -1)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje constante precedida por un período de calentamiento durante el cual la tasa de aprendizaje aumenta linealmente entre 0 y la lr inicial establecida en el optimizador.

### get_cosine_schedule_with_warmup[[transformers.get_cosine_schedule_with_warmup]]

#### transformers.get_cosine_schedule_with_warmup[[transformers.get_cosine_schedule_with_warmup]]

```python
transformers.get_cosine_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

num_training_steps (`int`) : El número total de pasos de entrenamiento.

num_cycles (`float`, *opcional*, valor predeterminado 0.5) : El número de ondas en la programación coseno (el valor predeterminado es simplemente disminuir desde el valor máximo hasta 0 siguiendo una media coseno).

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje que disminuye siguiendo los valores de la función coseno entre la lr inicial establecida en el optimizador y 0, después de un período de calentamiento durante el cual aumenta linealmente entre 0 y la lr inicial establecida en el optimizador.

### get_cosine_with_hard_restarts_schedule_with_warmup[[transformers.get_cosine_with_hard_restarts_schedule_with_warmup]]

#### transformers.get_cosine_with_hard_restarts_schedule_with_warmup[[transformers.get_cosine_with_hard_restarts_schedule_with_warmup]]

```python
transformers.get_cosine_with_hard_restarts_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: int = 1, last_epoch: int = -1)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

num_training_steps (`int`) : El número total de pasos de entrenamiento.

num_cycles (`int`, *opcional*, valor predeterminado: 1) : El número de reinicios duros a utilizar.

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje que disminuye siguiendo los valores de la función coseno entre la lr inicial establecida en el optimizador y 0, con varios reinicios duros, después de un período de calentamiento durante el cual aumenta linealmente entre 0 y la lr inicial establecida en el optimizador.

### get_cosine_with_min_lr_schedule_with_warmup[[transformers.get_cosine_with_min_lr_schedule_with_warmup]]

#### transformers.get_cosine_with_min_lr_schedule_with_warmup[[transformers.get_cosine_with_min_lr_schedule_with_warmup]]

```python
transformers.get_cosine_with_min_lr_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1, min_lr: float | None = None, min_lr_rate: float | None = None)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

num_training_steps (`int`) : El número total de pasos de entrenamiento.

num_cycles (`float`, *opcional*, valor predeterminado 0.5) : El número de ondas en la programación coseno (el valor predeterminado es simplemente disminuir desde el valor máximo hasta 0 siguiendo una media coseno).

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

min_lr (`float`, *opcional*) : La tasa de aprendizaje mínima a alcanzar tras el programa coseno.

min_lr_rate (`float`, *opcional*) : La tasa de aprendizaje mínima como proporción de la tasa de aprendizaje inicial. Si se establece, no se debe establecer `min_lr`.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje que disminuye siguiendo los valores de la función coseno entre la lr inicial establecida en el optimizador y min_lr, después de un período de calentamiento durante el cual aumenta linealmente entre 0 y la lr inicial establecida en el optimizador.

### get_cosine_with_min_lr_schedule_with_warmup_lr_rate[[transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate]]

#### transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate[[transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate]]

```python
transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate(optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1, min_lr: float | None = None, min_lr_rate: float | None = None, warmup_lr_rate: float | None = None)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

num_training_steps (`int`) : El número total de pasos de entrenamiento.

num_cycles (`float`, *opcional*, valor predeterminado 0.5) : El número de ondas en la programación coseno (el valor predeterminado es simplemente disminuir desde el valor máximo hasta 0 siguiendo una media coseno).

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

min_lr (`float`, *opcional*) : La tasa de aprendizaje mínima a alcanzar tras el programa coseno.

min_lr_rate (`float`, *opcional*) : La tasa de aprendizaje mínima como proporción de la tasa de aprendizaje inicial. Si se establece, no se debe establecer `min_lr`.

warmup_lr_rate (`float`, *opcional*) : La tasa de aprendizaje mínima como proporción de la tasa de aprendizaje inicial. Si no se establece, `warmup_lr_rate` se tratará como float(1/num_warmup_steps).

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje que disminuye siguiendo los valores de la función coseno entre la lr inicial establecida en el optimizador y min_lr, después de un período de calentamiento durante el cual aumenta linealmente entre 0 y la lr inicial establecida en el optimizador.

### GreedyLR[[transformers.GreedyLR]]

#### transformers.GreedyLR[[transformers.GreedyLR]]

```python
transformers.GreedyLR(optimizer: Optimizer, mode: str = 'min', factor: float = 0.95, patience: int = 10, threshold: float = 1e-06, threshold_mode: str = 'abs', cooldown: int = 0, warmup: int = 0, min_lr: float | list[float] = 0.001, max_lr: float | list[float] = 1.0, eps: float = 1e-08, verbose: bool = False, smooth: bool = False, window_size: int = 50, reset_start: int = 500)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

mode (`str`, *opcional*, valor predeterminado `"min"`) : Uno de 'min' o 'max'. En el modo 'min', la tasa de aprendizaje se reducirá cuando la métrica haya dejado de disminuir; en el modo 'max', cuando haya dejado de aumentar.

factor (`float`, *opcional*, valor predeterminado 0.95) : Factor por el cual se ajustará la tasa de aprendizaje. La tasa de aprendizaje se multiplica por el factor en un meseta y se divide por el factor en caso de mejora. Debe ser < 1.0.

patience (`int`, *opcional*, valor predeterminado 10) : Número de épocas sin mejora tras las cuales se ajustará la tasa de aprendizaje.

threshold (`float`, *opcional*, valor predeterminado 1e-06) : Umbral para medir el nuevo óptimo.

threshold_mode (`str`, *opcional*, valor predeterminado `"abs"`) : Uno de 'rel' o 'abs'.

cooldown (`int`, *opcional*, valor predeterminado 0) : Número de épocas que se debe esperar antes de reanudar la operación normal después de que se haya reducido la tasa de aprendizaje.

warmup (`int`, *opcional*, valor predeterminado 0) : Número de épocas que se espera antes de reanudar la operación normal después de que se haya aumentado la tasa de aprendizaje.

min_lr (`float` o `list[float]`, *opcional*, valor predeterminado 0.001) : Un límite inferior para la tasa de aprendizaje.

max_lr (`float` o `list[float]`, *opcional*, valor predeterminado: 1.0) : Un límite superior para la tasa de aprendizaje.

eps (`float`, *opcional*, valor predeterminado 1e-08) : Decaimiento mínimo aplicado al lr.

verbose (`bool`, *opcional*, valor predeterminado `False`) : Si es True, imprime un mensaje en stdout para cada actualización.

smooth (`bool`, *opcional*, valor predeterminado `False`) : Si es True, aplica suavizado de media de streaming a las métricas.

window_size (`int`, *opcional*, valor predeterminado 50) : El tamaño de la ventana para la media de streaming cuando smooth=True.

reset_start (`int`, *opcional*, valor predeterminado: 500) : Número de pasos para esperar en min_lr antes de restablecer al estado inicial.

Planificador de tasa de aprendizaje adaptativa que responde a las métricas de entrenamiento.

GreedyLR ajusta dinámicamente la tasa de aprendizaje en función del rendimiento del entrenamiento:
- Aumenta la LR cuando las métricas mejoran de forma consistente (divide por un factor)
- Disminuye la LR cuando las métricas se estancan (multiplica por un factor)

Esto difiere de los programadores tradicionales, como el recocido coseno, al responder a las dinámicas reales del entrenamiento en lugar de seguir un programa predeterminado.

Referencia: `GreedyLR: A Novel Adaptive Learning Rate Scheduler <https://arxiv.org/abs/2512.14527>`_

Ejemplo:
```python
>>> optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
>>> scheduler = GreedyLR(optimizer, mode="min", patience=10)
>>> for epoch in range(100):
...     train(...)
...     val_loss = validate(...)
...     scheduler.step(val_loss)
```

#### get_last_lr[[transformers.GreedyLR.get_last_lr]]

```python
get_last_lr()
```

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

Devuelve la última tasa de aprendizaje calculada por el programador actual.

#### load_state_dict[[transformers.GreedyLR.load_state_dict]]

```python
load_state_dict(state_dict: dict[str, Any])
```

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

Cargar el estado desde un diccionario.

#### state_dict[[transformers.GreedyLR.state_dict]]

```python
state_dict()
```

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

Devuelve el estado del programador como un diccionario.

#### paso[[transformers.GreedyLR.step]]

```python
step(metrics: float, epoch: int | None = None)
```

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

**Parámetros:**

metrics (`float`) : El valor de la métrica que se utilizará para tomar decisiones de ajuste de la tasa de aprendizaje.

epoch (`int`, *opcional*) : El número de época actual. Si es None, se utiliza el contador interno.

Realiza un paso del programador en función de las métricas dadas.

### get_greedy_schedule[[transformers.get_greedy_schedule]]

#### transformers.get_greedy_schedule[[transformers.get_greedy_schedule]]

```python
transformers.get_greedy_schedule(optimizer: Optimizer, **kwargs)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

kwargs (`dict`, *opcional*) : Parámetros adicionales que se pasan al programador. Consulte [GreedyLR](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.GreedyLR) para ver los parámetros posibles.

**Devuelve:**

[GreedyLR](/docs/transformers/v5.23.0/es/main_classes/optimizer_schedules#transformers.GreedyLR) con el programa adecuado.

Cree un programador de tasa de aprendizaje adaptativa que ajuste la LR en función de las métricas de entrenamiento.

### get_linear_schedule_with_warmup[[transformers.get_linear_schedule_with_warmup]]

#### transformers.get_linear_schedule_with_warmup[[transformers.get_linear_schedule_with_warmup]]

```python
transformers.get_linear_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, last_epoch = -1)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

num_training_steps (`int`) : El número total de pasos de entrenamiento.

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje que disminuye linealmente desde la lr inicial establecida en el optimizador hasta 0, después de un período de calentamiento durante el cual aumenta linealmente desde 0 hasta la lr inicial establecida en el optimizador.

### get_polynomial_decay_schedule_with_warmup[[transformers.get_polynomial_decay_schedule_with_warmup]]

#### transformers.get_polynomial_decay_schedule_with_warmup[[transformers.get_polynomial_decay_schedule_with_warmup]]

```python
transformers.get_polynomial_decay_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, lr_end = 1e-07, power = 1.0, last_epoch = -1)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

num_training_steps (`int`) : El número total de pasos de entrenamiento.

lr_end (`float`, *opcional*, valor predeterminado 1e-7) : La LR final.

power (`float`, *opcional*, valor predeterminado 1.0) : Factor de potencia.

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje que disminuye mediante un decaimiento polinómico desde la lr inicial establecida en el optimizador hasta la lr final definida por *lr_end*, tras un período de calentamiento durante el cual aumenta linealmente desde 0 hasta la lr inicial establecida en el optimizador.

Nota: *power* tiene un valor predeterminado de 1.0, tal como en la implementación de fairseq, que a su vez se basa en la implementación original de BERT en https://github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/optimization.py#L37

### get_inverse_sqrt_schedule[[transformers.get_inverse_sqrt_schedule]]

#### transformers.get_inverse_sqrt_schedule[[transformers.get_inverse_sqrt_schedule]]

```python
transformers.get_inverse_sqrt_schedule(optimizer: Optimizer, num_warmup_steps: int, timescale: int | None = None, last_epoch: int = -1)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

timescale (`int`, *opcional*, valor predeterminado `num_warmup_steps`) : Escala de tiempo.

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Cree un programa con una tasa de aprendizaje inversa de la raíz cuadrada, a partir de la lr inicial establecida en el optimizador, después de un período de calentamiento que aumenta la lr linealmente desde 0 hasta la lr inicial establecida en el optimizador.

### get_reduce_on_plateau_schedule[[transformers.get_reduce_on_plateau_schedule]]

#### transformers.get_reduce_on_plateau_schedule[[transformers.get_reduce_on_plateau_schedule]]

```python
transformers.get_reduce_on_plateau_schedule(optimizer: Optimizer, **kwargs)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

kwargs (`dict`, *opcional*) : Parámetros adicionales que se pasarán al programador. Consulte `torch.optim.lr_scheduler.ReduceLROnPlateau` para ver los parámetros posibles.

**Devuelve:**

`torch.optim.lr_scheduler.ReduceLROnPlateau` con el programa adecuado.

Crea un programa con una tasa de aprendizaje constante que disminuye cuando una métrica deja de mejorar.

### get_wsd_schedule[[transformers.get_wsd_schedule]]

#### transformers.get_wsd_schedule[[transformers.get_wsd_schedule]]

```python
transformers.get_wsd_schedule(optimizer: Optimizer, num_warmup_steps: int, num_decay_steps: int, num_training_steps: int | None = None, num_stable_steps: int | None = None, warmup_type: str = 'linear', decay_type: str = 'cosine', min_lr_ratio: float = 0, num_cycles: float = 0.5, last_epoch: int = -1)
```

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

**Parámetros:**

optimizer (`~torch.optim.Optimizer`) : El optimizador para el que se programará la tasa de aprendizaje.

num_warmup_steps (`int`) : El número de pasos para la fase de calentamiento.

num_decay_steps (`int`) : El número de pasos para la fase de decaimiento.

num_training_steps (`int`, *opcional*) : El número total de pasos de entrenamiento. Esta es la suma de los pasos de calentamiento, estables y de decaimiento. Si no se proporciona `num_stable_steps`, la fase estable será `num_training_steps - num_warmup_steps - num_decay_steps`.

num_stable_steps (`int`, *opcional*) : El número de pasos para la fase estable. Asegúrese de que `num_warmup_steps + num_stable_steps + num_decay_steps` sea igual a `num_training_steps`; de lo contrario, los demás pasos se ajustarán a la tasa de aprendizaje mínima.

warmup_type (`str`, *opcional*, valor predeterminado "linear") : El tipo de warmup a utilizar. Puede ser 'linear', 'cosine' o '1-sqrt'.

decay_type (`str`, *opcional*, valor predeterminado "cosine") : El tipo de decaimiento a utilizar. Puede ser 'linear', 'cosine' o '1-sqrt'.

min_lr_ratio (`float`, *opcional*, valor predeterminado 0) : La tasa de aprendizaje mínima como proporción de la tasa de aprendizaje inicial.

num_cycles (`float`, *opcional*, valor predeterminado 0.5) : El número de ondas en la programación coseno (el valor predeterminado es simplemente disminuir desde el valor máximo hasta 0 siguiendo una media coseno).

last_epoch (`int`, *opcional*, valor predeterminado: -1) : El índice de la última época al reanudar el entrenamiento.

**Devuelve:**

`torch.optim.lr_scheduler.LambdaLR` con el programa adecuado.

Crea un programa con una tasa de aprendizaje que tenga tres etapas:
1. warmup: aumenta desde min_lr_ratio veces la tasa de aprendizaje inicial hasta la tasa de aprendizaje inicial siguiendo un warmup_type.
2. stable: tasa de aprendizaje constante.
3. decay: disminución desde la tasa de aprendizaje inicial hasta min_lr_ratio veces la tasa de aprendizaje inicial siguiendo un decay_type.

