This repository has been archived by the owner on May 29, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 5
/
Copy pathadamw_electra.py
112 lines (89 loc) · 4.74 KB
/
adamw_electra.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
from argparse import ArgumentParser, Namespace
from typing import Generator
import torch
from torch.optim import AdamW
from transformers_lightning.optimizers.super_optimizer import SuperOptimizer
from transformers_lightning.optimizers.utils import named_parameters_to_parameters
class ElectraAdamW(AdamW):
r"""Implements AdamW algorithm.
The original Adam algorithm was proposed in `Adam: A Method for Stochastic Optimization`_.
The AdamW variant was proposed in `Decoupled Weight Decay Regularization`_. This version is
inspired to the version of AdamW proposed in `ELECTRA: PRE-TRAINING TEXT ENCODERS
AS DISCRIMINATORS RATHER THAN GENERATORS`. This code is the porting of the original
tensorflow code available `here <https://github.com/google-research/electra/blob/master/model/optimization.py>`_.
Arguments:
params (iterable): iterable of parameters to optimize or dicts defining
parameter groups
lr (float, optional): learning rate (default: 1e-3)
betas (Tuple[float, float], optional): coefficients used for computing
running averages of gradient and its square (default: (0.9, 0.999))
eps (float, optional): term added to the denominator to improve
numerical stability (default: 1e-8)
weight_decay (float, optional): weight decay coefficient (default: 1e-2)
amsgrad (boolean, optional): whether to use the AMSGrad variant of this
algorithm from the paper `On the Convergence of Adam and Beyond`_
(default: False)
.. _Adam\: A Method for Stochastic Optimization:
https://arxiv.org/abs/1412.6980
.. _Decoupled Weight Decay Regularization:
https://arxiv.org/abs/1711.05101
.. _On the Convergence of Adam and Beyond:
https://openreview.net/forum?id=ryQu7f-RZ
"""
def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-6, weight_decay=1e-2, amsgrad=False):
super(ElectraAdamW, self).__init__(
params, lr=lr, betas=betas, eps=eps, weight_decay=weight_decay, amsgrad=amsgrad
)
@torch.no_grad()
def step(self, closure=None):
r"""Performs a single optimization step.
Arguments:
closure (callable, optional): A closure that reevaluates the model
and returns the loss.
"""
loss = None
if closure is not None:
with torch.enable_grad():
loss = closure()
for group in self.param_groups:
for p in group['params']:
if p.grad is None:
continue
grad = p.grad
state = self.state[p]
# Perform stepweight decay
p.mul_(1 - group['lr'] * group['weight_decay'])
# State initialization
if len(state) == 0:
# Exponential moving average of gradient values
state['exp_avg'] = torch.zeros_like(p, memory_format=torch.preserve_format)
# Exponential moving average of squared gradient values
state['exp_avg_sq'] = torch.zeros_like(p, memory_format=torch.preserve_format)
beta1, beta2 = group['betas']
exp_avg, exp_avg_sq = state['exp_avg'], state['exp_avg_sq']
# Update moving average and square average
exp_avg.mul_(beta1).add_(grad, alpha=1 - beta1)
exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1 - beta2)
# Decay the first and second moment running average coefficient
p.addcdiv_(exp_avg, exp_avg_sq.sqrt() + group['eps'], value=-group['lr'])
# Update internal state
state['exp_avg'], state['exp_avg_sq'] = exp_avg, exp_avg_sq
return loss
class ElectraAdamWOptimizer(SuperOptimizer, ElectraAdamW):
def __init__(self, hyperparameters: Namespace, named_parameters: Generator):
super().__init__(
hyperparameters,
named_parameters_to_parameters(named_parameters),
lr=hyperparameters.learning_rate,
betas=hyperparameters.adam_betas,
eps=hyperparameters.adam_epsilon,
weight_decay=hyperparameters.weight_decay,
amsgrad=hyperparameters.amsgrad
)
def add_argparse_args(parser: ArgumentParser):
super(ElectraAdamWOptimizer, ElectraAdamWOptimizer).add_argparse_args(parser)
parser.add_argument('--learning_rate', type=float, default=1e-3)
parser.add_argument('--weight_decay', type=float, default=0.01)
parser.add_argument('--adam_epsilon', type=float, default=1e-6)
parser.add_argument('--adam_betas', nargs=2, type=float, default=[0.9, 0.999])
parser.add_argument('--amsgrad', action='store_true')