# Оптимизация

Модуль `.optimization` предоставляет:

- оптимизатор с фиксированным weight decay, который можно использовать для дообучения моделей, и
- несколько расписаний в виде объектов расписаний, наследующих от `_LRSchedule`:
- класс накопления градиентов для накопления градиентов нескольких батчей

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L1057)

**Параметры:**

params (`Iterable[nn.parameter.Parameter]`) : итерируемый объект параметров для оптимизации или словари, определяющие группы параметров.

lr (`float`, *необязательный*) : Внешняя скорость обучения.

eps (`tuple[float, float]`, *необязательный*, по умолчанию `(1e-30, 0.001)`) : Константы регуляризации для квадратного градиента и масштаба параметров соответственно

clip_threshold (`float`, *optional*, по умолчанию 1.0) : Порог среднеквадратичного значения окончательного обновления градиента

decay_rate (`float`, *необязательный*, по умолчанию -0.8) : Коэффициент, используемый для вычисления скользящих средних квадратов

beta1 (`float`, *необязательный*) : Коэффициент, используемый для вычисления скользящих средних градиента

weight_decay (`float`, *необязательный*, по умолчанию 0.0) : Весовое затухание (штраф L2)

scale_parameter (`bool`, *необязательный*, по умолчанию `True`) : Если True, скорость обучения масштабируется по среднеквадратичному значению

relative_step (`bool`, *необязательный*, по умолчанию `True`) : Если True, вычисляется зависящая от времени скорость обучения вместо внешней скорости обучения

warmup_init (`bool`, *необязательный*, по умолчанию `False`) : Вычисление зависимости скорости обучения от времени зависит от того, используется ли инициализация с разгоном

Реализация AdaFactor для PyTorch может использоваться как прямая замена для Adam в исходном коде fairseq: https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py

Статья: *Adafactor: Adaptive Learning Rates with Sublinear Memory Cost* https://huggingface.co/papers/1804.04235 Обратите внимание, что этот оптимизатор внутренним образом корректирует скорость обучения в зависимости от параметров `scale_parameter`, `relative_step` и `warmup_init`. Чтобы использовать ручное (внешнее) расписание скорости обучения, установите `scale_parameter=False` и `relative_step=False`.

Эта реализация поддерживает значения с низкой точностью (FP16, bfloat), однако мы не проводили её тщательное тестирование.

Рекомендуемые настройки дообучения T5 (https://discuss.huggingface.co/t/t5-finetuning-tips/684/3):

- Не рекомендуется выполнять обучение без LR warmup или clip_threshold.

  - использование запланированного прогрева LR до фиксированного LR
  - используйте clip_threshold=1.0 (https://huggingface.co/papers/1804.04235)
- Отключить относительные обновления
- Используйте scale_parameter=False
- Дополнительные операции оптимизатора, такие как обрезка градиентов, не следует использовать вместе с Adafactor

Пример:

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

Другие сообщали, что следующая комбинация хорошо работает:

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

При использовании `lr=None` вместе с [Trainer](/docs/transformers/main/ru/main_classes/trainer#transformers.Trainer), скорее всего, вам потребуется использовать `AdafactorSchedule`

scheduler следующим образом:

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

Использование:

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

#### шаг[[transformers.Adafactor.step]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L1202)

**Параметры:**

closure (callable, optional) : замыкание, которое повторно вычисляет модель и возвращает потерю.

Выполняет один шаг оптимизации

## Расписания

### SchedulerType[[transformers.SchedulerType]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/trainer_utils.py#L561)

Имена планировщиков для параметра `lr_scheduler_type` в [TrainingArguments](/docs/transformers/main/ru/main_classes/trainer#transformers.TrainingArguments). По умолчанию используется "linear". Внутренне это вызывает планировщик `get_linear_schedule_with_warmup` из [Trainer](/docs/transformers/main/ru/main_classes/trainer#transformers.Trainer). Типы планировщиков:
- "linear" = [get_linear_schedule_with_warmup()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_linear_schedule_with_warmup)
- "cosine" = [get_cosine_schedule_with_warmup()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_cosine_schedule_with_warmup)
- "cosine_with_restarts" = [get_cosine_with_hard_restarts_schedule_with_warmup()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_cosine_with_hard_restarts_schedule_with_warmup)
- "polynomial" = [get_polynomial_decay_schedule_with_warmup()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_polynomial_decay_schedule_with_warmup)
- "constant" =  [get_constant_schedule()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_constant_schedule)
- "constant_with_warmup" = [get_constant_schedule_with_warmup()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_constant_schedule_with_warmup)
- "inverse_sqrt" = [get_inverse_sqrt_schedule()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_inverse_sqrt_schedule)
- "reduce_lr_on_plateau" = [get_reduce_on_plateau_schedule()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_reduce_on_plateau_schedule)
- "cosine_with_min_lr" = [get_cosine_with_min_lr_schedule_with_warmup()](/docs/transformers/main/ru/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/main/ru/main_classes/optimizer_schedules#transformers.get_cosine_with_min_lr_schedule_with_warmup_lr_rate)
- "warmup_stable_decay" = [get_wsd_schedule()](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.get_wsd_schedule)
- "greedy" = [get_greedy_schedule()](/docs/transformers/main/ru/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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L960)

**Параметры:**

name (`str` или `SchedulerType`) : имя планировщика, который следует использовать.

optimizer (`torch.optim.Optimizer`) : оптимизатор, который будет использоваться во время обучения.

num_warmup_steps (`int`, *optional*) : Количество шагов разгона. Не все планировщики требуют этот параметр (поэтому аргумент является необязательным); функция вызовет ошибку, если параметр не задан, а тип планировщика его требует.

num_training_steps (`int``, *необязательный*) : Количество шагов обучения. Не все планировщики требуют этот параметр (поэтому аргумент необязательный); если он не задан, а тип планировщика его требует, функция вызовет ошибку.

scheduler_specific_kwargs (`dict`, *необязательный*) : Дополнительные параметры для планировщиков, например, косинусного с перезапусками. Несоответствие типа планировщика и его параметров приведёт к тому, что функция планировщика вызовет TypeError.

Единый API для получения любого планировщика по его имени.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L39)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с постоянной скоростью обучения, используя скорость обучения, заданную в оптимизаторе.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L80)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с постоянной скоростью обучения, предшествующее которому период прогрева, в течение которого скорость обучения линейно возрастает от 0 до начального значения lr, заданного в оптимизаторе.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L143)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

num_training_steps (`int`) : Общее количество шагов обучения.

num_cycles (`float`, *optional*, по умолчанию 0.5) : Количество волн в косинусной расписании (по умолчанию значение просто уменьшается от максимального до 0 по половине косинусы).

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с коэффициентом обучения, который после периода прогрева, в течение которого он линейно возрастает от 0 до начального значения lr, заданного в оптимизаторе, уменьшается по значениям косинусной функции от начального lr, заданного в оптимизаторе, до 0.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L188)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

num_training_steps (`int`) : Общее количество шагов обучения.

num_cycles (`int`, *optional*, по умолчанию 1) : Количество жёстких перезапусков.

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с коэффициентом обучения, который уменьшается по значениям косинусоидальной функции от начального значения lr, заданного в оптимизаторе, до 0, с несколькими жёсткими перезапусками, после периода прогрева, в течение которого он линейно возрастает от 0 до начального значения lr, заданного в оптимизаторе.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L337)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

num_training_steps (`int`) : Общее количество шагов обучения.

num_cycles (`float`, *optional*, по умолчанию 0.5) : Количество волн в косинусной расписании (по умолчанию значение просто уменьшается от максимального до 0 по половине косинусы).

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

min_lr (`float`, *необязательный*) : Минимальная скорость обучения, к которой нужно прийти после косинусной расписки.

min_lr_rate (`float`, *необязательный*) : Минимальная скорость обучения в виде отношения к начальной скорости обучения. Если задано, `min_lr` не должно быть установлено.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с коэффициентом обучения, который после периода разгона, в течение которого он линейно возрастает от 0 до начального значения lr, заданного в оптимизаторе, уменьшается по значениям косинусоидальной функции от начального lr, заданного в оптимизаторе, до min_lr.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L414)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

num_training_steps (`int`) : Общее количество шагов обучения.

num_cycles (`float`, *optional*, по умолчанию 0.5) : Количество волн в косинусной расписании (по умолчанию значение просто уменьшается от максимального до 0 по половине косинусы).

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

min_lr (`float`, *необязательный*) : Минимальная скорость обучения, к которой нужно прийти после косинусной расписки.

min_lr_rate (`float`, *необязательный*) : Минимальная скорость обучения в виде отношения к начальной скорости обучения. Если задано, `min_lr` не должно быть установлено.

warmup_lr_rate (`float`, *необязательный*) : Минимальная скорость обучения в виде отношения к начальной скорости обучения. Если не задано, `warmup_lr_rate` будет рассматриваться как float(1/num_warmup_steps).

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с коэффициентом обучения, который после периода разгона, в течение которого он линейно возрастает от 0 до начального значения lr, заданного в оптимизаторе, уменьшается по значениям косинусоидальной функции от начального lr, заданного в оптимизаторе, до min_lr.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L621)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

mode (`str`, *необязательный*, по умолчанию `"min"`) : одно из значений 'min' или 'max'. В режиме 'min' LR снижается, когда метрика перестает уменьшаться; в режиме 'max' — когда перестает увеличиваться.

factor (`float`, *optional*, по умолчанию 0.95) : Коэффициент, на который корректируется скорость обучения. На плато LR умножается на factor, а при улучшении — делится на factor. Должно быть < 1.0.

patience (`int`, *optional*, по умолчанию 10) : Количество эпох без улучшения, после которых будет скорректирована скорость обучения.

threshold (`float`, *необязательный*, по умолчанию 1e-06) : Порог для измерения нового оптимума.

threshold_mode (`str`, *необязательный*, по умолчанию `"abs"`) : одно из значений 'rel' или 'abs'.

cooldown (`int`, *optional*, по умолчанию 0) : Количество эпох, в течение которых нужно подождать, прежде чем возобновить нормальную работу после снижения LR.

warmup (`int`, *необязательный*, по умолчанию 0) : Количество эпох, в течение которых нужно подождать, прежде чем возобновить обычную работу после увеличения LR.

min_lr (`float` или `list[float]`, *необязательный*, по умолчанию 0.001) : Нижняя граница для скорости обучения.

max_lr (`float` или `list[float]`, *необязательный*, по умолчанию 1.0) : Верхняя граница для скорости обучения.

eps (`float`, *optional*, по умолчанию 1e-08) : Минимальное затухание, применяемое к lr.

verbose (`bool`, *необязательный*, по умолчанию `False`) : Если True, выводит сообщение в stdout при каждом обновлении.

smooth (`bool`, *необязательный*, по умолчанию `False`) : Если True, применяется сглаживание скользящего среднего к метрикам.

window_size (`int`, *optional*, по умолчанию 50) : Размер окна для скользящего среднего при smooth=True.

reset_start (`int`, *optional*, по умолчанию 500) : Количество шагов ожидания на min_lr перед сбросом в начальное состояние.

Адаптивный планировщик скорости обучения, реагирующий на метрики обучения.

GreedyLR динамически корректирует скорость обучения на основе результатов обучения:
- Увеличивает LR, если метрики последовательно улучшаются (делит на коэффициент)
- Уменьшает LR при стабилизации метрик (умножает на коэффициент)

Это отличается от традиционных планировщиков, таких как cosine annealing, тем, что реагирует на фактическую динамику обучения, а не следует заранее заданному расписанию.

Ссылка: `GreedyLR: A Novel Adaptive Learning Rate Scheduler <https://arxiv.org/abs/2512.14527>`_

Пример:
```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()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L855)

Возвращает последнее вычисленное значение коэффициента обучения текущим планировщиком.

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L892)

Загрузить состояние из словаря.

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

```python
state_dict()
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L859)

Возвращает состояние планировщика в виде словаря.

#### шаг[[transformers.GreedyLR.step]]

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L749)

**Параметры:**

metrics (`float`) : Значение метрики, используемое для принятия решений о корректировке LR.

epoch (`int`, *optional*) : Текущий номер эпохи. Если None, используется внутренний счётчик.

Выполнить шаг планировщика на основе переданных метрик.

### get_greedy_schedule[[transformers.get_greedy_schedule]]

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

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L928)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

kwargs (`dict`, *необязательный*) : Дополнительные параметры, передаваемые планировщику. См. [GreedyLR](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.GreedyLR) для списка возможных параметров.

**Возвращаемое значение:**

[GreedyLR](/docs/transformers/main/ru/main_classes/optimizer_schedules#transformers.GreedyLR) с подходящим расписанием.

Создайте адаптивный планировщик скорости обучения, который корректирует LR на основе метрик обучения.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L107)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

num_training_steps (`int`) : Общее количество шагов обучения.

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с коэффициентом обучения, который после периода прогрева, в течение которого он линейно возрастает от 0 до начального lr, заданного в оптимизаторе, линейно уменьшается до 0.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L242)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

num_training_steps (`int`) : Общее количество шагов обучения.

lr_end (`float`, *необязательный*, по умолчанию 1e-7) : Конечное значение LR.

power (`float`, *необязательный*, по умолчанию 1.0) : Коэффициент степени.

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с коэффициентом обучения, который уменьшается по полиномиальному закону затухания от начального значения lr, заданного в оптимизаторе, до конечного значения lr, определённого параметром *lr_end*, после периода прогрева, в течение которого он линейно возрастает от 0 до начального значения lr, заданного в оптимизаторе.

Примечание: *power* по умолчанию равно 1.0, как в реализации fairseq, которая, в свою очередь, основана на исходной реализации BERT по адресу 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)
```

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L296)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

timescale (`int`, *необязательный*, по умолчанию `num_warmup_steps`) : Масштаб времени.

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с обратной квадратно-корневой функцией для скорости обучения, начиная с начального значения lr, заданного в оптимизаторе, после периода прогрева, в течение которого lr линейно возрастает от 0 до начального значения lr, заданного в оптимизаторе.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L56)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

kwargs (`dict`, *необязательный*) : Дополнительные параметры, передаваемые планировщику. См. `torch.optim.lr_scheduler.ReduceLROnPlateau` для списка возможных параметров.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.ReduceLROnPlateau` с подходящим расписанием.

Создайте расписание с постоянной скоростью обучения, которая снижается, когда метрика перестала улучшаться.

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

[Источник](https://github.com/huggingface/transformers/blob/main/src/transformers/optimization.py#L508)

**Параметры:**

optimizer (`~torch.optim.Optimizer`) : оптимизатор, для которого планируется изменение скорости обучения.

num_warmup_steps (`int`) : Количество шагов для фазы прогрева.

num_decay_steps (`int`) : Количество шагов для фазы затухания.

num_training_steps (`int`, *необязательный*) : Общее количество шагов обучения. Это сумма шагов разгона, стабильной фазы и фазы затухания. Если `num_stable_steps` не задан, длительность стабильной фазы будет равна `num_training_steps - num_warmup_steps - num_decay_steps`.

num_stable_steps (`int`, *optional*) : Количество шагов для стабильной фазы. Убедитесь, что `num_warmup_steps + num_stable_steps + num_decay_steps` равно `num_training_steps`, в противном случае для остальных шагов будет использоваться минимальная скорость обучения.

warmup_type (`str`, *необязательный*, по умолчанию "linear") : Тип разгона. Допустимые значения: 'linear', 'cosine' или '1-sqrt'.

decay_type (`str`, *необязательный*, по умолчанию "cosine") : Тип затухания. Допустимые значения: 'linear', 'cosine' или '1-sqrt'.

min_lr_ratio (`float`, *необязательный*, по умолчанию 0) : Минимальная скорость обучения в виде отношения к начальной скорости обучения.

num_cycles (`float`, *optional*, по умолчанию 0.5) : Количество волн в косинусной расписании (по умолчанию значение просто уменьшается от максимального до 0 по половине косинусы).

last_epoch (`int`, *необязательный*, по умолчанию -1) : Индекс последней эпохи при возобновлении обучения.

**Возвращаемое значение:**

`torch.optim.lr_scheduler.LambdaLR` с подходящим расписанием.

Создайте расписание с коэффициентом обучения, имеющим три этапа:
1. warmup: увеличение с min_lr_ratio от начальной скорости обучения до начальной скорости обучения в соответствии с warmup_type.
2. stable: постоянная скорость обучения.
3. decay: снижение от начальной скорости обучения до значения, равного min_lr_ratio от начальной скорости обучения, в соответствии с decay_type.