Hugging Face's logo

timm documentation

Otimização

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v1.0.31).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Otimização

Esta página contém a documentação de referência da API dos otimizadores incluídos em timm, bem como 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. 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.

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:

ModificadorSignificadoExemplos
prefixo cVariante cautelosa, a atualização é mascarada onde seu sinal diverge do gradiente (Cautious Optimizers)cadamw, clion, cmars, cadopt
sufixo wDecaimento de peso desacoplado (estilo AdamW), para otimizadores que por padrão utilizam decaimento L2 acopladosgdw, lambw, adoptw, novogradw, rmsproptfw
sufixo cDecaimento 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)adamc, nadamc, sgdc, lionc, adoptc, kronc
prefixo nMomentum de Nesterov (famílias SGD, LARS e Muon)nesterov, nlars, nmuon, nadamuon
prefixo lookahead_Envolva o otimizador em Lookaheadlookahead_adamw
prefixo fusedImplementação fundida da NVIDIA Apex (requer apex)fusedadamw, fusedlamb
prefixo bnbimplementaçã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

NomesImplementaçãoObservações
adamw, adam, nadam, radam, radamw, adamax, adadelta, adagrad, rmsprop, sgd, momentum, nesterovtorch.optim
adamwlegacy, adamc, cadamw, cadamcAdamWLegacyAdamW com cautela, decaimento corrigido, recorte de atualização, capturable
nadamw, nadamc, cnadamw, cnadamcNAdamWAdamW com momento de Nesterov (forma de eficiência algorítmica do MLCommons)
adopt, adoptw, adoptc, cadopt, cadoptw, cadoptcAdoptVariante do Adam que converge para qualquer β2
adan, adanw, cadan, cadanwAdanMomentum adaptativo de Nesterov
adabelief, radabeliefAdaBeliefradabelief adiciona retificação no estilo RAdam
adafactor, cadafactorAdafactorfairseq Adafactor, tamanho relativo do passo quando lr=None
adafactorbv, adafactorbvc, cadafactorbv, cadafactorbvcAdafactorBigVisionBig Vision Adafactor, momentos de segunda ordem fatorados, momento de baixa precisão, recorte de atualização
adamp, cadamp, sgdp, csgdpAdamP, SGDPProjeção da atualização para pesos invariantes em relação à escala
adahessianAdahessianSegunda ordem, requer um closure (is_second_order)
kron, kronw, kroncKronPSGD com um pré-condicionador fatorado de Kronecker
lamb, lambc, lambw, lambcw, lambcd, clamb, clambwLambMomentos adaptativos por camada, variantes trust_clip (lambc, lambcw)
laprop, lapropc, clapropLaPropMomentum e adaptividade separados
lars, larc, nlars, nlarcLarsEscala adaptativa de taxa por camada, variantes trust_clip (larc, nlarc)
lion, lionc, clion, clioncLionMomentum de sinal evoluído
madgrad, madgradwMADGRADMédia dupla baseada em momento
mars, cmarsMarsRedução de variância, atualização no estilo AdamW ou Lion
muon, nmuon, adamuon, nadamuonMuonMomento ortogonalizado Newton-Schulz para pesos 2D+, fallback AdamW / NAdamW para parâmetros 1D
novograd, novogradw, novogradcNvNovoGradMomentos normalizados por camada
rmsproptf, rmsproptfw, rmsproptfc, crmsproptfRMSpropTFOrdem das operações e tratamento de eps no TensorFlow, lr incorporado ao buffer de momentum
sgdw, nesterovw, sgdc, csgdw, csgdcSGDWSGD com decaimento de peso desacoplado
nadamlegacy, radamlegacyNAdamLegacy, RAdamLegacyImplementações de referência, substituídas por torch.optim
fused*, bnb*NVIDIA Apex, bitsandbytesRegistrado 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. Quais otimizadores aceitam quais opções pode ser verificado 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 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 particionamento 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 particionamento 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, Adafactor). 1.0 como nos artigos. Assim como no Adafactor, o weight decay (decoupled) 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 (sem decaimento para parâmetros 1D e o conjunto no_weight_decay() do modelo) ou, com layer_decay definido, 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 group_matcher() recorrem a 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

< >

( model_or_params: typing.Union[torch.nn.Module, torch.optim.optimizer.ParamsT]opt: str = 'sgd'lr: typing.Optional[float] = Noneweight_decay: float = 0.0momentum: float = 0.9foreach: typing.Optional[bool] = Nonefilter_bias_and_bn: bool = Truefallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = Falselayer_decay: typing.Optional[float] = Nonelayer_decay_min_scale: float = 0.0layer_decay_no_opt_scale: typing.Optional[float] = Noneparam_group_fn: typing.Optional[typing.Callable[[torch.nn.Module], torch.optim.optimizer.ParamsT]] = None**kwargs: typing.Any )

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 o parâmetro 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 bias e das camadas de normalização (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).

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 weight decay e taxas de aprendizado por camada, bem como a agrupação personalizada de parâmetros.

Exemplos:

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

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

SGD com momentum e decaimento de peso:

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:

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

Grupos de parâmetros personalizados:

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: Prioridade 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

< >

( filter: typing.Union[str, typing.List[str]] = ''exclude_filters: typing.Optional[typing.List[str]] = Nonewith_description: bool = False ) → If with_description is False

Parâmetros

  • filter — String de filtro no estilo curinga ou lista de strings de filtro (por exemplo, ‘adam’ para todas as variantes de Adam, ou [‘adam’, ‘*8bit’] para variantes de 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

Se with_description for 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 include e exclude, e podem opcionalmente retornar descrições com cada nome de otimizador.

Exemplos:

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

< >

( name: strbind_defaults: bool = True ) → If bind_defaults is False

Parâmetros

  • name — Nome do otimizador a ser recuperado (ex.: ‘adam’, ‘sgd’)
  • bind_defaults — Se True, retorna uma função parcial com os argumentos padrão de OptimInfo vinculados. Se False, retorna a classe de otimizador bruta.

Retorna

Se bind_defaults for 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:

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

A classe de otimizador bruta:

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

< >

( name: str )

Parâmetros

  • name — Nome do otimizador

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

< >

( model: Moduleweight_decay: typing.Optional[float] = 1e-05weight_decay_exclude_1d: bool = Trueno_weight_decay_list: typing.Collection[str] = ()fallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = False )

timm.optim.param_groups_layer_decay

< >

( model: Moduleweight_decay: float = 0.05no_weight_decay_list: typing.Collection[str] = ()fallback_list: typing.Collection[str] = ()fallback_no_weight_decay: bool = Falseweight_decay_exclude_1d: bool = Truelayer_decay: float = 0.75min_scale: float = 0.0no_opt_scale: typing.Optional[float] = Noneverbose: bool = False )

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

< >

( modellayers_per_group = 12num_groups = None )

Classes de Otimizador

classe timm.optim.AdaBelief

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-16weight_decay = 0amsgrad = Falsedecoupled_decay = Truefixed_decay = Falserectify = Truedegenerated_to_sgd = Trueforeach: typing.Optional[bool] = None )

Parâmetros

  • params (iterável) — iterável de parâmetros a serem otimizados 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 weightdecouple é definido como True. Quando fixed_decay == True, o decaimento de peso é realizado como $W{new} = W{old} - W{old} \times decay$. Quando fixeddecay == 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 retificada semelhante à do RAdam
  • degenerated_to_sgd (boolean, opcional) (padrão —True) Se definido como True, executa a atualização por SGD quando a variância do gradiente é alta
  • foreach (boolean, opcional) — usa 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 do EfficientNet, consulte estes gists

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.Adafactor

< >

( params: ParamsTlr: typing.Optional[float] = Noneeps: float = 1e-30eps_scale: float = 0.001clip_threshold: float = 1.0decay_rate: float = -0.8betas: typing.Optional[typing.Tuple[float, float]] = Noneweight_decay: float = 0.0scale_parameter: bool = Truewarmup_init: bool = Falsemin_dim_size_to_factor: int = 16caution: bool = False )

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 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 de 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

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.AdafactorBigVision

< >

( params: ParamsTlr: float = 1.0min_dim_size_to_factor: int = 16decay_rate: float = 0.8decay_offset: int = 0beta2_cap: float = 0.999momentum: typing.Optional[float] = 0.9momentum_dtype: typing.Union[str, torch.dtype] = torch.bfloat16eps: typing.Optional[float] = Noneweight_decay: float = 0.0clipping_threshold: typing.Optional[float] = Noneunscaled_wd: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = False )

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

classe timm.optim.Adahessian

< >

( paramslr = 0.1betas = (0.9, 0.999)eps = 1e-08weight_decay = 0.0hessian_power = 1.0update_each = 1n_samples = 1avg_conv_kernel = False )

Parâmetros

  • params (iterável) — iterável de parâmetros a serem otimizados 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 a cada 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

< >

( )

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

set_hessian

< >

( )

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

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — uma closure que reavalia o modelo e retorna a perda (padrão — None)

Executa um único passo de otimização.

zero_hessian

< >

( )

Zera os traços da hessiana acumulada.

classe timm.optim.AdamP

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-08weight_decay = 0delta = 0.1wd_ratio = 0.1nesterov = Falsecaution = False )

classe timm.optim.AdamWLegacy

< >

( params: ParamsTlr: float = 0.001betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-08weight_decay: float = 0.01amsgrad: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonecapturable: bool = Falseclipping_threshold: typing.Optional[float] = None )

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 — maximiza 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 laço for na CUDA, pois é mais rápida em geral.
  • capturable — se esta instância é segura para ser capturada em um gráfico CUDA. Passar True pode prejudicar o desempenho sem gráfico, então, se você não pretende capturar esta instância em um gráfico, deixe como False
  • clipping_threshold — limiar de clipping para a atualização RMS (StableAdamW, https://arxiv.org/abs/2304.13013), a atualização é escalada 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 weight decay desacoplado não é clipado (o StableAdamW também escala o decay pelo lr clipado).

Implementa o algoritmo AdamW.

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

Referências:

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.Adan

< >

( paramslr: float = 0.001betas: typing.Tuple[float, float, float] = (0.98, 0.92, 0.99)eps: float = 1e-08weight_decay: float = 0.0no_prox: bool = Falsecaution: bool = Falseforeach: typing.Optional[bool] = None )

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 de ‘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

< >

( closure = None )

Executa um único passo de otimização.

classe timm.optim.Adopt

< >

( params: ParamsTlr: typing.Union[float, torch.Tensor] = 0.001betas: typing.Tuple[float, float] = (0.9, 0.9999)eps: float = 1e-06clip_exp: typing.Optional[float] = 0.333weight_decay: float = 0.0decoupled: bool = Falsecorrected_weight_decay: bool = Falsecaution: bool = Falseforeach: typing.Optional[bool] = Nonemaximize: bool = Falsecapturable: bool = Falsedifferentiable: bool = False )

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

etapa

< >

( closure = None )

Parâmetros

  • closure (Callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Execute um único passo de otimização.

classe timm.optim.kron.Kron

< >

( params: ParamsTlr: float = 0.001momentum: float = 0.9weight_decay: float = 0.0preconditioner_update_probability: typing.Union[typing.Callable, float, NoneType] = Nonemax_size_triangular: int = 2048min_ndim_triangular: int = 2memory_save_mode: typing.Optional[str] = Nonemomentum_into_precond_update: bool = Trueprecond_lr: float = 0.1precond_init_scale: float = 1.0mu_dtype: typing.Optional[torch.dtype] = Noneprecond_dtype: typing.Optional[torch.dtype] = Nonedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falseflatten: bool = Falseflatten_start_dim: int = 2flatten_end_dim: int = -1stochastic_weight_decay: bool = Falsedeterministic: bool = False )

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 impulso.
  • weight_decay — Decaimento de peso.
  • preconditioner_update_probability — Probabilidade de atualização do pré-condicionador. Se for 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 de dim ser triangular.
  • min_ndim_triangular — Número mínimo de dimensões que uma camada precisa ter para usar pré-condicionadores triangulares.
  • memory_save_mode — ‘one_diag’, ‘smart_one_diag’ ou ‘all_diag’, o padrão é None 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 momentum para a atualização do pré-condicionador em vez dos gradientes brutos.
  • mu_dtype — Dtype do acumulador de momento.
  • precond_dtype — Dtype 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 — Achata as 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 achatamento, padrão -1.
  • stochastic_weight_decay — Ativa a 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.

classe timm.optim.Lamb

< >

( params: ParamsTlr: float = 0.001bias_correction: bool = Truebetas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-06weight_decay: float = 0.01grad_averaging: bool = Truemax_grad_norm: typing.Optional[float] = 1.0trust_clip: bool = Falsealways_adapt: bool = Falsecaution: bool = Falsedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falseforeach: typing.Optional[bool] = None )

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 gradiente.
  • max_grad_norm — Valor usado para limitar a norma global do gradiente.
  • trust_clip — Ativa 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 — aplica o decaimento de peso corrigido (lr**2 / max_lr) ao usar decoupled_decay
  • foreach — use a implementação foreach (multi-tensor), usada por padrão (None) a menos que não seja suportada

Implementa uma variante pura em PyTorch do otimizador FuseLAMB (variante NvLamb) 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:

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.LaProp

< >

( params: ParamsTlr: float = 0.0004betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-15weight_decay: float = 0.0caution: bool = Falsecorrected_weight_decay: bool = Falseforeach: typing.Optional[bool] = None )

Parâmetros

  • foreach — use a implementação foreach (multi-tensor), usada por padrão (None) a menos que não seja suportada (veja laprop())

Otimizador LaProp

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

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.Lars

< >

( paramslr = 1.0momentum = 0dampening = 0weight_decay = 0nesterov = Falsetrust_coeff = 0.001eps = 1e-08trust_clip = Falsealways_adapt = Falseforeach: typing.Optional[bool] = None )

Parâmetros

  • params (iterável) — iterável de parâmetros a serem otimizados 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) — usa 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

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.Lion

< >

( params: ParamsTlr: float = 0.0001betas: typing.Tuple[float, float] = (0.9, 0.99)weight_decay: float = 0.0caution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = None )

Implementa o algoritmo Lion.

etapa

< >

( closure = None )

Parâmetros

  • closure — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.Lookahead

< >

( base_optimizeralpha = 0.5k = 6 )

classe timm.optim.MADGRAD

< >

( params: typing.Anylr: float = 0.01momentum: float = 0.9weight_decay: float = 0eps: float = 1e-06decoupled_decay: bool = False )

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 e pode convergir mais rápido e generalizar melhor. Atualmente, apenas para GPU. Normalmente, a mesma agenda de taxa de aprendizado usada para SGD ou Adam pode ser usada. 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

< >

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

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.Mars

< >

( params: ParamsTlr: float = 0.003betas: typing.Tuple[float, float] = (0.9, 0.99)eps: float = 1e-08weight_decay: float = 0.0gamma: float = 0.025mars_type: str = 'adamw'optimize_1d: bool = Falselr_1d_factor: float = 1.0betas_1d: typing.Optional[typing.Tuple[float, float]] = Nonecaution: bool = False )

Otimizador MARS

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

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.Muon

< >

( params: ParamsTlr: float = 0.02weight_decay: float = 0momentum: float = 0.95nesterov: bool = Falsens_steps: int = 5ns_coefficients: typing.Union[str, typing.Tuple[float, float, float], typing.List[typing.Tuple[float, float, float]]] = 'quintic'eps: float = 1e-07safety_factor: float = 1.0adjust_lr_fn: typing.Optional[str] = 'match_rms_adamw'conv_mode: str = 'flatten'normalize_spatial: bool = Trueadamw_lr: typing.Optional[float] = Nonefallback_lr_scale: float = 1.0betas: typing.Tuple[float, float] = (0.9, 0.95)algo: str = 'muon'scale_eps: bool = Falsecapturable: bool = Falseverbose: bool = False )

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 às direções ortogonalizadas para escalonamento adaptativo semelhante ao do Adam

etapa

< >

( closure = None )

Executa um único passo de otimização.

classe timm.optim.NAdamLegacy

< >

( paramslr = 0.002betas = (0.9, 0.999)eps = 1e-08weight_decay = 0schedule_decay = 0.004 )

Parâmetros

  • params (iterável) — iterável de parâmetros a serem otimizados 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: Pode ter problemas potenciais, mas funciona bem em alguns problemas.

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.NAdamW

< >

( params: ParamsTlr: float = 0.001betas: typing.Tuple[float, float] = (0.9, 0.999)eps: float = 1e-08weight_decay: float = 0.01caution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonecapturable: bool = Falseclipping_threshold: typing.Optional[float] = None )

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 — ative a cautela
  • corrected_weight_decay — aplicar decaimento de peso corrigido (lr**2 / max_lr)
  • maximize — maximiza os parâmetros com base no objetivo, em vez de minimizá-los
  • foreach — se a implementação foreach do otimizador é usada. 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 clipping para a atualização RMS (StableAdamW, https://arxiv.org/abs/2304.13013), a atualização é escalada 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 weight decay desacoplado não é clipado (o StableAdamW também escala o decay pelo lr clipado).

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

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.NvNovoGrad

< >

( paramslr = 0.001betas = (0.95, 0.98)eps = 1e-08weight_decay = 0grad_averaging = Falseamsgrad = Falsedecoupled_decay = Falsecorrected_weight_decay = False )

Parâmetros

  • params (iterável) — iterável de parâmetros a serem otimizados 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 — aplica 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 — aplica o decaimento de peso corrigido (lr**2 / max_lr) quando decoupled_decay é True

Implementa o algoritmo Novograd.

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo
  • and retorna a perda. —

Executa um único passo de otimização.

classe timm.optim.RAdamLegacy

< >

( paramslr = 0.001betas = (0.9, 0.999)eps = 1e-08weight_decay = 0 )

Otimizador RAdam do PyTorch

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

classe timm.optim.RMSpropTF

< >

( params: ParamsTlr: float = 0.01alpha: float = 0.9eps: float = 1e-10weight_decay: float = 0momentum: float = 0.0centered: bool = Falsedecoupled_decay: bool = Falsecorrected_weight_decay: bool = Falselr_in_momentum: bool = Truecaution: bool = Falseforeach: typing.Optional[bool] = None )

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, a gradiente é normalizada por uma estimativa de sua variância
  • weight_decay — decaimento de peso (penalidade L2) (padrão: 0)
  • decoupled_decay — decaimento de peso desacoplado conforme https://arxiv.org/abs/1711.05101
  • corrected_weight_decay — aplica o decaimento de peso corrigido (lr**2 / max_lr) quando decoupled_decay é True
  • lr_in_momentum — a escala da taxa de aprendizado está incluída na atualização do buffer de momentum, conforme os padrões do Tensorflow
  • caution — aplicar cautela
  • foreach — use a implementação foreach (multi-tensor), usada por padrão (None) a menos que não seja suportada (veja rmsprop_tf())

Implementa o algoritmo RMSprop (epsilon no estilo TensorFlow)

OBSERVAÇÃO: Este é um recorte direto do RMSprop do PyTorch com eps aplicado antes da raiz quadrada e algumas outras modificações para corresponder mais de perto ao Tensorflow, de modo a alinhar os 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.

A versão centralizada aparece pela primeira vez em Generating Sequences With Recurrent Neural Networks.

etapa

< >

( closure = None )

Parâmetros

  • closure (callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

classe timm.optim.SGDP

< >

( paramslr = torch.optim.optimizer.requiredmomentum = 0dampening = 0weight_decay = 0nesterov = Falseeps = 1e-08delta = 0.1wd_ratio = 0.1caution = False )

classe timm.optim.SGDW

< >

( params: ParamsTlr: float = 0.001momentum: float = 0.0dampening: float = 0.0weight_decay: float = 0.0nesterov: bool = Falsecaution: bool = Falsecorrected_weight_decay: bool = Falsemaximize: bool = Falseforeach: typing.Optional[bool] = Nonedifferentiable: bool = False )

etapa

< >

( closure = None )

Parâmetros

  • closure (Callable, opcional) — Uma closure que reavalia o modelo e retorna a perda.

Executa um único passo de otimização.

Update on GitHub

←Perdas Agendadores de taxa de aprendizado→