docs/si/optimizers/index.html
[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/optimizers/ init.py)
මෙම MNIST උදාහරණය මෙම ප්රශස්තකරණය භාවිතා කරයි.
මෙමගොනුව ආදම් සහ එහි දිගු සඳහා පොදු පාදක පන්තියක් අර්ථ දක්වයි. මූලික පන්තිය භාවිතා කිරීමට උපකාරී වේ නැවත භාවිතා කිරීමේ හැකියාව නිසා අවම කේතයක් සහිත වෙනත් ප්රශස්තිකාරක ක්රියාත්මක කරන්න.
එල්2 බර ක්ෂය වීම සඳහා විශේෂ පන්තියක් ද අපි අර්ථ දක්වන්නෙමු, එවිට එක් එක් ප්රශස්තකරණය තුළ එය ක්රියාත්මක කිරීමට අපට අවශ්ය නොවන අතර ප්රශස්තිකාරක වෙනස් නොකර L1 වැනි වෙනත් බර දිරාපත් විය හැකිය.
PyTorchප්රශස්තකරණය පිළිබඳ සංකල්ප කිහිපයක් මෙන්න:
PyTorchකණ්ඩායම් පරාමිතීන් කණ්ඩායම් ලෙස හැඳින්වෙන කට්ටලවලට ප්රශස්තිකරණය කරයි. සෑම කණ්ඩායමකටම ඉගෙනුම් අනුපාත වැනි තමන්ගේම අධි පරාමිතීන් තිබිය හැකිය.
බොහෝපොදු අවස්ථාවන්හිදී එක් කණ්ඩායමක් පමණක් වනු ඇත. මෙය ඔබ ඔබේ ප්රශස්තකරණය ආරම්භ කරන විට,
Optimizer(model.parameters())
ප්රශස්තකරණයආරම්භ කිරීමේදී ඔබට බහු පරාමිති කණ්ඩායම් නිර්වචනය කළ හැකිය:
Optimizer([{'params': model1.parameters()}, {'params': model2.parameters(), 'lr': 2}])
මෙන්නඅපි කණ්ඩායම් ලැයිස්තුවක් සම්මත කරමු. සෑම කණ්ඩායමක්ම 'පරාමිති' යන යතුර යටතේ එහි පරාමිතීන් සහිත ශබ්දකෝෂයකි. ඔබ ඕනෑම අධි-පරාමිතීන් ද සඳහන් කරයි. අධි පරාමිතීන් අර්ථ දක්වා නොමැති නම් ඒවා ප්රශස්තිකරණ මට්ටමේ පෙරනිමි වෙත පෙරනිමිය වනු ඇත.
ඔබටමෙම කණ්ඩායම් වලට ප්රවේශ විය හැකිය (සහ පවා වෙනස් කරන්න), සහ ඒවායේ අධි-පරාමිතීන් සමඟ optimizer.param_groups . මට හමු වී ඇති බොහෝ ඉගෙනුම් අනුපාත කාලසටහන් ක්රියාත්මක කිරීම් මෙයට ප්රවේශ වී 'lr' වෙනස් කරයි.
ප්රශස්තකරණයශබ්දකෝෂයක එක් එක් පරාමිතිය සඳහා (ටෙන්සර්) ප්රාන්ත (ශබ්දකෝෂයක්) පවත්වා ගනී optimizer.state . ප්රශස්තකරණය on ාතීය සාමාන්යය වැනි දේවල් පවත්වා ගෙන යන්නේ මෙහිදීය.
62fromtypingimportDict,Tuple,Any6364importtorch65fromtorchimportnn66fromtorch.optim.optimizerimportOptimizer
69classGenericAdaptiveOptimizer(Optimizer):
params යනු පරාමිති එකතු කිරීම හෝ පරාමිති කණ්ඩායම් සමූහයකි.
defaults පෙරනිමි අධි-පරාමිතීන්ගේ ශබ්ද කෝෂයක්
lr ඉගෙනුම් අනුපාතය, α
betas මෙම tuple වේ (β1,β2)
eps වේ ϵ
74def\_\_init\_\_(self,params,defaults:Dict[str,Any],lr:float,betas:Tuple[float,float],eps:float):
අධි-පරාමිතීන්පරීක්ෂා කරන්න
86ifnot0.0\<=lr:87raiseValueError(f"Invalid learning rate: {lr}")88ifnot0.0\<=eps:89raiseValueError(f"Invalid epsilon value: {eps}")90ifnot0.0\<=betas[0]\<1.0:91raiseValueError(f"Invalid beta parameter at index 0: {betas[0]}")92ifnot0.0\<=betas[1]\<1.0:93raiseValueError(f"Invalid beta parameter at index 1: {betas[1]}")
පෙරනිමිසඳහා අධි-පරාමිතීන් එකතු කරන්න
96defaults.update(dict(lr=lr,betas=betas,eps=eps))
PyTorchප්රශස්තකරණය ආරම්භ කරන්න. මෙය පෙරනිමි අධි-පරාමිතීන් සහිත පරාමිති කණ්ඩායම් නිර්මාණය කරනු ඇත
99super().\_\_init\_\_(params,defaults)
පරාමිතීන් state සඳහා ආරම්භ කිරීම සඳහා මෙය කේතය සමඟ ඉක්මවා යා යුතුය param . group යනු පරාමිති කණ්ඩායම් ශබ්ද කෝෂය param අයත් වේ.
101definit\_state(self,state:Dict[str,any],group:Dict[str,any],param:nn.Parameter):
108pass
මෙමoverridden හා param tensor මත ප්රශස්තිකරණය පියවර ගත යුතු θ, එම පරාමිතිය සඳහා ඵලය අනුක්රමික කොහෙද grad , gt, state යනු එම පරාමිතිය සඳහා ප්රශස්තිකරණ රාජ්ය ශබ්ද කෝෂය group වන අතර පරාමිති කණ්ඩායම් param ශබ්දකෝෂයට අයත් වේ.
110defstep\_param(self,state:Dict[str,any],group:Dict[str,any],grad:torch.Tensor,param:torch.Tensor):
119pass
ආදම් මත පදනම් වූ ප්රශස්තිකරණ අවශ්යතා සෑම පොදු දේවල් කරන අච්චු ක්රමයක් අපි නිර්මාණය කර ඇත්තෙමු.
[email protected]\_grad()122defstep(self,closure=None):
අලාභයගණනය කරන්න.
🤔ඔබට මෙය අවශ්ය විට මට විශ්වාස නැත. මම හිතන්නේ එය ඔබ අලාභය ගණනය කරන, කරන loss.backward සහ අලාභය ආපසු ලබා දෙන ශ්රිතයක් අර්ථ දැක්වුවහොත්, එය තනිවම අමතනවා වෙනුවට ඔබට එය සම්මත කළ හැකිය optimizer.step . 🤷♂️
133loss=None134ifclosureisnotNone:135withtorch.enable\_grad():136loss=closure()
පරාමිතිකණ්ඩායම් හරහා නැවත ක්රියාත්මක කරන්න
139forgroupinself.param\_groups:
පරාමිතිකණ්ඩායමේ පරාමිතීන් හරහා නැවත ක්රියාත්මක කරන්න
141forparamingroup['params']:
පරාමිතියටකිසිදු අනුක්රමික නොමැති නම් මඟ හරින්න
143ifparam.gradisNone:144continue
ශ්රේණියේආතතිය ලබා ගන්න
146grad=param.grad.data
අපිවිරල අනුක්රමික හැසිරවිය නැහැ
148ifgrad.is\_sparse:149raiseRuntimeError('GenericAdaptiveOptimizer does not support sparse gradients,'150' please consider SparseAdam instead')
පරාමිතියසඳහා රාජ්ය ලබා ගන්න
153state=self.state[param]
රාජ්යuninitialized නම් රාජ්ය ආරම්භ
156iflen(state)==0:157self.init\_state(state,group,param)
පරාමිතියමත ප්රශස්තිකරණ පියවර ගන්න
160self.step\_param(state,group,grad,param)
වසාදැමීමෙන් ගණනය කරන ලද අලාභය ආපසු ලබා දෙන්න
163returnloss
166classWeightDecay:
weight_decay ක්ෂය සංගුණකය වේweight_decouple යනු බර ක්ෂය වීම ශ්රේණියට එකතු කළ යුතුද යන්න හෝ පරාමිතියෙන් කෙලින්ම ක්ෂය වීම පෙන්නුම් කරන ධජයකි. ශ්රේණියට එකතු කළහොත් එය සාමාන්ය ප්රශස්තිකරණ යාවත්කාලීනය හරහා ගමන් කරයි.absolute මෙම ධජය මඟින් බර ක්ෂය වීමේ සංගුණකය නිරපේක්ෂ ද යන්න පෙන්නුම් කරයි. ක්ෂය වීම පරාමිතිය මත සෘජුවම සිදු කරන විට මෙය අදාළ වේ. මෙය අසත්යයක් නම් සැබෑ ක්ෂය වීමයි weight_decaylearning_rate .171def\_\_init\_\_(self,weight\_decay:float=0.,weight\_decouple:bool=True,absolute:bool=False):
අධිපරාමිතීන් පරීක්ෂා කරන්න
184ifnot0.0\<=weight\_decay:185raiseValueError(f"Invalid weight\_decay value: {weight\_decay}")186187self.absolute=absolute188self.weight\_decouple=weight\_decouple189self.weight\_decay=weight\_decay
පරාමිතිකණ්ඩායම් සඳහා ආපසු පැහැර හැරීම්
191defdefaults(self):
195returndict(weight\_decay=self.weight\_decay)
197def\_\_call\_\_(self,param:torch.nn.Parameter,grad:torch.Tensor,group:Dict[str,any]):
අපිපරාමිතිය මත ක්ෂය වීම කෙලින්ම කරන්නේ නම්
203ifself.weight\_decouple:
බරක්ෂය වීමේ සංගුණකය නිරපේක්ෂ නම්
205ifself.absolute:206param.data.mul\_(1.0-group['weight\_decay'])
එසේනොමැති නම්
208else:209param.data.mul\_(1.0-group['lr']\*group['weight\_decay'])
නවීකරණයනොකළ ශ්රේණිය ආපසු ලබා දෙන්න
211returngrad212else:213ifgroup['weight\_decay']!=0:
බරක්ෂය වීම ශ්රේණියට එකතු කර නවීකරණය කරන ලද ශ්රේණිය නැවත ලබා දෙන්න
215returngrad.add(param.data,alpha=group['weight\_decay'])216else:217returngrad