pytorch optimizer
v0.3.0
Torch-Optimizer -Sammlung von Optimierern für Pytorch-kompatibel mit dem Optim-Modul.
import torch_optimizer as optim
# model = ...
optimizer = optim . DiffGrad ( model . parameters (), lr = 0.001 )
optimizer . step ()Der Installationsprozess ist einfach: Nur:
$ pip Installieren Sie Torch_optimizer
https://pytorch-optimizer.rtfd.io
Bitte zitieren Sie die ursprünglichen Autoren der Optimierungsalgorithmen. Wenn Ihnen dieses Paket gefällt:
@software {novik_torchoptimizers,
Titel = {{Torch-Optimizer-Sammlung von Optimierungsalgorithmen für Pytorch.}},
Autor = {Novik, mykola},
Jahr = 2020,
Monat = 1,
Version = {1.0.1}
}
Oder verwenden Sie die GitHub -Funktion: "Diese Repository zitieren".
| 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 |
| Vorab | https://arxiv.org/abs/1902.09843 |
| Adamod | https://arxiv.org/abs/1910.12249 |
| Adafaktor | 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 |
| Lamm | https://arxiv.org/abs/1904.00962 |
| Lookahead | https://arxiv.org/abs/1907.08610 |
| Verrückter | 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 |
| Ranger | https://medium.com/@lessw/new-leep-learning-optimizer-ranger-synergistic-combination-of-radam-lookahead-for-best-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 |
| Shampoo | https://arxiv.org/abs/1802.09568 |
| Yogi | https://papers.nips.cc/paper/8186-adaptive-methods-for-nonconvex-optimization |
Visualisierungen helfen uns, zu sehen, wie unterschiedliche Algorithmen mit einfachen Situationen wie Sattelpunkten, lokalen Minima, Tälern usw. umgehen, und können interessante Einblicke in die Innenarbeit eines Algorithmus liefern. Rosenbrock und Rastrigin -Benchmark -Funktionen wurden ausgewählt, weil:
Rastrigin ist eine nicht konvexe Funktion und hat ein globales Minimum in (0,0, 0,0). Das Minimum dieser Funktion ist ein ziemlich schwieriges Problem aufgrund seines großen Suchraums und seiner großen Anzahl lokaler Minima.
Jeder Optimierer führt 501 Optimierungsschritte aus. Die Lernrate ist die beste, die durch einen Hyperparameter -Suchalgorithmus gefunden wird. Der Rest der Abstimmparameter ist standardmäßig. Es ist sehr einfach, das Skript zu erweitern und andere Optimiererparameter einzustellen.
Python Beispiele/Viz_Optimizers.py
Wählen Sie keinen Optimierer aus, der auf Visualisierungen basiert. Optimierungsansätze haben einzigartige Eigenschaften und können für unterschiedliche Zwecke zugeschnitten sein oder möglicherweise einen expliziten Lernrate -Zeitplan usw. erfordern
Wenn Sie nicht wissen, welchen Optimierer Sie verwenden sollen, beginnen Sie mit dem integrierten SGD/Adam. Sobald die Trainingslogik bereit ist und die Basiswerte festgelegt sind, tauschen Sie den Optimierer aus und prüfen Sie, ob sich verbessert.
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 ()Papier : optimaler adaptiver und beschleunigter stochastischer Gradientenabstieg (2018) [https://arxiv.org/abs/1810.00553]
Referenzcode : https://github.com/severilov/a2grad_optimizer
import torch_optimizer as optim
# model = ...
optimizer = optim . A2GradInc (
model . parameters (),
kappa = 1000.0 ,
beta = 10.0 ,
lips = 10.0 ,
)
optimizer . step ()Papier : optimaler adaptiver und beschleunigter stochastischer Gradientenabstieg (2018) [https://arxiv.org/abs/1810.00553]
Referenzcode : https://github.com/severilov/a2grad_optimizer
import torch_optimizer as optim
# model = ...
optimizer = optim . A2GradUni (
model . parameters (),
kappa = 1000.0 ,
beta = 10.0 ,
lips = 10.0 ,
)
optimizer . step ()Papier : optimaler adaptiver und beschleunigter stochastischer Gradientenabstieg (2018) [https://arxiv.org/abs/1810.00553]
Referenzcode : https://github.com/severilov/a2grad_optimizer
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 ()Papier : Über die Unzulänglichkeit bestehender Impulsschemata für die stochastische Optimierung (2019) [https://arxiv.org/abs/1803.05591]
Referenzcode : https://github.com/rahulkidambi/accsgd
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 ()Papier : Adabelief -Optimierer, Anpassung von Stufen durch den Glauben an beobachtete Gradienten (2020) [https://arxiv.org/abs/2010.07468]
Referenzcode : https://github.com/juntang-zhuang/adabelief-optimizer
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 ()Papier : Adaptive Gradientenmethoden mit dynamischer Lernrate (2019) [https://arxiv.org/abs/1902.09843]
Referenzcode : https://github.com/luolc/adabound
Die Adamod -Methode schränkt die adaptiven Lernraten mit adaptiven und momentalen Obergrenzen ein. Die dynamischen Lernrate -Grenzen basieren auf den exponentiellen, bewegenden Durchschnittswerten der adaptiven Lernraten selbst, die unerwartete große Lernraten glätten und das Training von tiefen neuronalen Netzwerken stabilisieren.
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 ()Papier : Eine adaptive und momentale gebundene Methode zum stochastischen Lernen. (2019) [https://arxiv.org/abs/1910.12249]
Referenzcode : https://github.com/lancopku/adamod
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 ()Papier : Adafaktor: Adaptive Lernraten mit Sublinear -Speicherkosten. (2018) [https://arxiv.org/abs/1804.04235]
Referenzcode : https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py
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 ()Papier : Adahessian: Ein adaptiver Optimierer zweiter Ordnung für maschinelles Lernen (2020) [https://arxiv.org/abs/2006.00719]
Referenzcode : https://github.com/amirgholami/adahessian
ADAMP schlägt eine einfache und effektive Lösung vor: Bei jeder Iteration des Adam-Optimierers, das auf Skala-invarianten Gewichten (z. B. Gewichten vor einer BN-Schicht) angewendet wird, entfernt ADAMP die radiale Komponente (dh parallel zum Gewichtsvektor) aus dem Aktualisierungsvektor. Intuitiv verhindert dieser Vorgang die unnötige Aktualisierung entlang der radialen Richtung, die die Gewichtsnorm nur erhöht, ohne zur Verlustminimierung beizutragen.
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 ()Papier : Verlangsamung der Gewichtsnorm Anstieg der Impuls-basierten Optimierer. (2020) [https://arxiv.org/abs/2006.08217]
Referenzcode : https://github.com/clovaai/adamp
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 ()Papier : aggregierter Impuls: Stabilität durch passive Dämpfung. (2019) [https://arxiv.org/abs/1804.00325]
Referenzcode : https://github.com/athemathmus/aggmo
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 ()Papier : Apollo: Eine adaptive Parameter-Weise diagonale Quasi-Newton-Methode zur nicht konvexen stochastischen Optimierung. (2020) [https://arxiv.org/abs/2009.13586]
Referenzcode : https://github.com/xuezhemax/apollo
Optimierer Basierend auf der Differenz zwischen dem vorliegenden und dem unmittelbaren vergangenen Gradienten wird die Schrittgröße für jeden Parameter so eingestellt, dass es eine größere Schrittgröße für schnellere Gradientenwechselparameter und eine niedrigere Schrittgröße für niedrigere Gradientenwechselparameter haben sollte.
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 ()Papier : DiffGrad: Eine Optimierungsmethode für Faltungsnetzwerke. (2019) [https://arxiv.org/abs/1909.11015]
Referenzcode : https://github.com/shivram1987/diffgradgrad
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 ()Papier : Große Batch -Optimierung für Deep Learning: Training Bert in 76 Minuten (2019) [https://arxiv.org/abs/1904.00962]
Referenzcode : https://github.com/cybertronai/pytorch-lamb
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 ()Papier : Lookahead Optimierer: K tritt nach vorne, 1 Schritt zurück (2019) [https://arxiv.org/abs/1907.08610]
Referenzcode : https://github.com/alphadl/lookahead.pytorch
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 ()Papier : Anpassungsfähigkeit ohne Kompromiss: Eine Momentum, eine adaptive, doppelt gemittelte Gradientenmethode für die stochastische Optimierung (2021) [https://arxiv.org/abs/2101.11075]
Referenzcode : https://github.com/facebookResearch/Madgradgrad
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 ()Papier : Stochastische Gradientenmethoden mit schichtweisen adaptiven Momenten für das Training von Deep Networks (2019) [https://arxiv.org/abs/1905.11286]
Referenzcode : https://github.com/nvidia/deeplearnexamples/
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 ()Papier : Ein PID -Controller -Ansatz für die stochastische Optimierung von Deep Networks (2018) [http://www4.comp.polyu.edu.hk/~cslzhang/paper/cvpr18_pid.pdf]
Referenzcode : https://github.com/tensorboy/pidoptimizer
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 ()Papier : quasi-hyperbolic dynamik und Adam für Deep Learning (2019) [https://arxiv.org/abs/1810.06801]
Referenzcode : https://github.com/facebookresearch/qhoptim
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 ()Papier : quasi-hyperbolic dynamik und Adam für Deep Learning (2019) [https://arxiv.org/abs/1810.06801]
Referenzcode : https://github.com/facebookresearch/qhoptim
Veraltet, bitte verwenden Sie die von Pytorch bereitgestellte Version.
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 ()Papier : Über die Varianz der adaptiven Lernrate und darüber hinaus (2019) [https://arxiv.org/abs/1908.03265]
Referenzcode : https://github.com/liyuanlucasliu/radam
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 ()Papier : New Deep Learning Optimizer, Ranger: Synergistische Kombination von Radam + Lookahead für das Beste von beiden (2019) [https://medium.com/@lessw/new-leep-learning-optimizer-ranger-synergistic-combination-of-radam-lookahead-for-the-the-the-best-of-2Dc83f79a48d]
Referenzcode : https://github.com/lessw2020/ranger-leep-learning-optimizer
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 ()Papier : quasi-hyperbolic dynamik und Adam für Deep Learning (2018) [https://arxiv.org/abs/1810.06801]
Referenzcode : https://github.com/lessw2020/ranger-leep-learning-optimizer
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 ()Papier : Kalibrierung der adaptiven Lernrate zur Verbesserung der Konvergenz von Adam (2019) [https://arxiv.org/abs/1908.00700v2]
Referenzcode : https://github.com/lessw2020/ranger-leep-learning-optimizer
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 ()Papier : Verlangsamung der Gewichtsnorm Anstieg der Impuls-basierten Optimierer. (2020) [https://arxiv.org/abs/2006.08217]
Referenzcode : https://github.com/clovaai/adamp
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 ()Papier : SGDR: Stochastischer Gradientenabstieg mit warmen Neustarts (2017) [https://arxiv.org/abs/1608.03983]
Referenzcode : Pytorch/Pytorch#22466
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 ()Papier : Verbesserung der Generalisierungsleistung durch Wechsel von Adam zu SGD (2017) [https://arxiv.org/abs/1712.07628]
Referenzcode : https://github.com/mrpatekful/swats
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 ()Papier : Shampoo: Vorkonditionierte stochastische Tensoroptimierung (2018) [https://arxiv.org/abs/1802.09568]
Referenzcode : https://github.com/moskomule/shampoo.pytorch
Yogi ist der Optimierungsalgorithmus auf ADAM mit einer feinkörnigen effektiven Lernrate -Kontrolle und hat ähnliche theoretische Garantien für die Konvergenz wie 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 ()Papier : Adaptive Methoden für die nicht konvexe Optimierung (2018) [https://papers.nips.cc/paper/8186-adaptive-Methode-for-nonconvex-optimization]
Referenzcode : https://github.com/4rtemi5/yogi-optimizer_keras
