pytorch optimizer
v0.3.0
Torch-Optimizer - Collection d'optimisateurs pour Pytorch compatible avec le module Optim.
import torch_optimizer as optim
# model = ...
optimizer = optim . DiffGrad ( model . parameters (), lr = 0.001 )
optimizer . step ()Le processus d'installation est simple, juste:
$ pip install torch_optimizer
https://pytorch-optimizer.rtfd.io
Veuillez citer les auteurs originaux des algorithmes d'optimisation. Si vous aimez ce package:
@software {novik_torchoptimizers,
Title = {{Torch-Optimizer - Collection des algorithmes d'optimisation pour Pytorch.}},
auteur = {novik, mykola},
année = 2020,
mois = 1,
version = {1.0.1}
}
Ou utilisez la fonction GitHub: "Citez ce référentiel".
| A2gradexp | https://arxiv.org/abs/1810.00553 |
| A2gradinc | https://arxiv.org/abs/1810.00553 |
| A2gradu | https://arxiv.org/abs/1810.00553 |
| Accsgd | https://arxiv.org/abs/1803.05591 |
| Adabélief | https://arxiv.org/abs/2010.07468 |
| Adapter | https://arxiv.org/abs/1902.09843 |
| Adamod | https://arxiv.org/abs/1910.12249 |
| Adafacteur | https://arxiv.org/abs/1804.04235 |
| Adahessien | https://arxiv.org/abs/2006.00719 |
| Adamp | https://arxiv.org/abs/2006.08217 |
| Agmmo | https://arxiv.org/abs/1804.00325 |
| Apollon | https://arxiv.org/abs/2009.13586 |
| Difficulté | https://arxiv.org/abs/1909.11015 |
| Agneau | 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 |
| Piquer | 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-deep-learning-optimizer-ranger-synergistic-combination-of-radam-lookahead-for-the-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 |
| Gamins | https://arxiv.org/abs/1712.07628 |
| Shampooing | https://arxiv.org/abs/1802.09568 |
| Yogi | https://papers.nips.cc/paper/8186-adaptive-methods-for-nonconvex-optimisation |
Les visualisations nous aident à voir comment différents algorithmes traitent des situations simples telles que: les points de selle, les minima locaux, les vallées, etc., et peuvent fournir des informations intéressantes sur le fonctionnement interne d'un algorithme. Les fonctions de référence Rosenbrock et Rastrigin ont été sélectionnées car:
Rastrigin est une fonction non convexe et a un minimum global dans (0,0, 0,0). Trouver le minimum de cette fonction est un problème assez difficile en raison de son grand espace de recherche et de son grand nombre de minima locaux.
Chaque optimiseur effectue 501 étapes d'optimisation. Le taux d'apprentissage est le meilleur trouvé par un algorithme de recherche de paramètres hyper, le reste des paramètres de réglage est par défaut. Il est très facile d'étendre le script et de régler d'autres paramètres d'optimiseur.
Exemples python / viz_optimizers.py
Ne choisissez pas un optimiseur en fonction des visualisations, les approches d'optimisation ont des propriétés uniques et peuvent être adaptées à différentes fins ou peuvent nécessiter un calendrier de taux d'apprentissage explicite, etc. La meilleure façon de le savoir est d'en essayer un sur votre problème particulier et de voir s'il améliore les scores.
Si vous ne savez pas quel optimiseur utiliser, commencez par le SGD / Adam intégré. Une fois que la logique de formation est prête et que les scores de base sont établis, échangez l'optimiseur et voyez s'il y a une amélioration.
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 ()Document : Optimal Adaptive and Accelerated Stochastic Gradient Descent (2018) [https://arxiv.org/abs/1810.00553]
Code de référence : 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 ()Document : Optimal Adaptive and Accelerated Stochastic Gradient Descent (2018) [https://arxiv.org/abs/1810.00553]
Code de référence : 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 ()Document : Optimal Adaptive and Accelerated Stochastic Gradient Descent (2018) [https://arxiv.org/abs/1810.00553]
Code de référence : 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 ()Document : Sur l'insuffisance des schémas de momentum existants pour l'optimisation stochastique (2019) [https://arxiv.org/abs/1803.05591]
Code de référence : 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 ()Document : Adabelief Optimizer, adaptation des passes par la croyance aux gradients observés (2020) [https://arxiv.org/abs/2010.07468]
Code de référence : 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 ()Document : Méthodes de gradient adaptatif avec un taux d'apprentissage dynamique (2019) [https://arxiv.org/abs/1902.09843]
Code de référence : https://github.com/luolc/adabound
La méthode Adamod restreint les taux d'apprentissage adaptatifs avec des limites supérieures adaptatives et mobilières. Les limites du taux d'apprentissage dynamique sont basées sur les moyennes mobiles exponentielles des taux d'apprentissage adaptatifs eux-mêmes, ce qui lisse les taux d'apprentissage importants inattendus et stabiliser la formation des réseaux de neurones profonds.
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 ()Document : une méthode liée adaptative et motation pour l'apprentissage stochastique. (2019) [https://arxiv.org/abs/1910.12249]
Code de référence : 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 : Adafactor: Taux d'apprentissage adaptatifs avec coût de la mémoire sous-linéaire. (2018) [https://arxiv.org/abs/1804.04235]
Code de référence : 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 ()Document : Adahessian: un optimiseur adaptatif de second ordre pour l'apprentissage automatique (2020) [https://arxiv.org/abs/2006.00719]
Code de référence : https://github.com/amirgholami/adahessian
L'ADAMP propose une solution simple et efficace: à chaque itération de l'optimiseur ADAM appliqué sur des poids invariants à l'échelle (par exemple, les poids convaincants précédant une couche BN), ADAMP supprime le composant radial (c'est-à-dire parallèle au vecteur de poids) du vecteur de mise à jour. Intuitivement, cette opération empêche la mise à jour inutile le long de la direction radiale qui ne fait qu'augmenter la norme de poids sans contribuer à la minimisation des pertes.
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 : Ralentissant l'augmentation de la norme de poids dans les optimisateurs basés sur la quantité de mouvement. (2020) [https://arxiv.org/abs/2006.08217]
Code de référence : 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 : Momentum agrégé: stabilité par amortissement passif. (2019) [https://arxiv.org/abs/1804.00325]
Code de référence : https://github.com/athemathmo/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: une méthode de quasi-newton diagonale adaptative pour l'optimisation stochastique non convexe. (2020) [https://arxiv.org/abs/2009.13586]
Code de référence : https://github.com/xuezhemax/apollo
Optimiseur basé sur la différence entre le gradient passé actuel et le gradient passé immédiat, la taille de l'étape est ajustée pour chaque paramètre de telle manière qu'il devrait avoir une taille de pas plus grande pour les paramètres de changement de gradient plus rapide et une taille de pas plus faible pour les paramètres de changement de gradient inférieur.
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 ()Document : Diffgrad: une méthode d'optimisation pour les réseaux de neurones convolutionnels. (2019) [https://arxiv.org/abs/1909.11015]
Code de référence : https://github.com/shivram1987/diffgrate
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 ()Document : grande optimisation par lots pour l'apprentissage en profondeur: formation Bert en 76 minutes (2019) [https://arxiv.org/abs/1904.00962]
Code de référence : 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 Optimizer: k avancé, 1 pas en arrière (2019) [https://arxiv.org/abs/1907.08610]
Code de référence : 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 ()Document : Adaptivité sans compromis: une méthode de gradient moyen, adaptative, adaptative et moyenne pour l'optimisation stochastique (2021) [https://arxiv.org/abs/2101.11075]
Code de référence : https://github.com/facebookresearch/madgrad
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 ()Document : Méthodes de gradient stochastique avec des moments adaptatifs en couches pour la formation des réseaux profonds (2019) [https://arxiv.org/abs/1905.11286]
Code de référence : https://github.com/nvidia/deeplearningexamples/
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 : une approche de contrôleur PID pour l'optimisation stochastique des réseaux profonds (2018) [http://www4.comp.polyu.edu.hk/~cslzhang/paper/cvpr18_pid.pdf]
Code de référence : 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 ()Document : Quasi-Hyperbolic Momentum et Adam for Deep Learning (2019) [https://arxiv.org/abs/1810.06801]
Code de référence : 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 ()Document : Quasi-Hyperbolic Momentum et Adam for Deep Learning (2019) [https://arxiv.org/abs/1810.06801]
Code de référence : https://github.com/facebookresearch/qhoptim
Débordé, veuillez utiliser la version fournie par 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 ()Document : Sur la variance du taux d'apprentissage adaptatif et au-delà (2019) [https://arxiv.org/abs/1908.03265]
Code de référence : 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 ()Document : nouvel optimiseur d'apprentissage en profondeur, Ranger: combinaison synergique de Radam + Lookahead pour le meilleur des deux (2019) [https://medium.com/@lessw/new-deep-learning-optimizer-ranger-synergistic-combination-of-radam-lokeahead-for-the-best-of-2dc83f79a48d]
Code de référence : https://github.com/lessw2020/ranger-deep-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 ()Document : Quasi-Hyperbolic Momentum et Adam for Deep Learning (2018) [https://arxiv.org/abs/1810.06801]
Code de référence : https://github.com/lessw2020/ranger-deep-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 ()Document : Calibrage du taux d'apprentissage adaptatif pour améliorer la convergence d'Adam (2019) [https://arxiv.org/abs/1908.00700v2]
Code de référence : https://github.com/lessw2020/ranger-deep-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 : Ralentissant l'augmentation de la norme de poids dans les optimisateurs basés sur la quantité de mouvement. (2020) [https://arxiv.org/abs/2006.08217]
Code de référence : 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: Descente de gradient stochastique avec des redémarrages chauds (2017) [https://arxiv.org/abs/1608.03983]
Code de référence : 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 ()Document : Amélioration des performances de la généralisation en passant d'Adam à SGD (2017) [https://arxiv.org/abs/1712.07628]
Code de référence : 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 : Shampoing: Optimisation des tendeurs stochastiques préconditionnés (2018) [https://arxiv.org/abs/1802.09568]
Code de référence : https://github.com/moskomule/shampoo.pytorch
Le yogi est un algorithme d'optimisation basé sur Adam avec un contrôle de taux d'apprentissage effectif plus fin et a des garanties théoriques similaires sur la convergence comme 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 : Méthodes adaptatives pour l'optimisation non convexe (2018) [https://papers.nips.cc/paper/8186-adaptive-methods-for-nonconvex-optimisation]
Code de référence : https://github.com/4rtemi5/yogi-optimizer_keras
