#

ප්රශස්තකරණය

ප්රශස්තිකරණක්රියාත්මක කිරීම්

මෙම MNIST උදාහරණය මෙම ප්රශස්තකරණය භාවිතා කරයි.

Genericබලපත්රය යටතේ අවසර ලබා ඇත අනුවර්තී ප්රතිස්ඨාපනය මූලික පන්තිය

මෙමගොනුව ආදම් සහ එහි දිගු සඳහා පොදු පාදක පන්තියක් අර්ථ දක්වයි. මූලික පන්තිය භාවිතා කිරීමට උපකාරී වේ නැවත භාවිතා කිරීමේ හැකියාව නිසා අවම කේතයක් සහිත වෙනත් ප්රශස්තිකාරක ක්රියාත්මක කරන්න.

එල්2 බර ක්ෂය වීම සඳහා විශේෂ පන්තියක් ද අපි අර්ථ දක්වන්නෙමු, එවිට එක් එක් ප්රශස්තකරණය තුළ එය ක්රියාත්මක කිරීමට අපට අවශ්ය නොවන අතර ප්රශස්තිකාරක වෙනස් නොකර L1 වැනි වෙනත් බර දිරාපත් විය හැකිය.

PyTorchප්රශස්තකරණය පිළිබඳ සංකල්ප කිහිපයක් මෙන්න:

පරාමිතිකණ්ඩායම්

PyTorchකණ්ඩායම් පරාමිතීන් කණ්ඩායම් ලෙස හැඳින්වෙන කට්ටලවලට ප්රශස්තිකරණය කරයි. සෑම කණ්ඩායමකටම ඉගෙනුම් අනුපාත වැනි තමන්ගේම අධි පරාමිතීන් තිබිය හැකිය.

බොහෝපොදු අවස්ථාවන්හිදී එක් කණ්ඩායමක් පමණක් වනු ඇත. මෙය ඔබ ඔබේ ප්රශස්තකරණය ආරම්භ කරන විට,

Optimizer(model.parameters())

ප්රශස්තකරණයආරම්භ කිරීමේදී ඔබට බහු පරාමිති කණ්ඩායම් නිර්වචනය කළ හැකිය:

Optimizer([{'params': model1.parameters()}, {'params': model2.parameters(), 'lr': 2}])

මෙන්නඅපි කණ්ඩායම් ලැයිස්තුවක් සම්මත කරමු. සෑම කණ්ඩායමක්ම 'පරාමිති' යන යතුර යටතේ එහි පරාමිතීන් සහිත ශබ්දකෝෂයකි. ඔබ ඕනෑම අධි-පරාමිතීන් ද සඳහන් කරයි. අධි පරාමිතීන් අර්ථ දක්වා නොමැති නම් ඒවා ප්රශස්තිකරණ මට්ටමේ පෙරනිමි වෙත පෙරනිමිය වනු ඇත.

ඔබටමෙම කණ්ඩායම් වලට ප්රවේශ විය හැකිය (සහ පවා වෙනස් කරන්න), සහ ඒවායේ අධි-පරාමිතීන් සමඟ optimizer.param_groups . මට හමු වී ඇති බොහෝ ඉගෙනුම් අනුපාත කාලසටහන් ක්රියාත්මක කිරීම් මෙයට ප්රවේශ වී 'lr' වෙනස් කරයි.

ජනපදය

ප්රශස්තකරණයශබ්දකෝෂයක එක් එක් පරාමිතිය සඳහා (ටෙන්සර්) ප්රාන්ත (ශබ්දකෝෂයක්) පවත්වා ගනී optimizer.state . ප්රශස්තකරණය on ාතීය සාමාන්යය වැනි දේවල් පවත්වා ගෙන යන්නේ මෙහිදීය.

62from typing import Dict, Tuple, Any
63
64import torch
65from torch import nn
66from torch.optim.optimizer import Optimizer

#

ආදම් සහ දිගු සඳහා මූලික පන්තිය

69class GenericAdaptiveOptimizer(Optimizer):

#

ආරම්භකරන්න

params යනු පරාමිති එකතු කිරීම හෝ පරාමිති කණ්ඩායම් සමූහයකි.
defaults පෙරනිමි අධි-පරාමිතීන්ගේ ශබ්ද කෝෂයක්
lr ඉගෙනුම් අනුපාතය, $α$
betas මෙම tuple වේ $(β_{1}, β_{2})$

eps වේ

ϵ

74    def __init__(self, params, defaults: Dict[str, Any], lr: float, betas: Tuple[float, float], eps: float):

#

අධි-පරාමිතීන්පරීක්ෂා කරන්න

86        if not 0.0 <= lr:
87            raise ValueError(f"Invalid learning rate: {lr}")
88        if not 0.0 <= eps:
89            raise ValueError(f"Invalid epsilon value: {eps}")
90        if not 0.0 <= betas[0] < 1.0:
91            raise ValueError(f"Invalid beta parameter at index 0: {betas[0]}")
92        if not 0.0 <= betas[1] < 1.0:
93            raise ValueError(f"Invalid beta parameter at index 1: {betas[1]}")

#

පෙරනිමිසඳහා අධි-පරාමිතීන් එකතු කරන්න

96        defaults.update(dict(lr=lr, betas=betas, eps=eps))

#

PyTorchප්රශස්තකරණය ආරම්භ කරන්න. මෙය පෙරනිමි අධි-පරාමිතීන් සහිත පරාමිති කණ්ඩායම් නිර්මාණය කරනු ඇත

99        super().__init__(params, defaults)

#

දීඇති පරාමිතිය tensor සඳහා රාජ්ය ආරම්භ

පරාමිතීන් state සඳහා ආරම්භ කිරීම සඳහා මෙය කේතය සමඟ ඉක්මවා යා යුතුය param . group යනු පරාමිති කණ්ඩායම් ශබ්ද කෝෂය param අයත් වේ.

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

#

108        pass

#

පරාමිතිආතතියක් මත ප්රශස්තිකරණ පියවර ගන්න

මෙමoverridden හා param tensor මත ප්රශස්තිකරණය පියවර ගත යුතු $θ$ , එම පරාමිතිය සඳහා ඵලය අනුක්රමික කොහෙද grad , $g_{t}$ , state යනු එම පරාමිතිය සඳහා ප්රශස්තිකරණ රාජ්ය ශබ්ද කෝෂය group වන අතර පරාමිති කණ්ඩායම් param ශබ්දකෝෂයට අයත් වේ.

110    def step_param(self, state: Dict[str, any], group: Dict[str, any], grad: torch.Tensor, param: torch.Tensor):

#

119        pass

#

පියවරප්රශස්තකරණය

ආදම් මත පදනම් වූ ප්රශස්තිකරණ අවශ්යතා සෑම පොදු දේවල් කරන අච්චු ක්රමයක් අපි නිර්මාණය කර ඇත්තෙමු.

121    @torch.no_grad()
122    def step(self, closure=None):

#

අලාභයගණනය කරන්න.

🤔ඔබට මෙය අවශ්ය විට මට විශ්වාස නැත. මම හිතන්නේ එය ඔබ අලාභය ගණනය කරන, කරන loss.backward සහ අලාභය ආපසු ලබා දෙන ශ්රිතයක් අර්ථ දැක්වුවහොත්, එය තනිවම අමතනවා වෙනුවට ඔබට එය සම්මත කළ හැකිය optimizer.step . 🤷‍♂️

133        loss = None
134        if closure is not None:
135            with torch.enable_grad():
136                loss = closure()

#

පරාමිතිකණ්ඩායම් හරහා නැවත ක්රියාත්මක කරන්න

139        for group in self.param_groups:

#

පරාමිතිකණ්ඩායමේ පරාමිතීන් හරහා නැවත ක්රියාත්මක කරන්න

141            for param in group['params']:

#

පරාමිතියටකිසිදු අනුක්රමික නොමැති නම් මඟ හරින්න

143                if param.grad is None:
144                    continue

#

ශ්රේණියේආතතිය ලබා ගන්න

146                grad = param.grad.data

#

අපිවිරල අනුක්රමික හැසිරවිය නැහැ

148                if grad.is_sparse:
149                    raise RuntimeError('GenericAdaptiveOptimizer does not support sparse gradients,'
150                                       ' please consider SparseAdam instead')

#

පරාමිතියසඳහා රාජ්ය ලබා ගන්න

153                state = self.state[param]

#

රාජ්යuninitialized නම් රාජ්ය ආරම්භ

156                if len(state) == 0:
157                    self.init_state(state, group, param)

#

පරාමිතියමත ප්රශස්තිකරණ පියවර ගන්න

160                self.step_param(state, group, grad, param)

#

වසාදැමීමෙන් ගණනය කරන ලද අලාභය ආපසු ලබා දෙන්න

163        return loss

#

L2සිරුරේ බර ක්ෂය

166class WeightDecay:

#

බරක්ෂය වීම ආරම්භ කරන්න

weight_decay ක්ෂය සංගුණකය වේ
weight_decouple යනු බර ක්ෂය වීම ශ්රේණියට එකතු කළ යුතුද යන්න හෝ පරාමිතියෙන් කෙලින්ම ක්ෂය වීම පෙන්නුම් කරන ධජයකි. ශ්රේණියට එකතු කළහොත් එය සාමාන්ය ප්රශස්තිකරණ යාවත්කාලීනය හරහා ගමන් කරයි.
absolute මෙම ධජය මඟින් බර ක්ෂය වීමේ සංගුණකය නිරපේක්ෂ ද යන්න පෙන්නුම් කරයි. ක්ෂය වීම පරාමිතිය මත සෘජුවම සිදු කරන විට මෙය අදාළ වේ. මෙය අසත්යයක් නම් සැබෑ ක්ෂය වීමයි weight_decay
learning_rate .

171    def __init__(self, weight_decay: float = 0., weight_decouple: bool = True, absolute: bool = False):

#

අධිපරාමිතීන් පරීක්ෂා කරන්න

184        if not 0.0 <= weight_decay:
185            raise ValueError(f"Invalid weight_decay value: {weight_decay}")
186
187        self.absolute = absolute
188        self.weight_decouple = weight_decouple
189        self.weight_decay = weight_decay

#

පරාමිතිකණ්ඩායම් සඳහා ආපසු පැහැර හැරීම්

191    def defaults(self):

#

195        return dict(weight_decay=self.weight_decay)

#

බරක්ෂය වීම සිදු කර ශ්රේණිය නැවත ලබා දෙන්න

197    def __call__(self, param: torch.nn.Parameter, grad: torch.Tensor, group: Dict[str, any]):

#

අපිපරාමිතිය මත ක්ෂය වීම කෙලින්ම කරන්නේ නම්

203        if self.weight_decouple:

#

බරක්ෂය වීමේ සංගුණකය නිරපේක්ෂ නම්

205            if self.absolute:
206                param.data.mul_(1.0 - group['weight_decay'])

#

එසේනොමැති නම්

208            else:
209                param.data.mul_(1.0 - group['lr'] * group['weight_decay'])

#

නවීකරණයනොකළ ශ්රේණිය ආපසු ලබා දෙන්න

211            return grad
212        else:
213            if group['weight_decay'] != 0:

#

බරක්ෂය වීම ශ්රේණියට එකතු කර නවීකරණය කරන ලද ශ්රේණිය නැවත ලබා දෙන්න

215                return grad.add(param.data, alpha=group['weight_decay'])
216            else:
217                return grad