#

AMSGrad

මෙයඅ PyTorch කඩදාසි ක්රියාත්මක කිරීම ආදම් සහ ඉන් ඔබ්බට අභිසාරී වීම .

අපගේ ආදම් ප්රශස්තිකරණ ක්රියාත්මක කිරීමේ දිගුවක් ලෙස අපි මෙය ක්රියාත්මකකරමු. එය ක්රියාත්මක කිරීම ආදම්ට බෙහෙවින් සමාන බැවින් එය ස්වයංක්රීයව ක්රියාත්මක කිරීම ඇත්තෙන්ම කුඩා වේ.

ආදම්අභිසාරී වීමට අපොහොසත් වන කඩදාසි වල විස්තර කර ඇති කෘතිම උදාහරණය ක්රියාත්මක කිරීමක් ද අප සතුව ඇත.

18from typing import Dict
19
20import torch
21from torch import nn
22
23from labml_nn.optimizers import WeightDecay
24from labml_nn.optimizers.adam import Adam

#

AMSGradප්රශස්තකරණය

මෙමපන්තිය අර්ථ දක්වා ඇති ආදම් ප්රශස්තකරණයෙන් විහිදේ adam.py . ආදම් ප්රශස්තකරණය GenericAdaptiveOptimizer අර්ථ දක්වා ඇති පන්තිය දීර් ing __init__.py කරයි.

27class AMSGrad(Adam):

#

ප්රශස්තකරණයආරම්භ කරන්න

params යනු පරාමිතීන් ලැයිස්තුවයි
lr යනු ඉගෙනුම් අනුපාතයයි $α$
betas ( $β_{1}$ , $β_{2}$ ) ක tuple වේ
eps $\overset{ϵ}{^}$ හෝ මත $ϵ$ පදනම් වේ optimized_update
weight_decay WeightDecay අර්ථ දක්වා ඇති පන්තියේ අවස්ථාවකි __init__.py
'optimized_update'යනු එකතු කිරීමෙන් පසු එය කිරීමෙන් දෙවන මොහොතේ පක්ෂග්රාහීව නිවැරදි කිරීම ප්රශස්ත කිරීම සඳහා ද යන්න ධජයකි $ϵ$
amsgrad ආදම් සරල කිරීම සඳහා AMSGrad හෝ වැටීම භාවිතා කළ යුතුද යන්න දැක්වෙන ධජයකි
defaults කණ්ඩායම් අගයන් සඳහා පෙරනිමි ශබ්ද කෝෂයකි. ඔබට පන්තිය දීර් extend කිරීමට අවශ්ය විට මෙය ප්රයෝජනවත් Adam වේ.

35    def __init__(self, params, lr=1e-3, betas=(0.9, 0.999), eps=1e-16,
36                 weight_decay: WeightDecay = WeightDecay(),
37                 optimized_update: bool = True,
38                 amsgrad=True, defaults=None):

#

53        defaults = {} if defaults is None else defaults
54        defaults.update(dict(amsgrad=amsgrad))
55
56        super().__init__(params, lr, betas, eps, weight_decay, optimized_update, defaults)

#

පරාමිතිතත්වයක් ආරම්භ කරන්න

state පරාමිතිය ප්රශස්තකරණය රාජ්ය වේ (tensor)
group පරාමිති කණ්ඩායමේ ප්රශස්තිකරණ ගුණාංග ගබඩා කරයි

param පරාමිතිය tensor වේ

θ_{t - 1}

58    def init_state(self, state: Dict[str, any], group: Dict[str, any], param: nn.Parameter):

#

අපවිස්තාරණය කරන ආදම් ප්රශස්තිකරණයේ init_state ඇමතුම

68        super().init_state(state, group, param)

#

amsgrad ධජය මෙම පරාමිතිය පිරිසක් True සඳහා නම්, අපි වර්ග ඵලය අනුක්රමික ක ඝාතීය වෙනස්වන සාමාන්ය උපරිම පවත්වා

72        if group['amsgrad']:
73            state['max_exp_avg_sq'] = torch.zeros_like(param, memory_format=torch.preserve_format)

#

ගණනයකරන්න $m_{t}$ සහ $v_{t}$ හෝ $max (v_{1}, v_{2}, ..., v_{t - 1}, v_{t})$

state පරාමිතිය ප්රශස්තකරණය රාජ්ය වේ (tensor)
group පරාමිති කණ්ඩායමේ ප්රශස්තිකරණ ගුණාංග ගබඩා කරයි

grad පරාමිතිය

g_{t}

සඳහා වත්මන් ඵලය අනුක්රමික tensor වේ

θ_{t - 1}

75    def get_mv(self, state: Dict[str, any], group: Dict[str, any], grad: torch.Tensor):

#

$v_{t}$ ආදම්ගෙන් $m_{t}$ සහ ලබා ගන්න

85        m, v = super().get_mv(state, group, grad)

#

මෙමපරාමිති කණ්ඩායම භාවිතා කරන්නේ නම් amsgrad

88        if group['amsgrad']:

#

ලබාගන්න $max (v_{1}, v_{2}, ..., v_{t - 1})$ .

🗒කඩදාසි මේ $\overset{v}{^}_{t}$ සඳහා අංකනය භාවිතා කරයි, එය නැඹුරුව නිවැරදි ඝාතීය වෙනස්වන සාමාන්යය සඳහා එම අංකනය ආදම්ගේ භාවිතය සමග පටලවා නිසා අපි මෙතන බව භාවිතා කරන්නේ නැහැ.

94            v_max = state['max_exp_avg_sq']

#

ගණනයකරන්න $max (v_{1}, v_{2}, ..., v_{t - 1}, v_{t})$ .

🤔මම ඔබ වර්ග ඵලය අනුක්රමික දෙවන ඝාතීය සාමාන්ය නිවැරදි නැඹුරුව උපරිම ගැනීම/පවත්වා ගත යුතු දැනෙනවා. නමුත් එය PyTorch හි ද ක්රියාත්මක වන්නේ එලෙසිනි. පක්ෂග්රාහී නිවැරදි කිරීම පමණක් වටිනාකම වැඩි කරන අතර එය සැබෑ වෙනසක් කරන්නේ පුහුණුවේ මුල් පියවර කිහිපය තුළ පමණක් බැවින් එය සැබවින්ම වැදගත් නොවන බව මම සිතමි.

103            torch.maximum(v_max, v, out=v_max)
104
105            return m, v_max
106        else:

#

පරාමිතිකණ්ඩායම භාවිතා නොකරන්නේ නම් ආදම් වෙත ආපසු යන්න amsgrad

108            return m, v

#

කෘතිමඅත්හදා බැලීම

කඩදාසිවල විස්තර කර ඇති කෘතිම අත්හදා බැලීම මෙයයි, එය ආදම් අසමත් වන අවස්ථාවක් පෙන්වයි.

කඩදාසි(සහ ආදම්) පරාමිතීන් සම්බන්ධයෙන් ශ්රිතයක අපේක්ෂිත අගය අවම කිරීම ලෙස ප්රශස්තිකරණය කිරීමේ ගැටළුව සකස් කරයි $θ$ . $E [f (θ)]$ ස්ථිතික පුහුණු සැකසුම තුළ අපට $f$ එය ස්වයංක්රීයව ක්රියාත්මක නොවේ; එනම්, ඔබ එන්එන් ප්රශස්තිකරණය කරන විට සමස්ත දත්ත කාණ්ඩයේම ක්රියාකාරිත්වය $f$ වනු ඇත. අප ඇත්ත වශයෙන්ම ඇගයීමට ලක් කරන්නේ කුඩා කණ්ඩායමකි, එබැවින් සැබෑ කාර්යය වන්නේ ස්ටෝචාස්ටික් සාක්ෂාත් කර $f$ ගැනීමයි. මේ නිසා අපි කතා කරන්නේ අපේක්ෂිත වටිනාකමක් ගැන ය. එබැවින් පුහුණුවීමේ එක් එක් කාල පියවර $f_{1}, f_{2}, ..., f_{T}$ සඳහා ශ්රිතය අවබෝධ කර ගැනීම ඉඩ දෙන්න.

අපිප්රශස්තිකරණයේ ක්රියාකාරිත්වය කනගාටුව ලෙස මනින්නෙමු, කාල පියවරේදී පරාමිතීන් $R (T) = t = 1 \sum T [f_{t} (θ_{t}) - f_{t} (θ^{*})]$ $θ_{t}$ කොතැනද $t$ , සහ ප්රශස්ත $θ^{*}$ වේ අවම කරන පරාමිතීන් $E [f (θ)]$ .

දැන්කෘතිම ගැටළුව නිර්වචනය කිරීමට ඉඩ දෙයි,

f_{t} (x) = {1010 x, - 10 x, f or t mod 101 = 1 o t herwise

කොහෙද $- 1 \leq x \leq + 1$ . ප්රශස්ත විසඳුම වේ $x = - 1$ .

මෙමකේතය මෙම ගැටලුව මත ආදම් සහ AMSGrad ධාවනය කිරීමට උත්සාහ කරනු ඇත.

111def _synthetic_experiment(is_adam: bool):

#

$x$ පරාමිතිය නිර්වචනය

153    x = nn.Parameter(torch.tensor([.0]))

#

ප්රශස්ත, $x^{*} = - 1$

155    x_star = nn.Parameter(torch.tensor([-1]), requires_grad=False)

#

$f_{t} (x)$

157    def func(t: int, x_: nn.Parameter):

#

161        if t % 101 == 1:
162            return (1010 * x_).sum()
163        else:
164            return (-10 * x_).sum()

#

අදාළප්රශස්තකරණය ආරම්භ කරන්න

167    if is_adam:
168        optimizer = Adam([x], lr=1e-2, betas=(0.9, 0.99))
169    else:
170        optimizer = AMSGrad([x], lr=1e-2, betas=(0.9, 0.99))

#

$R (T)$

172    total_regret = 0
173
174    from labml import monit, tracker, experiment

#

ප්රතිඵලවාර්තා කිරීමට අත්හදා නිර්මාණය

177    with experiment.record(name='synthetic', comment='Adam' if is_adam else 'AMSGrad'):

#

$1 0^{7}$ පියවර සඳහා ධාවනය කරන්න

179        for step in monit.loop(10_000_000):

#

$f_{t} (θ_{t}) - f_{t} (θ^{*})$

181            regret = func(step, x) - func(step, x_star)

#

$R (T) = \sum_{t = 1}^{T} [f_{t} (θ_{t}) - f_{t} (θ^{*})]$

183            total_regret += regret.item()

#

සෑමපියවර 1,000 කට වරක් ප්රති results ල

185            if (step + 1) % 1000 == 0:
186                tracker.save(loss=regret, x=x, regret=total_regret / (step + 1))

#

අනුක්රමිකගණනය කරන්න

188            regret.backward()

#

ප්රශස්තකරන්න

190            optimizer.step()

#

අනුක්රමිකපැහැදිලි කරන්න

192            optimizer.zero_grad()

#

වගබලා ගන්න $- 1 \leq x \leq + 1$

195            x.data.clamp_(-1., +1.)
196
197
198if __name__ == '__main__':

#

කෘතිමඅත්හදා බැලීම ක්රියාත්මක කරන්න ආදම්. මෙන්න ප්රතිඵල. ආදම් අභිසාරී වන බව ඔබට පෙනේ $x = + 1$

202    _synthetic_experiment(True)

#

කෘතිමඅත්හදා බැලීම ක්රියාත්මක කරන්න AMSGrad මෙන්න ප්රති. ල. AMSGrad සැබෑ ප්රශස්ත බවට අභිසාරී වන බව ඔබට දැක ගත හැකිය $x = - 1$

206    _synthetic_experiment(False)