# Otimização

Esta página contém a documentação de referência da API dos otimizadores incluídos em `timm`, além de uma visão geral de como eles são selecionados e configurados por meio da fábrica de otimizadores.

## Uso

Os otimizadores são criados por nome com [`create_optimizer_v2`](#timm.optim.create_optimizer_v2). Dado um modelo, a fábrica constrói os grupos de parâmetros (exclusões de decaimento de peso, decaimento opcional da taxa de aprendizado por camada) antes de construir o otimizador. Os argumentos específicos do otimizador são passados como argumentos de palavra-chave.

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

O script de treinamento (`train.py`) expõe o mesmo por meio destas flags:

- **`--opt`** seleciona o otimizador.
- **`--lr`** define a taxa de aprendizado.
- **`--weight-decay`** define o weight decay.
- **`--momentum`** define o momentum.
- **`--opt-eps`** define o epsilon (`eps`).
- **`--opt-betas`** define os coeficientes beta (`betas`).
- **`--layer-decay`** define o decaimento da taxa de aprendizado por camada.
- **`--opt-kwargs key=value ...`** passa quaisquer outros argumentos do otimizador.

### Convenções de nomenclatura

Os nomes registrados são em minúsculas, um nome de otimizador base mais modificadores:

| Modificador | Significado | Exemplos |
|---|---|---|
| prefixo `c` | Variante cautelosa, a atualização é mascarada onde seu sinal diverge do gradiente ([Cautious Optimizers](https://arxiv.org/abs/2411.16085)) | `cadamw`, `clion`, `cmars`, `cadopt` |
| sufixo `w` | Decaimento de peso desacoplado (estilo AdamW), para otimizadores que por padrão utilizam decaimento L2 acoplado | `sgdw`, `lambw`, `adoptw`, `novogradw`, `rmsproptfw` |
| sufixo `c` | Decaimento de peso corrigido, o decaimento é escalado por `lr² / max_lr` em vez de `lr` ([Por que os gradientes aumentam rapidamente perto do final do treinamento](https://arxiv.org/abs/2506.02285)) | `adamc`, `nadamc`, `sgdc`, `lionc`, `adoptc`, `kronc` |
| prefixo `n` | Momentum de Nesterov (famílias SGD, LARS e Muon) | `nesterov`, `nlars`, `nmuon`, `nadamuon` |
| prefixo `lookahead_` | Envolva o otimizador em [`Lookahead`](#timm.optim.lookahead.Lookahead) | `lookahead_adamw` |
| prefixo `fused` | Implementação fundida da NVIDIA Apex (requer `apex`) | `fusedadamw`, `fusedlamb` |
| prefixo `bnb` | implementação bitsandbytes, sufixo `8bit` para estado de 8 bits (requer `bitsandbytes`) | `bnbadamw`, `bnbadamw8bit` |

Alguns nomes são anteriores às convenções: `lambc` e `larc` são LAMB / LARS com recorte de razão de confiança (a variante corrigida de decaimento do LAMB é `lambcd`), `momentum` é SGD com momento clássico e `sgd` é SGD com momento de Nesterov. As implementações `legacy` na tabela abaixo são anteriores à sua inclusão no PyTorch.

### Famílias de otimizador

| Nomes | Implementação | Observações |
|---|---|---|
| `adamw`, `adam`, `nadam`, `radam`, `radamw`, `adamax`, `adadelta`, `adagrad`, `rmsprop`, `sgd`, `momentum`, `nesterov` | `torch.optim` | |
| `adamwlegacy`, `adamc`, `cadamw`, `cadamc` | [`AdamWLegacy`](#timm.optim.adamw.AdamWLegacy) | AdamW com cautela, decaimento corrigido, recorte de atualização, `capturable` |
| `nadamw`, `nadamc`, `cnadamw`, `cnadamc` | [`NAdamW`](#timm.optim.nadamw.NAdamW) | AdamW com momento de Nesterov (forma de eficiência algorítmica do MLCommons) |
| `adopt`, `adoptw`, `adoptc`, `cadopt`, `cadoptw`, `cadoptc` | [`Adopt`](#timm.optim.adopt.Adopt) | Variante do Adam que converge para qualquer β2 |
| `adan`, `adanw`, `cadan`, `cadanw` | [`Adan`](#timm.optim.adan.Adan) | Momentum adaptativo de Nesterov |
| `adabelief`, `radabelief` | [`AdaBelief`](#timm.optim.adabelief.AdaBelief) | `radabelief` adiciona retificação no estilo RAdam |
| `adafactor`, `cadafactor` | [`Adafactor`](#timm.optim.adafactor.Adafactor) | fairseq Adafactor, tamanho relativo do passo quando `lr=None` |
| `adafactorbv`, `adafactorbvc`, `cadafactorbv`, `cadafactorbvc` | [`AdafactorBigVision`](#timm.optim.adafactor_bv.AdafactorBigVision) | Big Vision Adafactor, momentos de segunda ordem fatorados, momento de baixa precisão, recorte de atualização |
| `adamp`, `cadamp`, `sgdp`, `csgdp` | [`AdamP`](#timm.optim.adamp.AdamP), [`SGDP`](#timm.optim.sgdp.SGDP) | Projeção da atualização para pesos invariantes em relação à escala |
| `adahessian` | [`Adahessian`](#timm.optim.adahessian.Adahessian) | Segunda ordem, requer um closure (`is_second_order`) |
| `kron`, `kronw`, `kronc` | [`Kron`](#timm.optim.kron.Kron) | PSGD com um pré-condicionador fatorado de Kronecker |
| `lamb`, `lambc`, `lambw`, `lambcw`, `lambcd`, `clamb`, `clambw` | [`Lamb`](#timm.optim.lamb.Lamb) | Momentos adaptativos por camada, variantes `trust_clip` (`lambc`, `lambcw`) |
| `laprop`, `lapropc`, `claprop` | [`LaProp`](#timm.optim.laprop.LaProp) | Momentum e adaptividade separados |
| `lars`, `larc`, `nlars`, `nlarc` | [`Lars`](#timm.optim.lars.Lars) | Escala adaptativa de taxa por camada, variantes `trust_clip` (`larc`, `nlarc`) |
| `lion`, `lionc`, `clion`, `clionc` | [`Lion`](#timm.optim.lion.Lion) | Momentum de sinal evoluído |
| `madgrad`, `madgradw` | [`MADGRAD`](#timm.optim.madgrad.MADGRAD) | Média dupla baseada em momento |
| `mars`, `cmars` | [`Mars`](#timm.optim.mars.Mars) | Redução de variância, atualização no estilo AdamW ou Lion |
| `muon`, `nmuon`, `adamuon`, `nadamuon` | [`Muon`](#timm.optim.muon.Muon) | Momento ortogonalizado Newton-Schulz para pesos 2D+, fallback AdamW / NAdamW para parâmetros 1D |
| `novograd`, `novogradw`, `novogradc` | [`NvNovoGrad`](#timm.optim.nvnovograd.NvNovoGrad) | Momentos normalizados por camada |
| `rmsproptf`, `rmsproptfw`, `rmsproptfc`, `crmsproptf` | [`RMSpropTF`](#timm.optim.rmsprop_tf.RMSpropTF) | Ordem das operações e tratamento de eps no TensorFlow, lr incorporado ao buffer de momentum |
| `sgdw`, `nesterovw`, `sgdc`, `csgdw`, `csgdc` | [`SGDW`](#timm.optim.sgdw.SGDW) | SGD com decaimento de peso desacoplado |
| `nadamlegacy`, `radamlegacy` | [`NAdamLegacy`](#timm.optim.nadam.NAdamLegacy), [`RAdamLegacy`](#timm.optim.radam.RAdamLegacy) | Implementações de referência, substituídas por `torch.optim` |
| `fused*`, `bnb*` | NVIDIA Apex, bitsandbytes | Registrado quando o pacote é instalado |

### Opções comuns

A maioria dos otimizadores do `timm` compartilha um conjunto de opções além dos habituais `lr`, `weight_decay`, `betas` e `eps`. É possível verificar quais otimizadores aceitam quais opções nas assinaturas de classe abaixo; a fábrica gera um erro para argumentos não suportados.

- **`caution`** aplica a máscara de atualização cautelosa, equivalente aos nomes de registro com o prefixo `c`.
- **`corrected_weight_decay`** escala o decaimento de peso desacoplado por `lr² / max_lr` em vez de `lr` (os nomes com sufixo `c`), de modo que o decaimento efetivo siga o agendamento da taxa de aprendizado. `max_lr` é a taxa de aprendizado com a qual o otimizador foi construído; construa-o com a taxa de pico do agendamento (como `train.py` faz). Ele é mantido em cada grupo de parâmetros (`max_lr_snapshot`) e salvo/restaurado junto com o estado do otimizador.
- **`decoupled_decay`** (ou `decoupled`) alterna otimizadores que por padrão usam decaimento L2 acoplado para o decaimento no estilo AdamW (os nomes com o sufixo `w`).
- **`foreach`** seleciona a implementação multi-tensor. Por padrão (`None`), ela é usada em CUDA e em outros dispositivos com kernels foreach, em conformidade com o `torch.optim`, a menos que não seja suportada pela configuração (um tensor `lr` sem `capturable`, ou `caution` em uma versão do PyTorch sem o overload `_foreach_maximum_` necessário). O passo multi-tensor é executado em blocos de parâmetros dimensionados de modo que o conjunto de trabalho de cada bloco permaneça no cache L2 da GPU, o que é mais rápido do que transmitir cada parâmetro pela memória uma vez por operação para modelos grandes. O tamanho do bloco é derivado do tamanho do cache L2 do dispositivo (PyTorch >= 2.5) e o processamento em blocos é ignorado em dispositivos onde o bloco resultante seria inferior a 4M elementos. `TIMM_FOREACH_CHUNK_SIZE=<elements>` substitui o tamanho do bloco, e `0` desativa o processamento em blocos.
- **`capturable`** (AdamWLegacy, NAdamW, Adopt, Muon) mantém a contagem de passos no dispositivo para que o passo possa ser capturado em um grafo CUDA. Todos os otimizadores aceitam um `lr` dado como um tensor de 0 dimensões, atualizado in place por um agendamento, para uso com `torch.compile` e grafos CUDA.
- **`clipping_threshold`** (AdamWLegacy, NAdamW, AdafactorBigVision) aplica clipping na atualização pelo seu RMS, `update / max(1, rms / threshold)` com `rms` sendo o RMS do gradiente normalizado pelo segundo momento, por tensor ([StableAdamW](https://arxiv.org/abs/2304.13013), Adafactor). `1.0` como nos artigos. Assim como no Adafactor, o weight decay (desacoplado) não é clipado, mas o StableAdamW também escala o decay pela taxa de aprendizado clipada.
- **`maximize`** maximiza o objetivo em vez de minimizá-lo.

Parâmetros de baixa precisão (`bfloat16`, `float16`) são suportados em todo o processo:

- **AdaBelief, RAdamLegacy and Adafactor** mantêm seu estado em `float32` para parâmetros de baixa precisão.
- **AdafactorBigVision** mantém seu momento em uma precisão reduzida (`momentum_dtype`).
- **Kron** possui opções separadas `mu_dtype` / `precond_dtype`.

Esses dtypes de estado são preservados por `load_state_dict` (o carregador padrão do PyTorch converte o estado para o dtype do parâmetro). As funções de passo evitam sincronizações com o host (ramificações Python dependentes de dados em tensores de dispositivo), sendo a verificação de projeção do AdamP / SGDP a exceção.

### Grupos de parâmetros

Quando fornecido um modelo, `create_optimizer_v2` agrupa os parâmetros com [`param_groups_weight_decay`](#timm.optim.param_groups_weight_decay) (sem decaimento para parâmetros 1D e o conjunto `no_weight_decay()` do modelo) ou, com `layer_decay` definido, [`param_groups_layer_decay`](#timm.optim.param_groups_layer_decay), que atribui uma escala de taxa de aprendizado de `layer_decay ** (num_layers - layer_id)` por camada usando o `group_matcher()` do modelo. Modelos sem um `group_matcher()` recorrem a [`auto_group_layers`](#timm.optim.auto_group_layers), que precisa do `pretrained_cfg['classifier']` do modelo para separar a cabeça. Para otimizadores híbridos (Muon), os argumentos `fallback_list` e `fallback_no_weight_decay` direcionam os parâmetros para o otimizador de fallback (AdamW).

## API

### Funções de fábrica[[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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/_optim_factory.py#L1242)

**Parâmetros:**

model_or_params : Um modelo do PyTorch ou um iterável de parâmetros/grupos de parâmetros. Se um modelo for fornecido, os parâmetros serão extraídos e agrupados automaticamente com base nos outros argumentos.

opt : Nome do otimizador a ser criado (por exemplo, 'adam', 'adamw', 'sgd'). Use list_optimizers() para ver as opções disponíveis.

lr : Taxa de aprendizado. Se for None, será usado o padrão do otimizador.

weight_decay : Fator de decaimento de peso. Será usado para criar grupos de parâmetros se model_or_params for um modelo.

momentum : Fator de momentum para otimizadores que o suportam. Usado apenas se o otimizador escolhido aceitar um parâmetro de momentum.

foreach : Ativa/desativa a implementação foreach (multi-tensor), se disponível. Se for None, usará os padrões específicos do otimizador.

filter_bias_and_bn : Se True, os parâmetros de camadas de bias e norm (todos os parâmetros 1d) não terão weight decay aplicado. Usado apenas quando model_or_params é um modelo e weight_decay > 0.

fallback_list : Coleção de padrões de nomes de parâmetros para usar o otimizador de fallback em otimizadores híbridos (por exemplo, AdamW para Muon). Suporta correspondência com curingas.

fallback_no_weight_decay : Se True, os parâmetros na lista no_weight_decay() do modelo usarão o otimizador de fallback para otimizadores híbridos (por exemplo, AdamW para Muon).

layer_decay : Fator opcional de decaimento da taxa de aprendizado por camada. Se fornecido, as taxas de aprendizado serão escalonadas por layer_decay^(max_depth - layer_depth). Usado apenas quando model_or_params é um modelo.

param_group_fn : Função opcional para criar grupos de parâmetros personalizados. Se fornecida, as outras opções de agrupamento de parâmetros serão ignoradas.

- ****kwargs** : Argumentos adicionais específicos do otimizador (por exemplo, betas para Adam).

**Retorna:**

Instância do otimizador configurada.

Crie uma instância de otimizador via registro do timm.

Cria e configura um otimizador com grupos de parâmetros e configurações apropriados. Suporta a criação automática de grupos de parâmetros para decaimento de peso e taxas de aprendizado por camada, bem como a agrupamento personalizado de parâmetros.

Exemplos:

Ao usar AdamW a partir de um modelo, os grupos de parâmetros são criados automaticamente:

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

SGD com momentum e decaimento de peso:

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

Adam com decaimento da taxa de aprendizado por camada:

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

Grupos de parâmetros personalizados:

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

Observação: precedência do tratamento de grupos de parâmetros:
1. Se param_group_fn for fornecido, ele será usado exclusivamente
2. Se layer_decay for fornecido, grupos por camada serão criados
3. Se weight_decay > 0 e filter_bias_and_bn for True, os grupos de decaimento de peso serão criados
4. Caso contrário, todos os parâmetros ficarão em um único grupo

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/_optim_factory.py#L1137)

**Parâmetros:**

filter : String de filtro em estilo curinga ou lista de strings de filtro (por exemplo, 'adam*' para todas as variantes do Adam, ou ['adam*', '*8bit'] para variantes do Adam e otimizadores de 8 bits). String vazia significa sem filtragem.

exclude_filters : Lista opcional de padrões curinga para exclusão. Por exemplo, ['*8bit', 'fused*'] excluiria as implementações de 8 bits e fundidas.

with_description : Se True, retorna tuplas de (name, description) em vez de apenas nomes. As descrições fornecem explicações breves sobre as características do otimizador.

**Retorna:** `If with_description is False`

Lista de nomes de otimizadores como strings (por exemplo, ['adam', 'adamw', ...]) Se with_description for True: Lista de tuplas de (name, description) (por exemplo, [('adam', 'Adaptive Moment...'), ...])

Liste os nomes de otimizadores disponíveis, opcionalmente filtrados.

Liste todos os otimizadores registrados, com filtragem opcional usando padrões curinga. Os otimizadores podem ser filtrados usando padrões de inclusão e exclusão e podem, opcionalmente, retornar descrições junto com cada nome de otimizador.

Exemplos:

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/_optim_factory.py#L1200)

**Parâmetros:**

name : Nome do otimizador a ser recuperado (ex.: 'adam', 'sgd')

bind_defaults : Se True, retorna uma função parcial com argumentos padrão vinculados de OptimInfo. Se False, retorna a classe de otimizador bruta.

**Retorna:** `If bind_defaults is False`

A classe do otimizador (por exemplo, torch.optim.Adam) Se bind_defaults for True: uma função parcial com argumentos padrão vinculados

**Exceções:** ``ValueError``

- ``ValueError`` -- Se o nome do otimizador não for encontrado no registro

Obtém a classe do otimizador pelo nome, com a opção de vincular argumentos padrão.

Recupera a classe do otimizador ou uma função parcial com argumentos padrão vinculados. Isso permite a instanciação direta de otimizadores com suas configurações padrão, sem passar pela fábrica completa.

Exemplos:

Com os padrões do registro vinculados, `sgd` tem o momento nesterov habilitado:

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

A classe de otimizador bruta:

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/_optim_factory.py#L1185)

**Parâmetros:**

name : Nome do otimizador

**Retorna:**

Configuração do OptimInfo

**Exceções:** ``ValueError``

- ``ValueError`` -- Se o otimizador não for encontrado

Obtenha o OptimInfo para um otimizador.

### Funções de grupo de parâmetros[[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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/_param_groups.py#L113)

Grupos de parâmetros para decaimento de lr por camada & decaimento de peso Baseado no 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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/_param_groups.py#L84)

### Classes de Otimizador[[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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adabelief.py#L13)

**Parâmetros:**

params (iterável): iterável de parâmetros a otimizar ou dicionários definindo grupos de parâmetros

lr (float, opcional) : taxa de aprendizado (padrão: 1e-3)

betas (Tuple[float, float], opcional) : coeficientes usados para calcular as médias móveis do gradiente e seu quadrado (padrão: (0.9, 0.999))

eps (float, opcional) : termo adicionado ao denominador para melhorar a estabilidade numérica (padrão: 1e-16)

weight_decay (float, opcional) : decaimento de peso (penalidade L2) (padrão: 0)

amsgrad (boolean, opcional) : se deve usar a variante AMSGrad deste algoritmo do artigo `On the Convergence of Adam and Beyond`_ (padrão: False)

decoupled_decay (boolean, opcional) : (padrão: True) Se definido como True, o otimizador usa decaimento de peso desacoplado, como no AdamW

fixed_decay (boolean, opcional) : (padrão: False) Isso é usado quando weight_decouple é definido como True. Quando fixed_decay == True, o decaimento de peso é realizado como $W_{new} = W_{old} - W_{old} \times decay$. Quando fixed_decay == False, o decaimento de peso é realizado como $W_{new} = W_{old} - W_{old} \times decay \times lr$. Observe que, nesse caso, a taxa de decaimento de peso diminui com a taxa de aprendizado (lr).

rectify (boolean, opcional) : (padrão: True) Se definido como True, executa a atualização corrigida semelhante à do RAdam

degenerated_to_sgd (boolean, opcional) (padrão --True) Se definido como True, executa a atualização do SGD quando a variância do gradiente é alta

foreach (boolean, opcional) : use a implementação foreach (multi-tensor), por padrão (None) é usado, a menos que não seja suportado

Implementa o algoritmo AdaBelief. Modificado a partir do Adam no PyTorch

referência: AdaBelief Optimizer, adaptando tamanhos de passo pela crença nos gradientes observados, NeurIPS 2020

Para uma tabela completa de hiperparâmetros recomendados, consulte https://github.com/juntang-zhuang/Adabelief-Optimizer' Por exemplo, para os argumentos de treinamento da EfficientNet, veja estes gists
- link para train_script: https://gist.github.com/juntang-zhuang/0a501dd51c02278d952cf159bc233037
- link para args.yaml: https://gist.github.com/juntang-zhuang/517ce3c27022b908bb93f78e4f786dc3

#### etapa[[timm.optim.AdaBelief.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adabelief.py#L121)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adafactor.py#L22)

Implementa o algoritmo Adafactor.

Esta implementação é baseada em: `Adafactor: Adaptive Learning Rates with Sublinear Memory Cost` (veja https://arxiv.org/abs/1804.04235)

Observe que este otimizador ajusta internamente a taxa de aprendizado com base nas opções *scale_parameter*, *relative_step* e *warmup_init*.

Um agendamento manual (externo) de taxa de aprendizado é usado quando `lr` é definido (`relative_step` passa a ser False). Observe que, nesta implementação, `scale_parameter` e `warmup_init` se aplicam apenas à taxa de aprendizado de passo relativo (`lr=None`); diferentemente do fairseq / HF Transformers, a escalação do RMS do parâmetro não é aplicada a uma taxa de aprendizado externa.

Ags: params: iterável de parâmetros a serem otimizados ou dicionários definindo grupos de parâmetros lr: taxa de aprendizado externa eps: constantes de regularização para o gradiente quadrático e a escala do parâmetro, respectivamente eps_scale: constantes de regularização para a escala do parâmetro, respectivamente clip_threshold: limiar da raiz quadrada da média quadrática da atualização final do gradiente decay_rate: coeficiente usado para calcular as médias móveis do gradiente quadrático beta1: coeficiente usado para calcular as médias móveis do gradiente weight_decay: decaimento do peso scale_parameter: se True, a taxa de aprendizado do passo relativo é escalada pela raiz quadrada da média quadrática do parâmetro warmup_init: o cálculo da taxa de aprendizado dependente do tempo depende de se a inicialização de aquecimento está sendo usada

#### etapa[[timm.optim.Adafactor.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adafactor.py#L140)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adafactor_bv.py#L49)

Implementação em PyTorch da variante Adafactor do BigVision, com implementações de tensor único e múltiplos tensores.

Adaptado de https://github.com/google-research/big_vision por Ross Wightman

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adahessian.py#L9)

**Parâmetros:**

params (iterável): iterável de parâmetros a otimizar ou dicionários definindo grupos de parâmetros

lr (float, opcional) : taxa de aprendizado (padrão: 0.1)

betas ((float, float), opcional) : coeficientes usados para calcular as médias móveis do gradiente e do traço do hessiano ao quadrado (padrão: (0.9, 0.999))

eps (float, opcional) : termo adicionado ao denominador para melhorar a estabilidade numérica (padrão: 1e-8)

weight_decay (float, opcional) : decaimento de peso (penalidade L2) (padrão: 0.0)

hessian_power (float, opcional) : expoente do traço da hessiana (padrão: 1.0)

update_each (int, opcional) : calcula a aproximação do traço da hessiana apenas após *este* número de passos (para economizar tempo) (padrão: 1)

n_samples (int, opcional) : quantas vezes amostrar `z` para a aproximação do traço da hessiana (padrão: 1)

Implementa o algoritmo AdaHessian de "ADAHESSIAN: Um otimizador de segunda ordem adaptativo para aprendizado de máquina"

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

```python
get_params()
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adahessian.py#L74)

Obtém todos os parâmetros em todos os param_groups com gradientes

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

```python
set_hessian()
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adahessian.py#L90)

Calcula a aproximação de Hutchinson do traço da hessiana e a acumula para cada parâmetro treinável.

#### etapa[[timm.optim.Adahessian.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adahessian.py#L119)

**Parâmetros:**

closure (callable, opcional) : um closure que reavalia o modelo e retorna a perda (padrão -- None)

Executa um único passo de otimização.

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

```python
zero_hessian()
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adahessian.py#L81)

Zera os traços da hessiana acumulada.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adamw.py#L23)

**Parâmetros:**

params : iterável de parâmetros a serem otimizados ou dicionários definindo grupos de parâmetros

lr : taxa de aprendizado

betas : coeficientes usados para calcular as médias móveis do gradiente e do seu quadrado

eps : termo adicionado ao denominador para melhorar a estabilidade numérica

weight_decay : coeficiente de decaimento de peso

amsgrad : se deve usar a variante AMSGrad deste algoritmo do artigo `On the Convergence of Adam and Beyond`

caution : tenha cautela ao usar AdamW

corrected_weight_decay : aplicar decaimento de peso corrigido (lr**2 / max_lr)

maximize : maximize os parâmetros com base no objetivo, em vez de minimizá-los

foreach : se a implementação foreach do otimizador é utilizada. Se não for especificado pelo usuário (ou seja, se foreach for None), tentaremos usar foreach em vez da implementação com loop for na CUDA, pois é mais rápida em geral.

capturable : se esta instância é segura para captura em um gráfico CUDA. Passar True pode prejudicar o desempenho sem captura de gráfico, portanto, se você não pretende capturar esta instância em um gráfico, deixe como False

clipping_threshold : limiar de recorte para a atualização RMS (StableAdamW, https://arxiv.org/abs/2304.13013), a atualização é escalonada por 1 / max(1, rms / clipping_threshold), onde rms é o RMS de grad / (sqrt(v_hat) + eps). Atenua a atualização de parâmetros com um aumento súbito do gradiente em relação à sua estimativa de segundo momento. 1.0, conforme o artigo; None (padrão) desativa. Assim como no Adafactor, o decaimento de peso desacoplado não é recortado (o StableAdamW também escala o decaimento pelo lr recortado).

Implementa o algoritmo AdamW.

OBSERVAÇÃO: Esta implementação foi descontinuada em favor de torch.optim.AdamW e permanece como referência

Referências:
- Adam: A Method for Stochastic Optimization: https://arxiv.org/abs/1412.6980
- Regularização de decaimento de peso desacoplado: https://arxiv.org/abs/1711.05101
- Sobre a Convergência do Adam e Além: https://openreview.net/forum?id=ryQu7f-RZ

#### etapa[[timm.optim.AdamWLegacy.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adamw.py#L116)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adan.py#L48)

**Parâmetros:**

params : Iterável de parâmetros a serem otimizados ou dicionários definindo grupos de parâmetros.

lr : Taxa de aprendizado.

betas : Coeficientes usados para os momentos de primeira e segunda ordem.

eps : Termo adicionado ao denominador para melhorar a estabilidade numérica.

weight_decay : Decaimento de peso desacoplado (penalidade L2)

no_prox : Como executar o decaimento de peso

caution : Ative a cautela dos 'Cautious Optimizers'

foreach : Se True, usará a implementação torch._foreach. Mais rápido, mas usa um pouco mais de memória.

Implementa uma variante do Adan em pytorch.

Adan foi proposto em Adan: Adaptive Nesterov Momentum Algorithm for Faster Optimizing Deep Models https://arxiv.org/abs/2208.06677

#### etapa[[timm.optim.Adan.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adan.py#L119)

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adopt.py#L60)

ADOPT: Adam Modificado Pode Convergir com Qualquer β2 com a Taxa Ótima: https://arxiv.org/abs/2411.02853

#### etapa[[timm.optim.Adopt.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/adopt.py#L197)

**Parâmetros:**

closure (Callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Execute um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/kron.py#L82)

**Parâmetros:**

params : Iterável de parâmetros a serem otimizados ou dicionários definindo grupos de parâmetros.

lr : Taxa de aprendizado.

momentum : Parâmetro de momentum.

weight_decay : Decaimento de peso.

preconditioner_update_probability : Probabilidade de atualizar o pré-condicionador. Se None, o padrão é um agendamento que faz o resfriamento de 1.0 para 0.03 em 4000 passos.

max_size_triangular : Tamanho máximo para o pré-condicionador da dimensão ser triangular.

min_ndim_triangular : Número mínimo de dimensões que uma camada precisa ter para ter precondicionadores triangulares.

memory_save_mode : 'one_diag', 'smart_one_diag' ou 'all_diag', None é o padrão para definir todos os pré-condicionadores como triangulares, 'one_diag' define a maior ou última dimensão como diagonal por camada, e 'all_diag' define todos os pré-condicionadores como diagonais.

momentum_into_precond_update : se deve enviar o momento para a atualização do pré-condicionador em vez dos gradientes brutos.

mu_dtype : Tipo de dados do acumulador de momento.

precond_dtype : Tipo de dados do pré-condicionador.

decoupled_decay : decaimento de peso desacoplado no estilo AdamW

corrected_weight_decay : aplicar o decaimento de peso corrigido ao usar decoupled_decay (lr**2 / max_lr)

flatten : Achatar dimensões em vez de depender totalmente de expressões para parâmetros de rank superior

flatten_start_dim : Início do intervalo de achatamento, padrão é 2. Parece ser um bom compromisso para redes convolucionais.

flatten_end_dim : Fim do intervalo de flatten, padrão é -1.

stochastic_weight_decay : Ativar modulação aleatória do decaimento de peso

deterministic : Comportamento determinístico entre salvar / carregar (retomar). FIXME lento, precisa de trabalho

Implementa o PSGD Kron de 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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/lamb.py#L71)

**Parâmetros:**

params : Iterável de parâmetros a serem otimizados ou dicionários definindo grupos de parâmetros.

lr : Taxa de aprendizado

betas : Coeficientes usados para calcular as médias móveis do gradiente e sua norma.

eps : Termo adicionado ao denominador para melhorar a estabilidade numérica.

weight_decay : Decaimento de peso

grad_averaging : Se aplica (1-beta2) ao grad ao calcular as médias móveis do grad.

max_grad_norm : Valor usado para limitar a norma global do gradiente.

trust_clip : Ativar o recorte da razão de confiança do LAMBC.

always_adapt : Aplique a taxa de aprendizado adaptativa ao parâmetro de decaimento de peso 0.0.

caution : Aplique cautela.

decoupled : aplicar decaimento de peso desacoplado

corrected_weight_decay : aplicar decaimento de peso corrigido (lr**2 / max_lr) ao usar decoupled_decay

foreach : use a implementação foreach (multi-tensor), por padrão (None) usado, a menos que não seja suportado

Implementa uma variante pura em PyTorch do otimizador FuseLAMB (variante NvLamb) a partir de apex.optimizers.FusedLAMB referência: https://github.com/NVIDIA/DeepLearningExamples/blob/master/PyTorch/LanguageModeling/Transformer-XL/pytorch/lamb.py

O LAMB foi proposto em:
- Otimização de Lote Grande para Aprendizado Profundo - Treinando BERT em 76 minutos: https://arxiv.org/abs/1904.00962
- Sobre a Convergência do Adam e Além: https://openreview.net/forum?id=ryQu7f-RZ

#### etapa[[timm.optim.Lamb.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/lamb.py#L169)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/laprop.py#L32)

**Parâmetros:**

foreach : use a implementação foreach (multi-tensor), por padrão (None) usado, a menos que não seja suportado (veja laprop())

Otimizador LaProp

Artigo: LaProp: Separating Momentum and Adaptivity in Adam, https://arxiv.org/abs/2002.04839

#### etapa[[timm.optim.LaProp.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/laprop.py#L106)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/lars.py#L22)

**Parâmetros:**

params (iterável) : iterável de parâmetros a otimizar ou dicionários definindo grupos de parâmetros.

lr (float, opcional) : taxa de aprendizado (padrão: 1.0).

momentum (float, opcional) : fator de momentum (padrão: 0)

weight_decay (float, opcional) : decaimento de peso (penalidade L2) (padrão: 0)

dampening (float, opcional) : amortecimento para o momentum (padrão: 0)

nesterov (bool, opcional) : habilita o momento de Nesterov (padrão: False)

trust_coeff (float) : coeficiente de confiança para o cálculo do lr adaptativo / trust_ratio (padrão: 0.001)

eps (float) : eps para o denominador da divisão (padrão: 1e-8)

trust_clip (bool) : habilita o recorte da razão de confiança do LARC (padrão: False)

always_adapt (bool) : sempre aplicar a adaptação de LR do LARS, caso contrário, apenas quando group weight_decay != 0 (padrão: False)

foreach (bool, opcional) : use a implementação foreach (multi-tensor), por padrão (None) é usado, a menos que não seja suportado

LARS para PyTorch

Artigo: `Large batch training of Convolutional Networks` - https://arxiv.org/pdf/1708.03888.pdf

#### etapa[[timm.optim.Lars.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/lars.py#L84)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/lion.py#L34)

Implementa o algoritmo Lion.

#### etapa[[timm.optim.Lion.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/lion.py#L86)

**Parâmetros:**

closure : Um closure que reavalia o modelo e retorna a perda.

**Retorna:**

a perda.

Executa um único passo de otimização.

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

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/madgrad.py#L24)

**Parâmetros:**

params (iterável) : Iterável de parâmetros a serem otimizados ou dicionários definindo grupos de parâmetros.

lr (float) : Taxa de aprendizado (padrão: 1e-2).

momentum (float) : Valor do momentum no intervalo [0,1) (padrão: 0.9).

weight_decay (float) : decaimento de peso, ou seja, uma penalidade L2 (padrão: 0).

eps (float) : Termo adicionado ao denominador, fora da operação de raiz, para melhorar a estabilidade numérica. (padrão: 1e-6).

MADGRAD_: Um Método de Gradiente com Momento, Adaptativo e Média Dual para Otimização Estocástica.

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

MADGRAD é um otimizador de uso geral que pode ser usado no lugar de SGD ou Adam, podendo convergir mais rápido e generalizar melhor. Atualmente, apenas para GPU. Tipicamente, o mesmo cronograma de taxa de aprendizado usado para SGD ou Adam pode ser utilizado. A taxa de aprendizado geral não é comparável a nenhum dos dois métodos e deve ser determinada por uma varredura de hiperparâmetros.

MADGRAD requer menos decaimento de peso do que outros métodos, muitas vezes tão pouco quanto zero. Os valores de momento usados para SGD ou beta1 do Adam devem funcionar aqui também.

Em problemas esparsos, tanto weight_decay quanto momentum devem ser definidos como 0.

#### etapa[[timm.optim.MADGRAD.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/madgrad.py#L90)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/mars.py#L90)

Otimizador MARS

Artigo: MARS: Liberando o poder da redução de variância para o treinamento de modelos grandes https://arxiv.org/abs/2411.10438

#### etapa[[timm.optim.Mars.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/mars.py#L140)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/muon.py#L654)

Muon - MomentUm Ortogonalizado por Newton-schulz

Combina Muon para parâmetros 2D+ (matrizes de pesos) com AdamW para parâmetros 1D (viés, normalizações) e grupos de parâmetros com 'use_fallback=True' definido (ou 'use_muon=False' para compatibilidade).

Suporta dois algoritmos:
- "muon": Algoritmo Muon padrão com momentum + ortogonalização
- "adamuon": algoritmo AdaMuon que adiciona estimativa de segundo momento elemento a elemento a direções ortogonalizadas para escalonamento adaptativo semelhante ao do Adam

#### etapa[[timm.optim.Muon.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/muon.py#L798)

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/nadam.py#L7)

**Parâmetros:**

params (iterável): iterável de parâmetros a otimizar ou dicionários definindo grupos de parâmetros

lr (float, opcional) : taxa de aprendizado (padrão: 2e-3)

betas (Tuple[float, float], opcional) : coeficientes usados para calcular as médias móveis do gradiente e do seu quadrado

eps (float, opcional) : termo adicionado ao denominador para melhorar a estabilidade numérica (padrão: 1e-8)

weight_decay (float, opcional) : decaimento de peso (penalidade L2) (padrão: 0)

schedule_decay (float, opcional) : decaimento do agendamento de momentum (padrão: 4e-3)

Implementa o algoritmo Nadam (uma variante do Adam baseada no momento de Nesterov).

OBSERVAÇÃO: Esta implementação foi descontinuada em favor de torch.optim.NAdam e permanece como referência

Foi proposto em `Incorporating Nesterov Momentum into Adam`__.

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

Originalmente obtido de: https://github.com/pytorch/pytorch/pull/1408 OBSERVAÇÃO: Tem potenciais problemas, mas funciona bem em alguns problemas.

#### etapa[[timm.optim.NAdamLegacy.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/nadam.py#L52)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/nadamw.py#L25)

**Parâmetros:**

params : iterável de parâmetros a serem otimizados ou dicionários definindo grupos de parâmetros

lr : taxa de aprendizado

betas : coeficientes usados para calcular as médias móveis do gradiente e do seu quadrado

eps : termo adicionado ao denominador para melhorar a estabilidade numérica

weight_decay : coeficiente de decaimento de peso

caution : ativar cautela

corrected_weight_decay : aplicar decaimento de peso corrigido (lr**2 / max_lr)

maximize : maximize os parâmetros com base no objetivo, em vez de minimizá-los

foreach : se a implementação foreach do otimizador é utilizada. Se não especificado (None), a implementação foreach é usada em CUDA (dispositivos com kernels foreach), pois é mais rápida em geral.

capturable : se esta instância é segura para ser capturada em um gráfico CUDA

clipping_threshold : limiar de recorte para a atualização RMS (StableAdamW, https://arxiv.org/abs/2304.13013), a atualização é escalonada por 1 / max(1, rms / clipping_threshold), onde rms é o RMS de grad / (sqrt(v_hat) + eps). Atenua a atualização de parâmetros com um aumento súbito do gradiente em relação à sua estimativa de segundo momento. 1.0, conforme o artigo; None (padrão) desativa. Assim como no Adafactor, o decaimento de peso desacoplado não é recortado (o StableAdamW também escala o decaimento pelo lr recortado).

Implementa o algoritmo NAdamW.

Veja a Tabela 1 em https://arxiv.org/abs/1910.05446 para a implementação do algoritmo NAdam (há também um comentário no código que destaca a única diferença entre NAdamW e AdamW).

Para mais detalhes sobre o algoritmo, remetemos a
- Regularização de decaimento de peso desacoplado: https://arxiv.org/abs/1711.05101
- Sobre a Convergência do Adam e Além: https://openreview.net/forum?id=ryQu7f-RZ

#### etapa[[timm.optim.NAdamW.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/nadamw.py#L113)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/nvnovograd.py#L17)

**Parâmetros:**

params (iterável): iterável de parâmetros a otimizar ou dicionários definindo grupos de parâmetros

lr (float, opcional) : taxa de aprendizado (padrão: 1e-3)

betas (Tuple[float, float], opcional) : coeficientes usados para calcular as médias móveis do gradiente e seu quadrado (padrão: (0.95, 0.98))

eps (float, opcional) : termo adicionado ao denominador para melhorar a estabilidade numérica (padrão: 1e-8)

weight_decay (float, opcional) : decaimento de peso (penalidade L2) (padrão: 0)

grad_averaging : média de gradientes

amsgrad (boolean, opcional) : se deve usar a variante AMSGrad deste algoritmo do artigo `On the Convergence of Adam and Beyond`_ (padrão: False)

decoupled_decay : aplicar o decaimento de peso diretamente aos pesos (lr * weight_decay por passo) em vez de adicioná-lo ao gradiente normalizado antes da atualização do momento (conforme o artigo)

corrected_weight_decay : aplicar decaimento de peso corrigido (lr**2 / max_lr) quando decoupled_decay é True

Implementa o algoritmo Novograd.

#### etapa[[timm.optim.NvNovoGrad.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/nvnovograd.py#L90)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo

e retorna a perda. --

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/radam.py#L16)

Otimizador RAdam do PyTorch

OBSERVAÇÃO: Esta implementação foi descontinuada em favor de torch.optim.AdamW e permanece como referência

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/rmsprop_tf.py#L27)

**Parâmetros:**

params : iterável de parâmetros a serem otimizados ou dicionários definindo grupos de parâmetros

lr : taxa de aprendizado

momentum : fator de momentum

alpha : constante de suavização (decaimento)

eps : termo adicionado ao denominador para melhorar a estabilidade numérica

centered : se `True`, calcula o RMSProp centralizado, o gradiente é normalizado por uma estimativa de sua variância

weight_decay : decaimento de peso (penalidade L2) (padrão: 0)

decoupled_decay : decaimento de peso desacoplado, conforme descrito em https://arxiv.org/abs/1711.05101

corrected_weight_decay : aplicar decaimento de peso corrigido (lr**2 / max_lr) quando decoupled_decay é True

lr_in_momentum : a escalação da taxa de aprendizado está incluída na atualização do buffer de momento, conforme os padrões no Tensorflow

caution : aplicar cautela

foreach : use a implementação foreach (multi-tensor), por padrão (None) usado, a menos que não seja suportado (veja rmsprop_tf())

Implementa o algoritmo RMSprop (epsilon no estilo TensorFlow)

OBSERVAÇÃO: Este é um recorte e colagem direta do RMSprop do PyTorch com eps aplicado antes da raiz quadrada e algumas outras modificações para corresponder mais de perto ao Tensorflow para corresponder aos hiperparâmetros.

As alterações notáveis incluem:
1. Epsilon aplicado dentro da raiz quadrada
2. square_avg inicializado com uns
3. Escalação de LR da atualização acumulada no buffer de momentum

Proposto por G. Hinton em seu [curso](http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf).

A versão centralizada aparece pela primeira vez em [Generating Sequences With Recurrent Neural Networks](https://arxiv.org/pdf/1308.0850v5.pdf).

#### etapa[[timm.optim.RMSpropTF.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/rmsprop_tf.py#L112)

**Parâmetros:**

closure (callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/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)
```

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/sgdw.py#L26)

#### etapa[[timm.optim.SGDW.step]]

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

[Fonte](https://github.com/huggingface/pytorch-image-models/blob/main/timm/optim/sgdw.py#L98)

**Parâmetros:**

closure (Callable, opcional) : Um closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.