Download do pytorch optimizer - pytorch optimizer Download do código fonte

Torch-Optimizer

Status de ações do github para filial mestre

Torch-Optimizer -Coleção de otimizadores para Pytorch Compatível com o Módulo Optim.

Exemplo simples

 import torch_optimizer as optim

# model = ...
optimizer = optim . DiffGrad ( model . parameters (), lr = 0.001 )
optimizer . step ()

Instalação

O processo de instalação é simples, apenas:

 $ PIP Install Torch_Optimizer

Documentação

https://pytorch-optimizer.rtfd.io

Citação

Cite os autores originais dos algoritmos de otimização. Se você gosta deste pacote:

 @software {Novik_torChoptimizers,
    Title = {{Torch-Optimizer-Coleção de algoritmos de otimização para Pytorch.}},
    autor = {Novik, mykola},
    ano = 2020,
    mês = 1,
    versão = {1.0.1}
}

Ou use o recurso GitHub: "cite este botão Repositório".

Otimizadores suportados

A2Gradexp	https://arxiv.org/abs/1810.00553
A2Gradinc	https://arxiv.org/abs/1810.00553
A2graduni	https://arxiv.org/abs/1810.00553
Accsgd	https://arxiv.org/abs/1803.05591
Adabelief	https://arxiv.org/abs/2010.07468
Adabound	https://arxiv.org/abs/1902.09843
Adamod	https://arxiv.org/abs/1910.12249
Adafactor	https://arxiv.org/abs/1804.04235
Adahessian	https://arxiv.org/abs/2006.00719
Adamp	https://arxiv.org/abs/2006.08217
Aggmo	https://arxiv.org/abs/1804.00325
Apollo	https://arxiv.org/abs/2009.13586
Diffgrad	https://arxiv.org/abs/1909.11015
Cordeiro	https://arxiv.org/abs/1904.00962
Lookahead	https://arxiv.org/abs/1907.08610
Madgrad	https://arxiv.org/abs/2101.11075
Novograd	https://arxiv.org/abs/1905.11286
PID	https://www4.comp.polyu.edu.hk/~cslzhang/paper/cvpr18_pid.pdf
Qhadam	https://arxiv.org/abs/1810.06801
Qhm	https://arxiv.org/abs/1810.06801
Radam	https://arxiv.org/abs/1908.03265
Guarda-florestal	https://medium.com/@lessw/new-deep-learnning-optimizer-gunger-synergistic-combination-of-dam-lookahead-for-best-of-2dc83f79a48d
Rangerqh	https://arxiv.org/abs/1810.06801
Rangerva	https://arxiv.org/abs/1908.00700v2
Sgdp	https://arxiv.org/abs/2006.08217
Sgdw	https://arxiv.org/abs/1608.03983
Swats	https://arxiv.org/abs/1712.07628
Xampu	https://arxiv.org/abs/1802.09568
Yogi	https://papers.nips.cc/paper/8186-adaptive-methods-for-nonconvex-timization

Visualizações

As visualizações nos ajudam a ver como os diferentes algoritmos lidam com situações simples como: pontos de sela, mínimos locais, vales etc. e podem fornecer informações interessantes sobre o funcionamento interno de um algoritmo. As funções de referência de Rosenbrock e Rastrigin foram selecionadas porque:

Rosenbrock (também conhecido como função de banana), é uma função não convexa que possui um mínimo global (1.0. 1.0). O mínimo global está dentro de um vale plano longo, estreito e parabólico. Encontrar o vale é trivial. Convergir para o mínimo global, no entanto, é difícil. Os algoritmos de otimização podem prestar muita atenção a uma coordenada e lutar após o vale, que é relativamente plano.

Rastrigin é uma função não convexa e possui um mínimo global (0,0, 0,0). Encontrar o mínimo dessa função é um problema bastante difícil devido ao seu grande espaço de pesquisa e seu grande número de mínimos locais.

Cada otimizador executa 501 etapas de otimização. A taxa de aprendizado é a melhor encontrada por um algoritmo de pesquisa de parâmetros hiper, o restante dos parâmetros de ajuste é padrão. É muito fácil estender o script e ajustar outros parâmetros de otimizador.

 Exemplos de Python/viz_optimizers.py

Aviso

Não escolha um otimizador com base em visualizações, as abordagens de otimização têm propriedades exclusivas e podem ser adaptadas para fins diferentes ou podem exigir cronograma explícito de taxa de aprendizado etc. A melhor maneira de descobrir é tentar um em seu problema específico e ver se ele melhora as pontuações.

Se você não souber qual otimizador usar, comece com o SGD/Adam embutido. Quando a lógica de treinamento estiver pronta e as pontuações da linha de base forem estabelecidas, troque o otimizador e veja se há alguma melhoria.

A2Gradexp

 import torch_optimizer as optim

# model = ...
optimizer = optim . A2GradExp (
    model . parameters (),
    kappa = 1000.0 ,
    beta = 10.0 ,
    lips = 10.0 ,
    rho = 0.5 ,
)
optimizer . step ()

Artigo : Descendência estocástica ideal de gradiente estocástico adaptável e acelerado (2018) [https://arxiv.org/abs/1810.00553]

Código de referência : https://github.com/severilov/a2grad_optimizer

A2Gradinc

 import torch_optimizer as optim

# model = ...
optimizer = optim . A2GradInc (
    model . parameters (),
    kappa = 1000.0 ,
    beta = 10.0 ,
    lips = 10.0 ,
)
optimizer . step ()

Artigo : Descendência estocástica ideal de gradiente estocástico adaptável e acelerado (2018) [https://arxiv.org/abs/1810.00553]

Código de referência : https://github.com/severilov/a2grad_optimizer

A2graduni

 import torch_optimizer as optim

# model = ...
optimizer = optim . A2GradUni (
    model . parameters (),
    kappa = 1000.0 ,
    beta = 10.0 ,
    lips = 10.0 ,
)
optimizer . step ()

Artigo : Descendência estocástica ideal de gradiente estocástico adaptável e acelerado (2018) [https://arxiv.org/abs/1810.00553]

Código de referência : https://github.com/severilov/a2grad_optimizer

Accsgd

 import torch_optimizer as optim

# model = ...
optimizer = optim . AccSGD (
    model . parameters (),
    lr = 1e-3 ,
    kappa = 1000.0 ,
    xi = 10.0 ,
    small_const = 0.7 ,
    weight_decay = 0
)
optimizer . step ()

Artigo : Sobre a insuficiência dos esquemas de momento existentes para otimização estocástica (2019) [https://arxiv.org/abs/1803.05591]

Código de referência : https://github.com/rahulkidambi/accsgd

Adabelief

 import torch_optimizer as optim

# model = ...
optimizer = optim . AdaBelief (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-3 ,
    weight_decay = 0 ,
    amsgrad = False ,
    weight_decouple = False ,
    fixed_decay = False ,
    rectify = False ,
)
optimizer . step ()

Artigo : Otimizador do Adabelief, Adaptação Standses pela crença em gradientes observados (2020) [https://arxiv.org/abs/2010.07468]

Código de referência : https://github.com/juntang-zhuang/adabelief-optimizer

Adabound

 import torch_optimizer as optim

# model = ...
optimizer = optim . AdaBound (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    final_lr = 0.1 ,
    gamma = 1e-3 ,
    eps = 1e-8 ,
    weight_decay = 0 ,
    amsbound = False ,
)
optimizer . step ()

Artigo : Métodos de gradiente adaptativo com limite dinâmico da taxa de aprendizagem (2019) [https://arxiv.org/abs/1902.09843]

Código de referência : https://github.com/luolc/adabound

Adamod

O método Adamod restringe as taxas de aprendizado adaptativo com limites superiores adaptativos e momentâneos. Os limites da taxa de aprendizagem dinâmicos são baseados nas médias móveis exponenciais das próprias taxas de aprendizado adaptativo, o que suaviza grandes taxas de aprendizado inesperadas e estabilizam o treinamento de redes neurais profundas.

 import torch_optimizer as optim

# model = ...
optimizer = optim . AdaMod (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    beta3 = 0.999 ,
    eps = 1e-8 ,
    weight_decay = 0 ,
)
optimizer . step ()

Artigo : um método adaptável e momentâneo para a aprendizagem estocástica. (2019) [https://arxiv.org/abs/1910.12249]

Código de referência : https://github.com/lancopku/adamod

Adafactor

 import torch_optimizer as optim

# model = ...
optimizer = optim . Adafactor (
    m . parameters (),
    lr = 1e-3 ,
    eps2 = ( 1e-30 , 1e-3 ),
    clip_threshold = 1.0 ,
    decay_rate = - 0.8 ,
    beta1 = None ,
    weight_decay = 0.0 ,
    scale_parameter = True ,
    relative_step = True ,
    warmup_init = False ,
)
optimizer . step ()

Artigo : ADAFACTOR: Taxas de aprendizado adaptável com custo de memória sublinear. (2018) [https://arxiv.org/abs/1804.04235]

Código de referência : https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py

Adahessian

 import torch_optimizer as optim

# model = ...
optimizer = optim . Adahessian (
    m . parameters (),
    lr = 1.0 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-4 ,
    weight_decay = 0.0 ,
    hessian_power = 1.0 ,
)
      loss_fn ( m ( input ), target ). backward ( create_graph = True ) # create_graph=True is necessary for Hessian calculation
optimizer . step ()

Artigo : Adahessian: um otimizador de segunda ordem adaptável para aprendizado de máquina (2020) [https://arxiv.org/abs/2006.00719]

Código de referência : https://github.com/amirgholami/adahessian

Adamp

O ADAMP propõe uma solução simples e eficaz: a cada iteração do otimizador de Adam aplicado em pesos invariantes em escala (por exemplo, pesos convidrados em uma camada BN), o ADAMP remove o componente radial (isto é, paralelo ao vetor de peso) do vetor de atualização. Intuitivamente, essa operação impede a atualização desnecessária ao longo da direção radial que aumenta apenas a norma de peso sem contribuir para a minimização da perda.

 import torch_optimizer as optim

# model = ...
optimizer = optim . AdamP (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-8 ,
    weight_decay = 0 ,
    delta = 0.1 ,
    wd_ratio = 0.1
)
optimizer . step ()

Papel : diminuindo o aumento da norma de peso nos otimizadores baseados em momento. (2020) [https://arxiv.org/abs/2006.08217]

Código de referência : https://github.com/clovaai/adamp

Aggmo

 import torch_optimizer as optim

# model = ...
optimizer = optim . AggMo (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.0 , 0.9 , 0.99 ),
    weight_decay = 0 ,
)
optimizer . step ()

Papel : Momento agregado: estabilidade através do amortecimento passivo. (2019) [https://arxiv.org/abs/1804.00325]

Código de referência : https://github.com/athemathmo/aggmo

Apollo

 import torch_optimizer as optim

# model = ...
optimizer = optim . Apollo (
    m . parameters (),
    lr = 1e-2 ,
    beta = 0.9 ,
    eps = 1e-4 ,
    warmup = 0 ,
    init_lr = 0.01 ,
    weight_decay = 0 ,
)
optimizer . step ()

Papel : Apollo: Um método diagonal quase-newton de parâmetro adaptativo para otimização estocástica não-convexa. (2020) [https://arxiv.org/abs/2009.13586]

Código de referência : https://github.com/xuezhemax/apollo

Diffgrad

Otimizador Com base na diferença entre o presente e o gradiente do passado imediato, o tamanho da etapa é ajustado para cada parâmetro de forma que ele tenha um tamanho de etapa maior para parâmetros de mudança de gradiente mais rápido e um tamanho de etapa mais baixo para parâmetros de mudança de gradiente mais baixos.

 import torch_optimizer as optim

# model = ...
optimizer = optim . DiffGrad (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-8 ,
    weight_decay = 0 ,
)
optimizer . step ()

Artigo : Diffgrad: Um método de otimização para redes neurais convolucionais. (2019) [https://arxiv.org/abs/1909.11015]

Código de referência : https://github.com/shivram1987/diffgradg

Cordeiro

 import torch_optimizer as optim

# model = ...
optimizer = optim . Lamb (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-8 ,
    weight_decay = 0 ,
)
optimizer . step ()

Artigo : Grande otimização em lote para aprendizado profundo: Treinamento Bert em 76 minutos (2019) [https://arxiv.org/abs/1904.00962]

Código de referência : https://github.com/cybertronai/pytorch-lamb

Lookahead

 import torch_optimizer as optim

# model = ...
# base optimizer, any other optimizer can be used like Adam or DiffGrad
yogi = optim . Yogi (
    m . parameters (),
    lr = 1e-2 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-3 ,
    initial_accumulator = 1e-6 ,
    weight_decay = 0 ,
)

optimizer = optim . Lookahead ( yogi , k = 5 , alpha = 0.5 )
optimizer . step ()

Artigo : Otimizador Lookahead: K Avançar, 1 passo para trás (2019) [https://arxiv.org/abs/1907.08610]

Código de referência : https://github.com/alphadl/lookahead.pytorch

Madgrad

 import torch_optimizer as optim

# model = ...
optimizer = optim . MADGRAD (
    m . parameters (),
    lr = 1e-2 ,
    momentum = 0.9 ,
    weight_decay = 0 ,
    eps = 1e-6 ,
)
optimizer . step ()

Artigo : Adaptabilidade sem compromisso: Um método de gradiente de média apelumizado, adaptável e duplo para otimização estocástica (2021) [https://arxiv.org/abs/2101.11075]

Código de referência : https://github.com/facebookresearch/madgrad

Novograd

 import torch_optimizer as optim

# model = ...
optimizer = optim . NovoGrad (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-8 ,
    weight_decay = 0 ,
    grad_averaging = False ,
    amsgrad = False ,
)
optimizer . step ()

Artigo : Métodos de gradiente estocástico com momentos adaptativos em camadas para o treinamento de redes profundas (2019) [https://arxiv.org/abs/1905.11286]

Código de referência : https://github.com/nvidia/deeplearnningExamples/

PID

 import torch_optimizer as optim

# model = ...
optimizer = optim . PID (
    m . parameters (),
    lr = 1e-3 ,
    momentum = 0 ,
    dampening = 0 ,
    weight_decay = 1e-2 ,
    integral = 5.0 ,
    derivative = 10.0 ,
)
optimizer . step ()

Papel : Uma abordagem do controlador PID para otimização estocástica de redes profundas (2018) [http://www4.comp.polyu.edu.hk/~cslzhang/paper/cvpr18_pid.pdf]

Código de referência : https://github.com/tensorboy/pidoptimizer

Qhadam

 import torch_optimizer as optim

# model = ...
optimizer = optim . QHAdam (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    nus = ( 1.0 , 1.0 ),
    weight_decay = 0 ,
    decouple_weight_decay = False ,
    eps = 1e-8 ,
)
optimizer . step ()

Artigo : Momento Quasi-Hyperbólico e Adam for Deep Learning (2019) [https://arxiv.org/abs/1810.06801]

Código de referência : https://github.com/facebookresearch/qhoptim

Qhm

 import torch_optimizer as optim

# model = ...
optimizer = optim . QHM (
    m . parameters (),
    lr = 1e-3 ,
    momentum = 0 ,
    nu = 0.7 ,
    weight_decay = 1e-2 ,
    weight_decay_type = 'grad' ,
)
optimizer . step ()

Artigo : Momento Quasi-Hyperbólico e Adam for Deep Learning (2019) [https://arxiv.org/abs/1810.06801]

Código de referência : https://github.com/facebookresearch/qhoptim

Radam

Despregado, use a versão fornecida pela Pytorch.

 import torch_optimizer as optim

# model = ...
optimizer = optim . RAdam (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-8 ,
    weight_decay = 0 ,
)
optimizer . step ()

Artigo : Sobre a variação da taxa de aprendizado adaptável e além (2019) [https://arxiv.org/abs/1908.03265]

Código de referência : https://github.com/liyuanlucosliu/radam

Guarda-florestal

 import torch_optimizer as optim

# model = ...
optimizer = optim . Ranger (
    m . parameters (),
    lr = 1e-3 ,
    alpha = 0.5 ,
    k = 6 ,
    N_sma_threshhold = 5 ,
    betas = ( .95 , 0.999 ),
    eps = 1e-5 ,
    weight_decay = 0
)
optimizer . step ()

Papel : Novo otimizador de aprendizado profundo, Ranger: Combinação sinérgica de radam + lookahead para o melhor de ambos (2019) [https://medium.com/@lessw/new-deep-learning-optimizer-gunger-synergistic-combination-of-dam-llookead-for-best-of-2dc83f79a48d]

Código de referência : https://github.com/lessw2020/ranger-deep-learning-optimizer

Rangerqh

 import torch_optimizer as optim

# model = ...
optimizer = optim . RangerQH (
    m . parameters (),
    lr = 1e-3 ,
    betas = ( 0.9 , 0.999 ),
    nus = ( .7 , 1.0 ),
    weight_decay = 0.0 ,
    k = 6 ,
    alpha = .5 ,
    decouple_weight_decay = False ,
    eps = 1e-8 ,
)
optimizer . step ()

Artigo : Momento Quasi-Hyperbólico e Adam for Deep Learning (2018) [https://arxiv.org/abs/1810.06801]

Código de referência : https://github.com/lessw2020/ranger-deep-learning-optimizer

Rangerva

 import torch_optimizer as optim

# model = ...
optimizer = optim . RangerVA (
    m . parameters (),
    lr = 1e-3 ,
    alpha = 0.5 ,
    k = 6 ,
    n_sma_threshhold = 5 ,
    betas = ( .95 , 0.999 ),
    eps = 1e-5 ,
    weight_decay = 0 ,
    amsgrad = True ,
    transformer = 'softplus' ,
    smooth = 50 ,
    grad_transformer = 'square'
)
optimizer . step ()

Artigo : Calibrando a taxa de aprendizado adaptável para melhorar a convergência de Adam (2019) [https://arxiv.org/abs/1908.00700v2]

Código de referência : https://github.com/lessw2020/ranger-deep-learning-optimizer

Sgdp

 import torch_optimizer as optim

# model = ...
optimizer = optim . SGDP (
    m . parameters (),
    lr = 1e-3 ,
    momentum = 0 ,
    dampening = 0 ,
    weight_decay = 1e-2 ,
    nesterov = False ,
    delta = 0.1 ,
    wd_ratio = 0.1
)
optimizer . step ()

Papel : diminuindo o aumento da norma de peso nos otimizadores baseados em momento. (2020) [https://arxiv.org/abs/2006.08217]

Código de referência : https://github.com/clovaai/adamp

Sgdw

 import torch_optimizer as optim

# model = ...
optimizer = optim . SGDW (
    m . parameters (),
    lr = 1e-3 ,
    momentum = 0 ,
    dampening = 0 ,
    weight_decay = 1e-2 ,
    nesterov = False ,
)
optimizer . step ()

Artigo : SGDR: Descendência de gradiente estocástico com reinicializações quentes (2017) [https://arxiv.org/abs/1608.03983]

Código de referência : Pytorch/Pytorch#22466

Swats

 import torch_optimizer as optim

# model = ...
optimizer = optim . SWATS (
    model . parameters (),
    lr = 1e-1 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-3 ,
    weight_decay = 0.0 ,
    amsgrad = False ,
    nesterov = False ,
)
optimizer . step ()

Artigo : Melhorando o desempenho da generalização, mudando de Adam para SGD (2017) [https://arxiv.org/abs/1712.07628]

Código de referência : https://github.com/mrpatekful/swats

Xampu

 import torch_optimizer as optim

# model = ...
optimizer = optim . Shampoo (
    m . parameters (),
    lr = 1e-1 ,
    momentum = 0.0 ,
    weight_decay = 0.0 ,
    epsilon = 1e-4 ,
    update_freq = 1 ,
)
optimizer . step ()

Artigo : Shampoo: Otimização estocástica pré -condicionada do tensor (2018) [https://arxiv.org/abs/1802.09568]

Código de referência : https://github.com/moskomule/shampoo.pytorch

Yogi

O Yogi é o algoritmo de otimização baseado em Adam com controle de taxa de aprendizado eficaz mais fino e tem garantias teóricas semelhantes sobre a convergência como Adam.

 import torch_optimizer as optim

# model = ...
optimizer = optim . Yogi (
    m . parameters (),
    lr = 1e-2 ,
    betas = ( 0.9 , 0.999 ),
    eps = 1e-3 ,
    initial_accumulator = 1e-6 ,
    weight_decay = 0 ,
)
optimizer . step ()

Artigo : Métodos adaptativos para otimização não-convexa (2018) [https://papers.nips.cc/paper/8186-adaptive-methods-for-nonconvex-timization]

Código de referência : https://github.com/4rtemi5/yogi-optimizer_keras

Adam (embutido Pytorch)

SGD (Pytorch embutido)

Expandir