docs/si/lstm/index.html
[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/lstm/ init.py)
මෙය PyTorch දිගු කෙටි කාලීන මතකය ක්රියාත්මක කිරීමයි.
12fromtypingimportOptional,Tuple1314importtorch15fromtorchimportnn1617fromlabml\_helpers.moduleimportModule
LSTMසෛල ගණනය c, සහ h. c දිගු කාලීන මතකය හා සමාන වන අතර h එය කෙටිකාලීන මතකය හා සමාන වේ. අපි ආදානය x සහ දිගු කාලීන මතකය යාවත්කාලීන h කිරීමට භාවිතා කරමු. යාවත්කාලීනයේදී, සමහර අංග අමතක කිරීමේ c fගේට්ටුවකින් ඉවත් කර ඇති අතර සමහර විශේෂාංග ගේට්ටුවක් හරහා එකතු i වේ g.
නවකෙටිකාලීන මතකය යනු ප්රතිදාන ගේට්ටුවෙන් ගුණ කරන දිගු කාලීන මතකයයි o. tanh
යාවත්කාලීනයසිදු කරන c විට සෛලය දිගු කාලීන මතකය දෙස නොබලන බව සලකන්න. එය වෙනස් කරන්නේ එය පමණි. එසේම c කිසි විටෙකත් රේඛීය පරිවර්තනයක් හරහා නොයයි. අතුරුදහන් වීම සහ පුපුරා යන ශ්රේණිය විසඳන්නේ මෙයයි.
මෙන්නයාවත්කාලීන රීතිය.
ctht=σ(ft)⊙ct−1+σ(it)⊙tanh(gt)=σ(ot)⊙tanh(ct)
⊙ මූලද්රව්ය-නැණවත් ගුණ කිරීම සඳහා වේ.
අතරමැදිඅගයන් සහ ගේට්ටු සැඟවුණු තත්වයේ සහ ආදානයේ රේඛීය පරිවර්තනයන් ලෙස ගණනය කෙරේ.
itftgtot=linxi(xt)+linhi(ht−1)=linxf(xt)+linhf(ht−1)=linxg(xt)+linhg(ht−1)=linxo(xt)+linho(ht−1)
20classLSTMCell(Module):
57def\_\_init\_\_(self,input\_size:int,hidden\_size:int,layer\_norm:bool=False):58super().\_\_init\_\_()
මේවා input සහ hidden දෛශික පරිවර්තනය කිරීම සඳහා රේඛීය ස්තරය වේ. අපි පරිවර්තනයන් එකතු කරන බැවින් ඒවායින් එකකට නැඹුරුවක් අවශ්ය නොවේ.
මෙයඒකාබද්ධ linxi, linxflinxg, සහ linxo පරිවර්තනයන්.
64self.hidden\_lin=nn.Linear(hidden\_size,4\*hidden\_size)
මෙයඒකාබද්ධ linhi, linhflinhg, සහ linho පරිවර්තනයන්.
66self.input\_lin=nn.Linear(input\_size,4\*hidden\_size,bias=False)
ස්ථරසාමාන්යකරණය යෙදිය යුතුද යන්න.
ස්ථරසාමාන්යකරණය කිරීම වඩා හොඳ ප්රති. ල ලබා දෙයි. i, f, g සහ o කාවැද්දීම් සාමාන්යකරණය කර ඇති අතර ct එය සාමාන්යකරණය වේ ht=ot⊙tanh(LN(ct))
73iflayer\_norm:74self.layer\_norm=nn.ModuleList([nn.LayerNorm(hidden\_size)for\_inrange(4)])75self.layer\_norm\_c=nn.LayerNorm(hidden\_size)76else:77self.layer\_norm=nn.ModuleList([nn.Identity()for\_inrange(4)])78self.layer\_norm\_c=nn.Identity()
80defforward(self,x:torch.Tensor,h:torch.Tensor,c:torch.Tensor):
අපිරේඛීය පරිවර්තනයන් ගණනය කරමු itft, gt සහ එකම රේඛීය ස්ථර ot භාවිතා කිරීම.
83ifgo=self.hidden\_lin(h)+self.input\_lin(x)
සෑමස්ථරයක්ම 4 ගුණයක ප්රතිදානයක් නිපදවන hidden_size අතර අපි ඒවා බෙදුවෙමු
85ifgo=ifgo.chunk(4,dim=-1)
ස්ථරසාමාන්යකරණය යොදන්න (මුල් කඩදාසිවල නොව, වඩා හොඳ ප්රතිඵල ලබා දෙයි)
88ifgo=[self.layer\_norm[i](ifgo[i])foriinrange(4)]
it,ft,gt,ot
91i,f,g,o=ifgo
ct=σ(ft)⊙ct−1+σ(it)⊙tanh(gt)
94c\_next=torch.sigmoid(f)\*c+torch.sigmoid(i)\*torch.tanh(g)
ht=σ(ot)⊙tanh(ct) විකල්පයක් ලෙස, ස්ථර සම්මතය යොදන්න ct
98h\_next=torch.sigmoid(o)\*torch.tanh(self.layer\_norm\_c(c\_next))99100returnh\_next,c\_next
103classLSTM(Module):
LSTMජාලයක් සාදන්න. n_layers
108def\_\_init\_\_(self,input\_size:int,hidden\_size:int,n\_layers:int):
113super().\_\_init\_\_()114self.n\_layers=n\_layers115self.hidden\_size=hidden\_size
එක්එක් ස්ථරය සඳහා සෛල සාදන්න. පළමු ස්ථරයට පමණක් ආදානය කෙලින්ම ලැබෙන බව සලකන්න. සෙසු ස්ථර පහත ස්ථරයෙන් ආදානය ලබා ගනී
118self.cells=nn.ModuleList([LSTMCell(input\_size,hidden\_size)]+119[LSTMCell(hidden\_size,hidden\_size)for\_inrange(n\_layers-1)])
x හැඩය ඇති [n_steps, batch_size, input_size] අතර state එය ටූල් එකක් cවන h අතර එක් එක් හැඩයකින් යුක්ත වේ [batch_size, hidden_size] .
121defforward(self,x:torch.Tensor,state:Optional[Tuple[torch.Tensor,torch.Tensor]]=None):
126n\_steps,batch\_size=x.shape[:2]
රාජ්යයආරම්භ කරන්න නම් None
129ifstateisNone:130h=[x.new\_zeros(batch\_size,self.hidden\_size)for\_inrange(self.n\_layers)]131c=[x.new\_zeros(batch\_size,self.hidden\_size)for\_inrange(self.n\_layers)]132else:133(h,c)=state
එක්එක් ස්ථරයේ තත්වයන් ලබා ගැනීම සඳහා ආතතීන් ආපසු හරවන්න
📝ඔබට ටෙන්සර් සමඟ වැඩ කළ හැකි නමුත් මෙය නිදොස් කිරීමට පහසුය
137h,c=list(torch.unbind(h)),list(torch.unbind(c))
එක්එක් කාල පියවරේදී අවසාන ස්ථරයේ ප්රතිදානයන් එකතු කිරීමට අරා.
140out=[]141fortinrange(n\_steps):
පළමුස්ථරයට ආදානය යනු ආදානය ම වේ
143inp=x[t]
ස්ථරහරහා ලූප්
145forlayerinrange(self.n\_layers):
ස්ථරයේතත්වය ලබා ගන්න
147h[layer],c[layer]=self.cells[layer](inp,h[layer],c[layer])
ඊළඟස්ථරයට ආදානය මෙම ස්ථරයේ තත්වයයි
149inp=h[layer]
අවසාන h ස්ථරයේ ප්රතිදානය එකතු කරන්න
151out.append(h[-1])
ප්රතිදානයන්සහ ප්රාන්ත ගොඩගසන්න
154out=torch.stack(out)155h=torch.stack(h)156c=torch.stack(c)157158returnout,(h,c)