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

На этой странице представлена справочная документация по API оптимизаторов, входящих в состав `timm`, а также обзор того, как они выбираются и настраиваются через фабрику оптимизаторов.

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

Оптимизаторы создаются по имени с помощью [`create_optimizer_v2`](#timm.optim.create_optimizer_v2). Получив модель, фабрика формирует группы параметров (исключения для weight decay, необязательное затухание скорости обучения по слоям), прежде чем создать оптимизатор. Специфические для оптимизатора аргументы передаются в виде именованных аргументов.

```python
import timm
from timm.optim import create_optimizer_v2, list_optimizers

model = timm.create_model('vit_base_patch16_224')

# AdamW. 1D params (biases, norm scales) and params in model.no_weight_decay() are excluded from weight decay.
optimizer = create_optimizer_v2(model, opt='adamw', lr=1e-3, weight_decay=0.05)

# Layer-wise learning rate decay (fine-tuning), per-layer lr scales from the model's group_matcher().
optimizer = create_optimizer_v2(model, opt='adamw', lr=1e-3, weight_decay=0.05, layer_decay=0.75)

# Optimizer specific arguments are passed through.
optimizer = create_optimizer_v2(model, opt='lamb', lr=5e-3, weight_decay=0.02, trust_clip=True)

# A list of params or param groups can be passed instead of a model, weight decay grouping is then up to the caller.
optimizer = create_optimizer_v2(model.parameters(), opt='sgd', lr=0.1, momentum=0.9)

# All registered names, optionally with a description.
print(list_optimizers(with_description=True))
```

Скрипт обучения (`train.py`) предоставляет тот же функционал через эти флаги:

- **`--opt`** выбирает оптимизатор.
- **`--lr`** задает скорость обучения.
- **`--weight-decay`** задаёт весовое затухание.
- **`--momentum`** задаёт импульс.
- **`--opt-eps`** задает значение эпсилон (`eps`).
- **`--opt-betas`** задаёт коэффициенты бета (`betas`).
- **`--layer-decay`** задаёт послойное затухание скорости обучения.
- **`--opt-kwargs key=value ...`** передаёт любые другие аргументы оптимизатора.

### Соглашения о наименовании

Зарегистрированные имена пишутся в нижнем регистре и состоят из базового имени оптимизатора и модификаторов:

| Изменить | Значение | Примеры |
|---|---|---|
| префикс `c` | Осторожный вариант: обновление маскируется там, где его знак не совпадает с градиентом ([Cautious Optimizers](https://arxiv.org/abs/2411.16085)) | `cadamw`, `clion`, `cmars`, `cadopt` |
| суффикс `w` | Развязанное (в стиле AdamW) затухание весов для оптимизаторов, по умолчанию использующих связанное L2-затухание | `sgdw`, `lambw`, `adoptw`, `novogradw`, `rmsproptfw` |
| суффикс `c` | Скорректированное затухание весов: затухание масштабируется множителем `lr² / max_lr` вместо `lr` ([Почему градиенты резко возрастают в конце обучения](https://arxiv.org/abs/2506.02285)) | `adamc`, `nadamc`, `sgdc`, `lionc`, `adoptc`, `kronc` |
| Префикс `n` | Импульс Нестерова (семейства SGD, LARS и Muon) | `nesterov`, `nlars`, `nmuon`, `nadamuon` |
| префикс `lookahead_` | Оберните оптимизатор в [`Lookahead`](#timm.optim.lookahead.Lookahead) | `lookahead_adamw` |
| префикс `fused` | Слиянная реализация NVIDIA Apex (требуется `apex`) | `fusedadamw`, `fusedlamb` |
| префикс `bnb` | реализация bitsandbytes, суффикс `8bit` для состояния 8 бит (требуется `bitsandbytes`) | `bnbadamw`, `bnbadamw8bit` |

Некоторые названия появились раньше принятых соглашений: `lambc` и `larc` — это LAMB / LARS с обрезкой доверительного отношения (исправленный вариант LAMB с затуханием — `lambcd`), `momentum` — это SGD с классическим импульсом, а `sgd` — SGD с импульсом Нестерова. Реализации `legacy` в таблице ниже предшествовали их включению в PyTorch.

### Семейства оптимизаторов

| Имена | Реализация | Примечания |
|---|---|---|
| `adamw`, `adam`, `nadam`, `radam`, `radamw`, `adamax`, `adadelta`, `adagrad`, `rmsprop`, `sgd`, `momentum`, `nesterov` | `torch.optim` | |
| `adamwlegacy`, `adamc`, `cadamw`, `cadamc` | [`AdamWLegacy`](#timm.optim.adamw.AdamWLegacy) | AdamW с осторожностью, исправленное затухание, обрезание обновлений, `capturable` |
| `nadamw`, `nadamc`, `cnadamw`, `cnadamc` | [`NAdamW`](#timm.optim.nadamw.NAdamW) | AdamW с импульсом Нестерова (форма алгоритмической эффективности MLCommons) |
| `adopt`, `adoptw`, `adoptc`, `cadopt`, `cadoptw`, `cadoptc` | [`Adopt`](#timm.optim.adopt.Adopt) | Вариант Adam, сходящийся для любого β2 |
| `adan`, `adanw`, `cadan`, `cadanw` | [`Adan`](#timm.optim.adan.Adan) | Адаптивный импульс Нестерова |
| `adabelief`, `radabelief` | [`AdaBelief`](#timm.optim.adabelief.AdaBelief) | `radabelief` добавляет коррекцию в стиле RAdam |
| `adafactor`, `cadafactor` | [`Adafactor`](#timm.optim.adafactor.Adafactor) | fairseq Adafactor, относительный размер шага, когда `lr=None` |
| `adafactorbv`, `adafactorbvc`, `cadafactorbv`, `cadafactorbvc` | [`AdafactorBigVision`](#timm.optim.adafactor_bv.AdafactorBigVision) | Big Vision Adafactor, факторизованные моменты второго порядка, импульс с низкой точностью, обрезание обновлений |
| `adamp`, `cadamp`, `sgdp`, `csgdp` | [`AdamP`](#timm.optim.adamp.AdamP), [`SGDP`](#timm.optim.sgdp.SGDP) | Проекция обновления для масштабно-инвариантных весов |
| `adahessian` | [`Adahessian`](#timm.optim.adahessian.Adahessian) | Второго порядка, требует замыкание (`is_second_order`) |
| `kron`, `kronw`, `kronc` | [`Kron`](#timm.optim.kron.Kron) | PSGD с преобразователем, факторизованным по Кронекеру |
| `lamb`, `lambc`, `lambw`, `lambcw`, `lambcd`, `clamb`, `clambw` | [`Lamb`](#timm.optim.lamb.Lamb) | Послойные адаптивные моменты, варианты `trust_clip` (`lambc`, `lambcw`) |
| `laprop`, `lapropc`, `claprop` | [`LaProp`](#timm.optim.laprop.LaProp) | Разделение импульса и адаптивности |
| `lars`, `larc`, `nlars`, `nlarc` | [`Lars`](#timm.optim.lars.Lars) | Масштабирование адаптивной скорости по слоям, варианты `trust_clip` (`larc`, `nlarc`) |
| `lion`, `lionc`, `clion`, `clionc` | [`Lion`](#timm.optim.lion.Lion) | Эволюционированный знак импульса |
| `madgrad`, `madgradw` | [`MADGRAD`](#timm.optim.madgrad.MADGRAD) | Двойное усреднение на основе импульса |
| `mars`, `cmars` | [`Mars`](#timm.optim.mars.Mars) | Снижение дисперсии, обновление в стиле AdamW или Lion |
| `muon`, `nmuon`, `adamuon`, `nadamuon` | [`Muon`](#timm.optim.muon.Muon) | Ортогонализированный импульс Ньютона-Шульца для весов размерности 2D и выше, резервный режим AdamW / NAdamW для параметров размерности 1D |
| `novograd`, `novogradw`, `novogradc` | [`NvNovoGrad`](#timm.optim.nvnovograd.NvNovoGrad) | Нормализованные моменты по слоям |
| `rmsproptf`, `rmsproptfw`, `rmsproptfc`, `crmsproptf` | [`RMSpropTF`](#timm.optim.rmsprop_tf.RMSpropTF) | Порядок операций в TensorFlow и обработка eps, lr, встроенная в буфер импульса |
| `sgdw`, `nesterovw`, `sgdc`, `csgdw`, `csgdc` | [`SGDW`](#timm.optim.sgdw.SGDW) | SGD с отделённым затуханием весов |
| `nadamlegacy`, `radamlegacy` | [`NAdamLegacy`](#timm.optim.nadam.NAdamLegacy), [`RAdamLegacy`](#timm.optim.radam.RAdamLegacy) | Референсные реализации, заменённые на `torch.optim` |
| `fused*`, `bnb*` | NVIDIA Apex, bitsandbytes | Регистрируется при установке пакета |

### Часто используемые параметры

Большинство оптимизаторов `timm` поддерживают набор параметров, выходящий за рамки стандартных `lr`, `weight_decay`, `betas` и `eps`. Какие именно оптимизаторы принимают какие параметры, можно узнать по сигнатурам классов ниже; фабрика вызывает исключение при передаче неподдерживаемых аргументов.

- **`caution`** применяет маску осторожного обновления, что эквивалентно именам реестра с префиксом `c`.
- **`corrected_weight_decay`** масштабирует развязанное затухание весов множителем `lr² / max_lr` вместо `lr` (имена с суффиксом `c`), благодаря чему эффективное затухание следует расписанию скорости обучения. `max_lr` — это скорость обучения, с которой был создан оптимизатор; создавайте его с пиковой скоростью обучения из расписания (как это делает `train.py`). Значение хранится в каждой группе параметров (`max_lr_snapshot`) и сохраняется/восстанавливается вместе с состоянием оптимизатора.
- **`decoupled_decay`** (или `decoupled`) переключает оптимизаторы, по умолчанию использующие связанное L2-затухание, на затухание в стиле AdamW (имена с суффиксом `w`).
- **`foreach`** выбирает реализацию для нескольких тензоров. По умолчанию (`None`) она используется на CUDA и других устройствах с ядрами foreach, что соответствует `torch.optim`, если конфигурация не поддерживает её (тензор `lr` без `capturable` или `caution` в версии PyTorch без требуемой перегрузки `_foreach_maximum_`). Шаг с несколькими тензорами выполняется в блоках параметров, размер которых подобран так, чтобы рабочий набор каждого блока оставался в кэше L2 GPU, что быстрее, чем пропускать каждый параметр через память один раз на операцию для больших моделей. Размер блока вычисляется на основе размера кэша L2 устройства (PyTorch >= 2.5), а разбиение на блоки пропускается на устройствах, где результирующий блок был бы меньше 4M элементов. `TIMM_FOREACH_CHUNK_SIZE=<elements>` переопределяет размер блока, `0` отключает разбиение на блоки.
- **`capturable`** (AdamWLegacy, NAdamW, Adopt, Muon) хранит счётчик шагов на устройстве, чтобы шаг можно было захватить в граф CUDA. Все оптимизаторы принимают `lr`, заданный как тензор нулевого измерения, который обновляется на месте расписанием, для использования с `torch.compile` и графами CUDA.
- **`clipping_threshold`** (AdamWLegacy, NAdamW, AdafactorBigVision) обрезает обновление по его RMS: `update / max(1, rms / threshold)`, где `rms` — это RMS нормализованного вторым моментом градиента, для каждого тензора ([StableAdamW](https://arxiv.org/abs/2304.13013), Adafactor). Значение `1.0`, как в статьях. Как и в Adafactor, (развязанное) затухание веса не обрезается, однако StableAdamW также масштабирует затухание обрезанной скоростью обучения.
- **`maximize`** максимизирует целевую функцию, а не минимизирует её.

Поддержка параметров с низкой точностью (`bfloat16`, `float16`) обеспечивается на всех этапах:

- **AdaBelief, RAdamLegacy and Adafactor** хранят своё состояние в `float32` для параметров с низкой точностью.
- **AdafactorBigVision** хранит свой импульс в пониженной точности (`momentum_dtype`).
- **Kron** имеет отдельные параметры `mu_dtype` / `precond_dtype`.

Эти state dtypes сохраняются при вызове `load_state_dict` (стандартный загрузчик PyTorch приводит state к dtype параметра). Функции шага избегают синхронизации с хостом (ветвления Python, зависящие от данных, на тензорах устройства), исключение составляет проверка проекции в AdamP / SGDP.

### Группы параметров

При передаче модели `create_optimizer_v2` группирует параметры с помощью [`param_groups_weight_decay`](#timm.optim.param_groups_weight_decay) (без затухания для 1D-параметров и набора `no_weight_decay()` модели) или, при установленном `layer_decay`, с помощью [`param_groups_layer_decay`](#timm.optim.param_groups_layer_decay), который назначает масштаб коэффициента обучения `layer_decay ** (num_layers - layer_id)` для каждого слоя, используя `group_matcher()` модели. Модели без `group_matcher()` используют [`auto_group_layers`](#timm.optim.auto_group_layers), для которого требуется `pretrained_cfg['classifier']` модели для выделения головы. Для гибридных оптимизаторов (Muon) аргументы `fallback_list` и `fallback_no_weight_decay` направляют параметры в запасной (AdamW) оптимизатор.

## API

### Фабричные функции[[timm.optim.create_optimizer_v2]]

#### timm.optim.create_optimizer_v2[[timm.optim.create_optimizer_v2]]

```python
timm.optim.create_optimizer_v2(model_or_params: typing.Union[torch.nn.Module, torch.optim.optimizer.ParamsT], opt: str = 'sgd', lr: typing.Optional[float] = None, weight_decay: float = 0.0, momentum: float = 0.9, foreach: typing.Optional[bool] = None, filter_bias_and_bn: bool = True, fallback_list: typing.Collection[str] = (), fallback_no_weight_decay: bool = False, layer_decay: typing.Optional[float] = None, layer_decay_min_scale: float = 0.0, layer_decay_no_opt_scale: typing.Optional[float] = None, param_group_fn: typing.Optional[typing.Callable[[torch.nn.Module], torch.optim.optimizer.ParamsT]] = None, **kwargs: typing.Any)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_optim_factory.py#L1242)

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

model_or_params : модель PyTorch или итерируемый объект параметров/групп параметров. Если предоставлена модель, параметры будут автоматически извлечены и сгруппированы на основе других аргументов.

opt : Имя оптимизатора для создания (например, 'adam', 'adamw', 'sgd'). Используйте list_optimizers(), чтобы просмотреть доступные варианты.

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

weight_decay : Коэффициент затухания весов. Будет использоваться для создания групп параметров, если model_or_params является моделью.

momentum : Коэффициент импульса для оптимизаторов, которые его поддерживают. Используется только в том случае, если выбранный оптимизатор принимает параметр momentum.

foreach : Включить/отключить реализацию foreach (для нескольких тензоров), если она доступна. Если значение равно None, будут использоваться значения по умолчанию, специфичные для данного оптимизатора.

filter_bias_and_bn : Если True, к параметрам bias и norm-слоёв (все 1d-параметры) не будет применяться weight decay. Используется только тогда, когда model_or_params является моделью и weight_decay > 0.

fallback_list : Коллекция шаблонов имён параметров для использования резервного оптимизатора в гибридных оптимизаторах (например, AdamW для Muon). Поддерживает сопоставление с использованием подстановочных знаков.

fallback_no_weight_decay : Если True, параметры из списка no_weight_decay() модели будут использовать резервный оптимизатор для гибридных оптимизаторов (например, AdamW для Muon).

layer_decay : Необязательный коэффициент затухания скорости обучения по слоям. Если указан, скорости обучения масштабируются по формуле layer_decay^(max_depth - layer_depth). Используется только в том случае, если model_or_params является моделью.

param_group_fn : Необязательная функция для создания пользовательских групп параметров. Если указана, другие варианты группировки параметров будут проигнорированы.

- ****kwargs** : Дополнительные аргументы, специфичные для оптимизатора (например, betas для Adam).

**Возвращает:**

Настроенный экземпляр оптимизатора.

Создайте экземпляр оптимизатора через реестр timm.

Создаёт и настраивает оптимизатор с соответствующими группами параметров и параметрами конфигурации. Поддерживает автоматическое создание групп параметров для weight decay и layer-wise learning rates, а также пользовательское группирование параметров.

Примеры:

AdamW из модели, группы параметров создаются автоматически:

```python
optimizer = create_optimizer_v2(model, 'adamw', lr=1e-3)
```

SGD с импульсом и затуханием весов:

```python
optimizer = create_optimizer_v2(model, 'sgd', lr=0.1, momentum=0.9, weight_decay=1e-4)
```

Adam с послойным затуханием коэффициента обучения:

```python
optimizer = create_optimizer_v2(model, 'adam', lr=1e-3, layer_decay=0.7)
```

Пользовательские группы параметров:

```python
def group_fn(model):
    return [
        {'params': model.backbone.parameters(), 'lr': 1e-4},
        {'params': model.head.parameters(), 'lr': 1e-3},
    ]

optimizer = create_optimizer_v2(model, 'sgd', param_group_fn=group_fn)
```

Примечание: приоритет обработки групп параметров:
1. Если указан param_group_fn, он будет использоваться исключительно
2. Если указан layer_decay, будут созданы послойные группы
3. Если weight_decay > 0 и filter_bias_and_bn равно True, будут созданы группы weight decay
4. В противном случае все параметры будут находиться в одной группе

#### timm.optim.list_optimizers[[timm.optim.list_optimizers]]

```python
timm.optim.list_optimizers(filter: typing.Union[str, typing.List[str]] = '', exclude_filters: typing.Optional[typing.List[str]] = None, with_description: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_optim_factory.py#L1137)

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

filter : Строка фильтра в стиле wildcards или список строк фильтров (например, 'adam*' для всех вариантов Adam или ['adam*', '*8bit'] для вариантов Adam и 8-битных оптимизаторов). Пустая строка означает отсутствие фильтрации.

exclude_filters : Необязательный список шаблонов с подстановочными знаками для исключения. Например, ['*8bit', 'fused*'] исключит 8-битные и слиянные реализации.

with_description : Если True, возвращает кортежи (name, description) вместо только имён. Описания содержат краткие пояснения характеристик оптимизатора.

**Возвращает:** `If with_description is False`

Список имён оптимизаторов в виде строк (например, ['adam', 'adamw', ...]) Если with_description равно True: список кортежей (name, description) (например, [('adam', 'Adaptive Moment...'), ...])

Список доступных имён оптимизаторов, при необходимости с фильтрацией.

Выводит список всех зарегистрированных оптимизаторов с возможностью фильтрации с использованием шаблонов с подстановочными символами. Оптимизаторы можно фильтровать с помощью шаблонов include и exclude, а также при необходимости возвращать описания вместе с каждым именем оптимизатора.

Примеры:

```python
>>> list_optimizers()
['adam', 'adamw', 'sgd', ...]

>>> list_optimizers(['la*', 'nla*'])  # List lamb & lars
['lamb', 'lambc', 'larc', 'lars', 'nlarc', 'nlars']

>>> list_optimizers('*adam*', exclude_filters=['bnb*', 'fused*'])  # Exclude bnb & apex adam optimizers
['adam', 'adamax', 'adamp', 'adamw', 'nadam', 'nadamw', 'radam']

>>> list_optimizers(with_description=True)  # Get descriptions
[('adabelief', 'Adapts learning rate based on gradient prediction error'),
 ('adadelta', 'torch.optim Adadelta, Adapts learning rates based on running windows of gradients'),
 ('adafactor', 'Memory-efficient implementation of Adam with factored gradients'),
...]
```

#### timm.optim.get_optimizer_class[[timm.optim.get_optimizer_class]]

```python
timm.optim.get_optimizer_class(name: str, bind_defaults: bool = True)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_optim_factory.py#L1200)

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

name : Имя оптимизатора для получения (например, 'adam', 'sgd')

bind_defaults : Если True, возвращает частичную функцию с аргументами по умолчанию, связанными из OptimInfo. Если False, возвращает исходный класс оптимизатора.

**Возвращает:** `If bind_defaults is False`

Класс оптимизатора (например, torch.optim.Adam). Если bind_defaults равно True: частичная функция с привязанными аргументами по умолчанию

**Исключения:** ``ValueError``

- ``ValueError`` -- если имя оптимизатора не найдено в реестре

Получить класс оптимизатора по имени с возможностью привязать аргументы по умолчанию.

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

Примеры:

При привязанных значениях по умолчанию из реестра `sgd` имеет включённый импульс Нестерова:

```python
SGD = get_optimizer_class('sgd')
opt = SGD(model.parameters(), lr=0.1, momentum=0.9)
```

Сырой класс оптимизатора:

```python
SGD = get_optimizer_class('sgd', bind_defaults=False)
opt = SGD(model.parameters(), lr=1e-3, momentum=0.9, nesterov=True)
```

#### timm.optim.get_optimizer_info[[timm.optim.get_optimizer_info]]

```python
timm.optim.get_optimizer_info(name: str)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_optim_factory.py#L1185)

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

name : Имя оптимизатора

**Возвращает:**

Конфигурация OptimInfo

**Исключения:** ``ValueError``

- ``ValueError`` -- если оптимизатор не найден

Получите OptimInfo для оптимизатора.

### Функции групп параметров[[timm.optim.param_groups_weight_decay]]

#### timm.optim.param_groups_weight_decay[[timm.optim.param_groups_weight_decay]]

```python
timm.optim.param_groups_weight_decay(model: Module, weight_decay: typing.Optional[float] = 1e-05, weight_decay_exclude_1d: bool = True, no_weight_decay_list: typing.Collection[str] = (), fallback_list: typing.Collection[str] = (), fallback_no_weight_decay: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_param_groups.py#L19)

#### timm.optim.param_groups_layer_decay[[timm.optim.param_groups_layer_decay]]

```python
timm.optim.param_groups_layer_decay(model: Module, weight_decay: float = 0.05, no_weight_decay_list: typing.Collection[str] = (), fallback_list: typing.Collection[str] = (), fallback_no_weight_decay: bool = False, weight_decay_exclude_1d: bool = True, layer_decay: float = 0.75, min_scale: float = 0.0, no_opt_scale: typing.Optional[float] = None, verbose: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_param_groups.py#L113)

Группы параметров для послойного затухания lr и weight decay На основе BEiT: https://github.com/microsoft/unilm/blob/master/beit/optim_factory.py#L58

#### timm.optim.auto_group_layers[[timm.optim.auto_group_layers]]

```python
timm.optim.auto_group_layers(model, layers_per_group = 12, num_groups = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/_param_groups.py#L84)

### Классы оптимизаторов[[timm.optim.AdaBelief]]

#### timm.optim.AdaBelief[[timm.optim.AdaBelief]]

```python
timm.optim.AdaBelief(params, lr = 0.001, betas = (0.9, 0.999), eps = 1e-16, weight_decay = 0, amsgrad = False, decoupled_decay = True, fixed_decay = False, rectify = True, degenerated_to_sgd = True, foreach: typing.Optional[bool] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adabelief.py#L13)

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

params (iterable): итерируемый объект с параметрами для оптимизации или словарями, определяющими группы параметров

lr (float, optional) : скорость обучения (по умолчанию: 1e-3)

betas (Tuple[float, float], optional) : коэффициенты, используемые для вычисления скользящих средних градиента и его квадрата (по умолчанию: (0.9, 0.999))

eps (float, optional) : слагаемое, добавляемое к знаменателю для повышения численной устойчивости (по умолчанию: 1e-16)

weight_decay (float, optional) : весовое затухание (штраф L2) (по умолчанию: 0)

amsgrad (boolean, optional) : использовать ли вариант AMSGrad этого алгоритма из статьи `On the Convergence of Adam and Beyond`_ (по умолчанию: False)

decoupled_decay (boolean, optional) : (по умолчанию: True) Если установлено в True, оптимизатор использует развязанное затухание весов, как в AdamW

fixed_decay (boolean, optional) : (по умолчанию: False) Используется, когда weight_decouple установлено в True. Если fixed_decay == True, затухание весов выполняется по формуле $W_{new} = W_{old} - W_{old} \times decay$. Если fixed_decay == False, затухание весов выполняется по формуле $W_{new} = W_{old} - W_{old} \times decay \times lr$. Обратите внимание, что в этом случае коэффициент затухания весов уменьшается вместе с шагом обучения (lr).

rectify (boolean, optional) : (по умолчанию: True) Если установлено в True, выполняется исправленное обновление, аналогичное RAdam

degenerated_to_sgd (boolean, optional) (по умолчанию --True) Если установлено значение True, выполняется обновление SGD, когда дисперсия градиента высока

foreach (boolean, optional) : использовать реализацию foreach (многотензорную), по умолчанию (None) используется, если не поддерживается

Реализует алгоритм AdaBelief. Модифицирован на основе Adam из PyTorch

reference: Оптимизатор AdaBelief, адаптация шагов по степени доверия к наблюдаемым градиентам, NeurIPS 2020

Полную таблицу рекомендуемых гиперпараметров см. по адресу https://github.com/juntang-zhuang/Adabelief-Optimizer. Например, train/args для EfficientNet см. в этих gists
- ссылка на train_script: https://gist.github.com/juntang-zhuang/0a501dd51c02278d952cf159bc233037
- ссылка на args.yaml: https://gist.github.com/juntang-zhuang/517ce3c27022b908bb93f78e4f786dc3

#### шаг[[timm.optim.AdaBelief.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adabelief.py#L121)

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

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

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

#### timm.optim.Adafactor[[timm.optim.Adafactor]]

```python
timm.optim.Adafactor(params: ParamsT, lr: typing.Optional[float] = None, eps: float = 1e-30, eps_scale: float = 0.001, clip_threshold: float = 1.0, decay_rate: float = -0.8, betas: typing.Optional[typing.Tuple[float, float]] = None, weight_decay: float = 0.0, scale_parameter: bool = True, warmup_init: bool = False, min_dim_size_to_factor: int = 16, caution: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adafactor.py#L22)

Реализует алгоритм Adafactor.

Эта реализация основана на: `Adafactor: Adaptive Learning Rates with Sublinear Memory Cost` (см. https://arxiv.org/abs/1804.04235)

Обратите внимание, что этот оптимизатор внутренним образом корректирует скорость обучения в зависимости от параметров *scale_parameter*, *relative_step* и *warmup_init*.

Ручной (внешний) график изменения скорости обучения используется, когда задано значение `lr` (в этом случае `relative_step` равно False). Обратите внимание, что в данной реализации `scale_parameter` и `warmup_init` применяются только к относительной скорости обучения (`lr=None`); в отличие от fairseq / HF Transformers, масштабирование RMS параметров не применяется к внешней скорости обучения.

Ags: params: итерируемый объект с параметрами для оптимизации или словарями, определяющими группы параметров lr: внешняя скорость обучения eps: константы регуляризации для квадратного градиента и масштаба параметров соответственно eps_scale: константы регуляризации для масштаба параметров соответственно clip_threshold: порог среднеквадратичного значения окончательного обновления градиента decay_rate: коэффициент, используемый для вычисления скользящих средних квадратного градиента beta1: коэффициент, используемый для вычисления скользящих средних градиента weight_decay: затухание весов scale_parameter: если True, относительная скорость обучения масштабируется среднеквадратичным значением параметров warmup_init: вычисление скорости обучения, зависящей от времени, зависит от того, используется ли инициализация с разгоном

#### шаг[[timm.optim.Adafactor.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adafactor.py#L140)

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

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

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

#### timm.optim.AdafactorBigVision[[timm.optim.AdafactorBigVision]]

```python
timm.optim.AdafactorBigVision(params: ParamsT, lr: float = 1.0, min_dim_size_to_factor: int = 16, decay_rate: float = 0.8, decay_offset: int = 0, beta2_cap: float = 0.999, momentum: typing.Optional[float] = 0.9, momentum_dtype: typing.Union[str, torch.dtype] = torch.bfloat16, eps: typing.Optional[float] = None, weight_decay: float = 0.0, clipping_threshold: typing.Optional[float] = None, unscaled_wd: bool = False, caution: bool = False, corrected_weight_decay: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adafactor_bv.py#L49)

Реализация PyTorch варианта Adafactor от BigVision с реализациями для одиночных и множественных тензоров.

Адаптировано из https://github.com/google-research/big_vision Россом Уайтменом

#### timm.optim.Adahessian[[timm.optim.Adahessian]]

```python
timm.optim.Adahessian(params, lr = 0.1, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0.0, hessian_power = 1.0, update_each = 1, n_samples = 1, avg_conv_kernel = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L9)

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

params (iterable): итерируемый объект с параметрами для оптимизации или словарями, определяющими группы параметров

lr (float, необязательно) : скорость обучения (по умолчанию: 0.1)

betas ((float, float), optional) : коэффициенты, используемые для вычисления скользящих средних градиента и следа квадратичной гессиана (по умолчанию: (0.9, 0.999))

eps (float, optional) : член, добавляемый к знаменателю для улучшения численной стабильности (по умолчанию: 1e-8)

weight_decay (float, optional) : весовое затухание (штраф L2) (по умолчанию: 0.0)

hessian_power (float, optional) : показатель степени следа гессиана (по умолчанию: 1.0)

update_each (int, optional) : вычислять приближение следа гессиана только после *этого* количества шагов (для экономии времени) (по умолчанию: 1)

n_samples (int, optional) : сколько раз сэмплировать `z` для аппроксимации следа гессиана (по умолчанию: 1)

Реализует алгоритм AdaHessian из статьи «ADAHESSIAN: адаптивный оптимизатор второго порядка для машинного обучения»

#### get_params[[timm.optim.Adahessian.get_params]]

```python
get_params()
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L74)

Получает все параметры во всех param_groups, у которых есть градиенты

#### set_hessian[[timm.optim.Adahessian.set_hessian]]

```python
set_hessian()
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L90)

Вычисляет приближение Хатчинсона для следа гессиана и накапливает его для каждого обучаемого параметра.

#### шаг[[timm.optim.Adahessian.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L119)

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

closure (callable, необязательный) : замыкание, которое повторно вычисляет модель и возвращает потерю (по умолчанию -- None)

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

#### zero_hessian[[timm.optim.Adahessian.zero_hessian]]

```python
zero_hessian()
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adahessian.py#L81)

Обнуляет накопленные следы гессиана.

#### timm.optim.AdamP[[timm.optim.AdamP]]

```python
timm.optim.AdamP(params, lr = 0.001, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0, delta = 0.1, wd_ratio = 0.1, nesterov = False, caution = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adamp.py#L64)

#### timm.optim.AdamWLegacy[[timm.optim.AdamWLegacy]]

```python
timm.optim.AdamWLegacy(params: ParamsT, lr: float = 0.001, betas: typing.Tuple[float, float] = (0.9, 0.999), eps: float = 1e-08, weight_decay: float = 0.01, amsgrad: bool = False, caution: bool = False, corrected_weight_decay: bool = False, maximize: bool = False, foreach: typing.Optional[bool] = None, capturable: bool = False, clipping_threshold: typing.Optional[float] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adamw.py#L23)

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

params : итерируемый объект параметров для оптимизации или словари, определяющие группы параметров

lr : скорость обучения

betas : коэффициенты, используемые для вычисления скользящих средних градиента и его квадрата

eps : член, добавляемый в знаменатель для улучшения численной устойчивости

weight_decay : коэффициент затухания весов

amsgrad : использовать ли вариант AMSGrad этого алгоритма из статьи `On the Convergence of Adam and Beyond`

caution : будьте осторожны при использовании AdamW

corrected_weight_decay : применить скорректированное затухание весов (lr**2 / max_lr)

maximize : максимизировать параметры на основе целевой функции, а не минимизировать

foreach : whether foreach implementation of optimizer is used. If unspecified by the user (so foreach is None), we will try to use foreach over for-loop implementation on CUDA, since it is faster in general.

capturable : указывает, безопасно ли захватывать этот экземпляр в графе CUDA. Передача True может ухудшить производительность при отсутствии графа, поэтому, если вы не планируете захват этого экземпляра в граф, оставьте значение False

clipping_threshold : порог обрезания обновления RMS (StableAdamW, https://arxiv.org/abs/2304.13013), обновление масштабируется множителем 1 / max(1, rms / clipping_threshold), где rms — это RMS от grad / (sqrt(v_hat) + eps). При резком увеличении градиента относительно оценки второго момента обновление параметров приглушается. По умолчанию 1.0, как в статье; None (значение по умолчанию) отключает обрезание. Как и в Adafactor, отделенное затухание весов не обрезается (StableAdamW также масштабирует затухание обрезанным lr).

Реализует алгоритм AdamW.

NOTE: Данная реализация устарела в пользу torch.optim.AdamW и остаётся в качестве справочного материала

Ссылки:
- Adam: A Method for Stochastic Optimization: https://arxiv.org/abs/1412.6980
- Регуляризация с отделённым затуханием весов: https://arxiv.org/abs/1711.05101
- О сходимости Adam и далее: https://openreview.net/forum?id=ryQu7f-RZ

#### шаг[[timm.optim.AdamWLegacy.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adamw.py#L116)

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

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

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

#### timm.optim.Adan[[timm.optim.Adan]]

```python
timm.optim.Adan(params, lr: float = 0.001, betas: typing.Tuple[float, float, float] = (0.98, 0.92, 0.99), eps: float = 1e-08, weight_decay: float = 0.0, no_prox: bool = False, caution: bool = False, foreach: typing.Optional[bool] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adan.py#L48)

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

params : Итерируемый объект параметров для оптимизации или словари, определяющие группы параметров.

lr : Скорость обучения.

betas : Коэффициенты, используемые для моментов первого и второго порядка.

eps : Член, добавляемый в знаменатель для повышения численной устойчивости.

weight_decay : Развязанное затухание весов (штраф L2)

no_prox : Как выполнять весовое затухание

caution : Включить осторожность из «Cautious Optimizers»

foreach : Если True, будет использоваться реализация torch._foreach. Быстрее, но использует немного больше памяти.

Реализует pytorch-вариант Adan.

Adan был предложен в статье Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models https://arxiv.org/abs/2208.06677

#### шаг[[timm.optim.Adan.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adan.py#L119)

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

#### timm.optim.Adopt[[timm.optim.Adopt]]

```python
timm.optim.Adopt(params: ParamsT, lr: typing.Union[float, torch.Tensor] = 0.001, betas: typing.Tuple[float, float] = (0.9, 0.9999), eps: float = 1e-06, clip_exp: typing.Optional[float] = 0.333, weight_decay: float = 0.0, decoupled: bool = False, corrected_weight_decay: bool = False, caution: bool = False, foreach: typing.Optional[bool] = None, maximize: bool = False, capturable: bool = False, differentiable: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adopt.py#L60)

ADOPT: Модифицированный Adam может сходиться с любым β2 с оптимальной скоростью: https://arxiv.org/abs/2411.02853

#### шаг[[timm.optim.Adopt.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/adopt.py#L197)

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

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

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

#### timm.optim.kron.Kron[[timm.optim.kron.Kron]]

```python
timm.optim.kron.Kron(params: ParamsT, lr: float = 0.001, momentum: float = 0.9, weight_decay: float = 0.0, preconditioner_update_probability: typing.Union[typing.Callable, float, NoneType] = None, max_size_triangular: int = 2048, min_ndim_triangular: int = 2, memory_save_mode: typing.Optional[str] = None, momentum_into_precond_update: bool = True, precond_lr: float = 0.1, precond_init_scale: float = 1.0, mu_dtype: typing.Optional[torch.dtype] = None, precond_dtype: typing.Optional[torch.dtype] = None, decoupled_decay: bool = False, corrected_weight_decay: bool = False, flatten: bool = False, flatten_start_dim: int = 2, flatten_end_dim: int = -1, stochastic_weight_decay: bool = False, deterministic: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/kron.py#L82)

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

params : Итерируемый объект параметров для оптимизации или словари, определяющие группы параметров.

lr : Скорость обучения.

momentum : Параметр импульса.

weight_decay : Затухание весов.

preconditioner_update_probability : Вероятность обновления преобразователя. Если None, по умолчанию используется расписание, которое аннелирует значение с 1.0 до 0.03 к 4000 шагам.

max_size_triangular : Максимальный размер предобусловливателя для dim, чтобы он был треугольным.

min_ndim_triangular : Минимальное количество измерений, которое должен иметь слой, чтобы использовать треугольные преобразователи.

memory_save_mode : 'one_diag', 'smart_one_diag' или 'all_diag', по умолчанию None, что устанавливает все преобразователи в треугольные; 'one_diag' устанавливает диагональный преобразователь для наибольшего или последнего измерения в каждом слое, а 'all_diag' устанавливает все преобразователи в диагональные.

momentum_into_precond_update : следует ли передавать импульс в обновление преобразователя вместо исходных градиентов.

mu_dtype : Тип данных (dtype) накопителя импульса.

precond_dtype : Тип данных преобразователя (preconditioner).

decoupled_decay : развязанное затухание весов в стиле AdamW

corrected_weight_decay : применяйте скорректированный весовой распад при использовании decoupled_decay (lr**2 / max_lr)

flatten : Разверните измерения, а не полагайтесь полностью на выражения для параметров более высокого ранга

flatten_start_dim : Начало диапазона сглаживания, по умолчанию 2. Похоже, это хороший компромисс для свёрточных сетей.

flatten_end_dim : Конец диапазона flatten, по умолчанию -1.

stochastic_weight_decay : Включить случайную модуляцию затухания весов

deterministic : Детерминированное поведение при сохранении / загрузке (возобновлении). FIXME медленный, требует доработки

Реализует PSGD Kron из https://github.com/lixilinx/psgd_torch.

#### timm.optim.Lamb[[timm.optim.Lamb]]

```python
timm.optim.Lamb(params: ParamsT, lr: float = 0.001, bias_correction: bool = True, betas: typing.Tuple[float, float] = (0.9, 0.999), eps: float = 1e-06, weight_decay: float = 0.01, grad_averaging: bool = True, max_grad_norm: typing.Optional[float] = 1.0, trust_clip: bool = False, always_adapt: bool = False, caution: bool = False, decoupled_decay: bool = False, corrected_weight_decay: bool = False, foreach: typing.Optional[bool] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lamb.py#L71)

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

params : Итерируемый объект параметров для оптимизации или словари, определяющие группы параметров.

lr : Скорость обучения

betas : Коэффициенты, используемые для вычисления скользящих средних градиента и его нормы.

eps : Член, добавляемый в знаменатель для повышения численной устойчивости.

weight_decay : Затухание весов

grad_averaging : Применяется ли (1-beta2) к градиенту при вычислении скользящих средних градиента.

max_grad_norm : Значение, используемое для обрезки глобальной нормы градиентов.

trust_clip : Включить обрезание отношения доверия LAMBC.

always_adapt : Примените адаптивную скорость обучения к параметру 0.0 weight decay.

caution : Будьте осторожны.

decoupled : применение независимого затухания весов

corrected_weight_decay : применяйте скорректированный весовой распад (lr**2 / max_lr) при использовании decoupled_decay

foreach : использовать реализацию foreach (многотензорную), по умолчанию (None) используется, если не поддерживается

Реализует чистый pytorch-вариант оптимизатора FuseLAMB (вариант NvLamb) из apex.optimizers.FusedLAMB. Ссылка на исходный код: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py

LAMB был предложен в:
- Оптимизация с большими батчами для глубокого обучения — обучение BERT за 76 минут: https://arxiv.org/abs/1904.00962
- О сходимости Adam и далее: https://openreview.net/forum?id=ryQu7f-RZ

#### шаг[[timm.optim.Lamb.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lamb.py#L169)

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

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

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

#### timm.optim.LaProp[[timm.optim.LaProp]]

```python
timm.optim.LaProp(params: ParamsT, lr: float = 0.0004, betas: typing.Tuple[float, float] = (0.9, 0.999), eps: float = 1e-15, weight_decay: float = 0.0, caution: bool = False, corrected_weight_decay: bool = False, foreach: typing.Optional[bool] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/laprop.py#L32)

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

foreach : использовать реализацию foreach (многотензорную), по умолчанию (None) используется, если не поддерживается (см. laprop())

Оптимизатор LaProp

Статья: LaProp: Separating Momentum and Adaptivity in Adam, https://arxiv.org/abs/2002.04839

#### шаг[[timm.optim.LaProp.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/laprop.py#L106)

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

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

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

#### timm.optim.Lars[[timm.optim.Lars]]

```python
timm.optim.Lars(params, lr = 1.0, momentum = 0, dampening = 0, weight_decay = 0, nesterov = False, trust_coeff = 0.001, eps = 1e-08, trust_clip = False, always_adapt = False, foreach: typing.Optional[bool] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lars.py#L22)

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

params (iterable) : итерируемый объект с параметрами для оптимизации или словарями, определяющими группы параметров.

lr (float, optional) : скорость обучения (по умолчанию: 1.0).

momentum (float, optional) : коэффициент импульса (по умолчанию: 0)

weight_decay (float, optional) : весовое затухание (штраф L2) (по умолчанию: 0)

dampening (float, optional) : затухание для импульса (по умолчанию: 0)

nesterov (bool, optional) : включает импульс Нестерова (по умолчанию: False)

trust_coeff (float) : коэффициент доверия для вычисления адаптивной lr / trust_ratio (по умолчанию: 0.001)

eps (float) : eps для знаменателя при делении (по умолчанию: 1e-8)

trust_clip (bool) : включить обрезание по доверительному соотношению LARC (по умолчанию: False)

always_adapt (bool) : всегда применять адаптацию LARS LR, иначе только когда group weight_decay != 0 (по умолчанию: False)

foreach (bool, optional) : использовать реализацию foreach (для нескольких тензоров), по умолчанию (None) используется, если не поддерживается

LARS для PyTorch

Статья: `Large batch training of Convolutional Networks` - https://arxiv.org/pdf/1708.03888.pdf

#### шаг[[timm.optim.Lars.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lars.py#L84)

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

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

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

#### timm.optim.Lion[[timm.optim.Lion]]

```python
timm.optim.Lion(params: ParamsT, lr: float = 0.0001, betas: typing.Tuple[float, float] = (0.9, 0.99), weight_decay: float = 0.0, caution: bool = False, corrected_weight_decay: bool = False, maximize: bool = False, foreach: typing.Optional[bool] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lion.py#L34)

Реализует алгоритм Lion.

#### шаг[[timm.optim.Lion.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lion.py#L86)

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

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

**Возвращает:**

потеря.

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

#### timm.optim.Lookahead[[timm.optim.Lookahead]]

```python
timm.optim.Lookahead(base_optimizer, alpha = 0.5, k = 6)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/lookahead.py#L15)

#### timm.optim.MADGRAD[[timm.optim.MADGRAD]]

```python
timm.optim.MADGRAD(params: typing.Any, lr: float = 0.01, momentum: float = 0.9, weight_decay: float = 0, eps: float = 1e-06, decoupled_decay: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/madgrad.py#L24)

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

params (iterable) : Итерируемый объект параметров для оптимизации или словарей, определяющих группы параметров.

lr (float) : Скорость обучения (по умолчанию: 1e-2).

momentum (float) : значение импульса в диапазоне [0,1) (по умолчанию: 0.9).

weight_decay (float) : Weight decay, то есть L2-штраф (по умолчанию: 0).

eps (float) : Слагаемое, добавляемое к знаменателю вне операции извлечения корня для повышения численной устойчивости. (по умолчанию: 1e-6).

MADGRAD_: метод стохастической оптимизации с импульсом, адаптивным и двойным усреднением градиента.

.. _MADGRAD: https://arxiv.org/abs/2101.11075

MADGRAD — это универсальный оптимизатор, который можно использовать вместо SGD или Adam; он может сходиться быстрее и лучше обобщать. В настоящее время поддерживается только GPU. Как правило, можно использовать тот же график изменения скорости обучения, что и для SGD или Adam. Общая скорость обучения не сопоставима с ни одним из этих методов и должна определяться с помощью перебора гиперпараметров.

MADGRAD требует меньшего затухания весов, чем другие методы, часто вплоть до нуля. Значения импульса, используемые для SGD или beta1 в Adam, должны работать и здесь.

Для разреженных задач оба параметра weight_decay и momentum должны быть установлены в 0.

#### шаг[[timm.optim.MADGRAD.step]]

```python
step(closure: typing.Optional[typing.Callable[[], float]] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/madgrad.py#L90)

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

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

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

#### timm.optim.Mars[[timm.optim.Mars]]

```python
timm.optim.Mars(params: ParamsT, lr: float = 0.003, betas: typing.Tuple[float, float] = (0.9, 0.99), eps: float = 1e-08, weight_decay: float = 0.0, gamma: float = 0.025, mars_type: str = 'adamw', optimize_1d: bool = False, lr_1d_factor: float = 1.0, betas_1d: typing.Optional[typing.Tuple[float, float]] = None, caution: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/mars.py#L90)

Оптимизатор MARS

Статья: MARS: Раскрытие потенциала снижения дисперсии для обучения больших моделей https://arxiv.org/abs/2411.10438

#### шаг[[timm.optim.Mars.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/mars.py#L140)

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

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

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

#### timm.optim.Muon[[timm.optim.Muon]]

```python
timm.optim.Muon(params: ParamsT, lr: float = 0.02, weight_decay: float = 0, momentum: float = 0.95, nesterov: bool = False, ns_steps: int = 5, ns_coefficients: typing.Union[str, typing.Tuple[float, float, float], typing.List[typing.Tuple[float, float, float]]] = 'quintic', eps: float = 1e-07, safety_factor: float = 1.0, adjust_lr_fn: typing.Optional[str] = 'match_rms_adamw', conv_mode: str = 'flatten', normalize_spatial: bool = True, adamw_lr: typing.Optional[float] = None, fallback_lr_scale: float = 1.0, betas: typing.Tuple[float, float] = (0.9, 0.95), algo: str = 'muon', scale_eps: bool = False, capturable: bool = False, verbose: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/muon.py#L654)

Muon - MomentUm, ортогонализированный методом Ньютона-Шульца

Сочетает Muon для параметров размерности 2D и выше (матрицы весов) с AdamW для параметров размерности 1D (смещения, нормализации) и групп параметров, для которых установлено 'use_fallback=True' (или 'use_muon=False' для совместимости).

Поддерживает два алгоритма:
- "muon": стандартный алгоритм Muon с импульсом + ортогонализацией
- "adamuon": алгоритм AdaMuon, который добавляет поэлементную оценку второго момента к ортогонализированным направлениям для адаптивного масштабирования, похожего на Adam

#### шаг[[timm.optim.Muon.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/muon.py#L798)

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

#### timm.optim.NAdamLegacy[[timm.optim.NAdamLegacy]]

```python
timm.optim.NAdamLegacy(params, lr = 0.002, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0, schedule_decay = 0.004)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nadam.py#L7)

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

params (iterable): итерируемый объект с параметрами для оптимизации или словарями, определяющими группы параметров

lr (float, optional) : скорость обучения (по умолчанию: 2e-3)

betas (Tuple[float, float], optional) : коэффициенты, используемые для вычисления скользящих средних градиента и его квадрата

eps (float, optional) : член, добавляемый к знаменателю для улучшения численной стабильности (по умолчанию: 1e-8)

weight_decay (float, optional) : весовое затухание (штраф L2) (по умолчанию: 0)

schedule_decay (float, optional) : коэффициент затухания расписания импульса (по умолчанию: 4e-3)

Реализует алгоритм Nadam (вариант Adam на основе импульса Нестерова).

NOTE: Данная реализация устарела в пользу torch.optim.NAdam и остаётся в качестве справочного материала

В статье `Incorporating Nesterov Momentum into Adam`__ это было предложено.

__ http://cs229.stanford.edu/proj2015/054_report.pdf __ http://www.cs.toronto.edu/~fritz/absps/momentum.pdf

Изначально взято из: https://github.com/pytorch/pytorch/pull/1408 ПРИМЕЧАНИЕ: Возможны проблемы, но хорошо работает на некоторых задачах.

#### шаг[[timm.optim.NAdamLegacy.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nadam.py#L52)

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

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

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

#### timm.optim.NAdamW[[timm.optim.NAdamW]]

```python
timm.optim.NAdamW(params: ParamsT, lr: float = 0.001, betas: typing.Tuple[float, float] = (0.9, 0.999), eps: float = 1e-08, weight_decay: float = 0.01, caution: bool = False, corrected_weight_decay: bool = False, maximize: bool = False, foreach: typing.Optional[bool] = None, capturable: bool = False, clipping_threshold: typing.Optional[float] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nadamw.py#L25)

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

params : итерируемый объект параметров для оптимизации или словари, определяющие группы параметров

lr : скорость обучения

betas : коэффициенты, используемые для вычисления скользящих средних градиента и его квадрата

eps : член, добавляемый в знаменатель для улучшения численной устойчивости

weight_decay : коэффициент затухания весов

caution : включить осторожность

corrected_weight_decay : применить скорректированное затухание весов (lr**2 / max_lr)

maximize : максимизировать параметры на основе целевой функции, а не минимизировать

foreach : используется ли foreach-реализация оптимизатора. Если не указано (None), foreach-реализация используется на CUDA (устройства с foreach-ядрами), поскольку в целом она быстрее.

capturable : указывает, безопасно ли захватывать этот экземпляр в графе CUDA

clipping_threshold : порог обрезания обновления RMS (StableAdamW, https://arxiv.org/abs/2304.13013), обновление масштабируется множителем 1 / max(1, rms / clipping_threshold), где rms — это RMS от grad / (sqrt(v_hat) + eps). При резком увеличении градиента относительно оценки второго момента обновление параметров приглушается. По умолчанию 1.0, как в статье; None (значение по умолчанию) отключает обрезание. Как и в Adafactor, отделенное затухание весов не обрезается (StableAdamW также масштабирует затухание обрезанным lr).

Реализует алгоритм NAdamW.

Реализация алгоритма NAdam описана в таблице 1 в https://arxiv.org/abs/1910.05446 (в коде также есть комментарий, указывающий на единственное отличие NAdamW от AdamW).

За дополнительными деталями относительно алгоритма мы отсылаем к
- Регуляризация с отделённым затуханием весов: https://arxiv.org/abs/1711.05101
- О сходимости Adam и далее: https://openreview.net/forum?id=ryQu7f-RZ

#### шаг[[timm.optim.NAdamW.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nadamw.py#L113)

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

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

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

#### timm.optim.NvNovoGrad[[timm.optim.NvNovoGrad]]

```python
timm.optim.NvNovoGrad(params, lr = 0.001, betas = (0.95, 0.98), eps = 1e-08, weight_decay = 0, grad_averaging = False, amsgrad = False, decoupled_decay = False, corrected_weight_decay = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nvnovograd.py#L17)

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

params (iterable): итерируемый объект с параметрами для оптимизации или словарями, определяющими группы параметров

lr (float, optional) : скорость обучения (по умолчанию: 1e-3)

betas (Tuple[float, float], optional) : коэффициенты, используемые для вычисления скользящих средних градиента и его квадрата (по умолчанию: (0.95, 0.98))

eps (float, optional) : член, добавляемый к знаменателю для улучшения численной стабильности (по умолчанию: 1e-8)

weight_decay (float, optional) : весовое затухание (штраф L2) (по умолчанию: 0)

grad_averaging : усреднение градиентов

amsgrad (boolean, optional) : использовать ли вариант AMSGrad этого алгоритма из статьи `On the Convergence of Adam and Beyond`_ (по умолчанию: False)

decoupled_decay : применять весовое затухание непосредственно к весам (lr * weight_decay на каждом шаге), а не добавлять его к нормализованному градиенту перед обновлением импульса (как описано в статье)

corrected_weight_decay : применяйте скорректированный весовой распад (lr**2 / max_lr), когда decoupled_decay равно True

Реализует алгоритм Novograd.

#### шаг[[timm.optim.NvNovoGrad.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/nvnovograd.py#L90)

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

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

и возвращает потерю. --

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

#### timm.optim.RAdamLegacy[[timm.optim.RAdamLegacy]]

```python
timm.optim.RAdamLegacy(params, lr = 0.001, betas = (0.9, 0.999), eps = 1e-08, weight_decay = 0)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/radam.py#L16)

Оптимизатор RAdam для PyTorch

NOTE: Данная реализация устарела в пользу torch.optim.AdamW и остаётся в качестве справочного материала

#### timm.optim.RMSpropTF[[timm.optim.RMSpropTF]]

```python
timm.optim.RMSpropTF(params: ParamsT, lr: float = 0.01, alpha: float = 0.9, eps: float = 1e-10, weight_decay: float = 0, momentum: float = 0.0, centered: bool = False, decoupled_decay: bool = False, corrected_weight_decay: bool = False, lr_in_momentum: bool = True, caution: bool = False, foreach: typing.Optional[bool] = None)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/rmsprop_tf.py#L27)

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

params : итерируемый объект параметров для оптимизации или словари, определяющие группы параметров

lr : скорость обучения

momentum : коэффициент импульса

alpha : константа сглаживания (затухания)

eps : член, добавляемый в знаменатель для улучшения численной устойчивости

centered : если `True`, вычисляется центрированный RMSProp, градиент нормализуется по оценке его дисперсии

weight_decay : весовое затухание (L2-штраф) (по умолчанию: 0)

decoupled_decay : развязанное затухание весов согласно https://arxiv.org/abs/1711.05101

corrected_weight_decay : применяйте скорректированный весовой распад (lr**2 / max_lr), когда decoupled_decay равно True

lr_in_momentum : масштабирование скорости обучения включено в обновление буфера импульса в соответствии с настройками по умолчанию в Tensorflow

caution : будьте осторожны

foreach : использовать реализацию foreach (многотензорную), по умолчанию (None) используется, если не поддерживается (см. rmsprop_tf())

Реализует алгоритм RMSprop (эпсилон в стиле TensorFlow)

NOTE: Это прямая копия PyTorch RMSprop с применением eps перед sqrt и несколькими другими изменениями для более точного соответствия Tensorflow при совпадающих гиперпараметрах.

Среди значимых изменений:
1. Epsilon, применяемый внутри квадратного корня
2. square_avg инициализирован единицами
3. Масштабирование LR обновления, накопленного в буфере импульса

Предложено Дж. Хинтоном в его [курсе](http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf).

The centered version first appears in [Generating Sequences With Recurrent Neural Networks](https://arxiv.org/pdf/1308.0850v5.pdf).

#### шаг[[timm.optim.RMSpropTF.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/rmsprop_tf.py#L112)

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

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

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

#### timm.optim.SGDP[[timm.optim.SGDP]]

```python
timm.optim.SGDP(params, lr = torch.optim.optimizer.required, momentum = 0, dampening = 0, weight_decay = 0, nesterov = False, eps = 1e-08, delta = 0.1, wd_ratio = 0.1, caution = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/sgdp.py#L22)

#### timm.optim.SGDW[[timm.optim.SGDW]]

```python
timm.optim.SGDW(params: ParamsT, lr: float = 0.001, momentum: float = 0.0, dampening: float = 0.0, weight_decay: float = 0.0, nesterov: bool = False, caution: bool = False, corrected_weight_decay: bool = False, maximize: bool = False, foreach: typing.Optional[bool] = None, differentiable: bool = False)
```

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/sgdw.py#L26)

#### шаг[[timm.optim.SGDW.step]]

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

[Источник](https://github.com/huggingface/pytorch-image-models/blob/v1.0.31/timm/optim/sgdw.py#L98)

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

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

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