homerecurrent_highway_networks

[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/recurrent_highway_networks/ init.py)

#

පුනරාවර්තනඅධිවේගී මාර්ග ජාල

මෙය පුනරාවර්තන අධිවේගී මාර්ග ජාල වල PyTorch ක්රියාත්මක කිරීමයි.

11fromtypingimportOptional1213importtorch14fromtorchimportnn1516fromlabml\_helpers.moduleimportModule

#

පුනරාවර්තනඅධිවේගී මාර්ගයේ ජාලය කල

මෙයසමීකරණ ක්රියාත්මක කරයි (6)−(9).

sdt​=hdt​⊙gdt​+sd−1t​⊙cdt​

කොහේද

h0t​g0t​c0t​​=tanh(linhx​(x)+linhs​(sDt−1​))=σ(lingx​(x)+lings​1(sDt−1​))=σ(lincx​(x)+lincs1​(sDt−1​))​

සහසඳහා 0<d<D

hdt​gdt​cdt​​=tanh(linhs​d(sdt​))=σ(lings​d(sdt​))=σ(lincsd​(sdt​))​

⊙ මූලද්රව්ය-නැණවත් ගුණ කිරීම සඳහා වේ.

මෙන්නඅපි කඩදාසි වලින් අංකවල වෙනස්කම් කිහිපයක් කර ඇත්තෙමු. කාලය සමඟ ව්යාකූලත්වය වළක්වා ගැනීම සඳහා g, ගේට්ටුව කඩදාසි t තුළ ඇති විය. බහු ස්ථර සමඟ ව්යාකූලත්වය වළක්වා ගැනීම d සඳහා අපි කඩදාසි වෙනුවට සහ ඉන් l ගැඹුර D සඳහා ගැඹුර සඳහා භාවිතා කරමු. L

සමීකරණවලින් බර මැට්ට්රිස් සහ පක්ෂග්රාහී දෛශික රේඛීය පරිවර්තනයන් සමඟ ප්රතිස්ථාපනය කර ඇත, මන්ද එය ක්රියාත්මක කිරීම පෙනෙන්නේ එලෙසිනි.

කඩදාසිවල විස්තර කර ඇති පරිදි අපි බර ගැටගැසීම ක්රියාත්මක කරමු cdt​=1−gdt​.

19classRHNCell(Module):

#

input_size යනු ආදානයේ විශේෂාංග දිග hidden_size වන අතර එය සෛලයේ විශේෂාංග දිග වේ. depth වේ D.

57def\_\_init\_\_(self,input\_size:int,hidden\_size:int,depth:int):

#

63super().\_\_init\_\_()6465self.hidden\_size=hidden\_size66self.depth=depth

#

අපිතනි රේඛීය ස්ථරයක් සමඟ ඒකාබද්ධ linhs​ කරමු. lings​ එවිට අපට linhs​ සහ lings​ සංරචක ලබා ගැනීම සඳහා ප්රති results ල බෙදිය හැකිය. මෙය linhs​d සහ lings​d සඳහා 0≤d<Dය.

70self.hidden\_lin=nn.ModuleList([nn.Linear(hidden\_size,2\*hidden\_size)for\_inrange(depth)])

#

ඒහා සමානව අපි ඒකාබද්ධ linhx​ වෙමු lingx​.

73self.input\_lin=nn.Linear(input\_size,2\*hidden\_size,bias=False)

#

x හැඩය s ඇති [batch_size, input_size] අතර හැඩය [batch_size, hidden_size] ඇත.

75defforward(self,x:torch.Tensor,s:torch.Tensor):

#

පුනරාවර්තනයකරන්න 0≤d<D

82fordinrange(self.depth):

#

රේඛීයපරිණාමයන්ගේ සංකෝචනය ගණනය කිරීම h සහ g

84ifd==0:

#

ආදානයභාවිතා d වන්නේ කවදාද යන්න පමණි 0.

86hg=self.input\_lin(x)+self.hidden\_lin[d](s)87else:88hg=self.hidden\_lin[d](s)

#

ලබාගැනීමට පළමු භාගය භාවිතා hg කරන්න hdt​

h0t​hdt​​=tanh(linhx​(x)+linhs​(sDt−1​))=tanh(linhs​d(sdt​))​

96h=torch.tanh(hg[:,:self.hidden\_size])

#

ලබාගැනීමට දෙවන භාගය භාවිතා hg කරන්න gdt​

g0t​gdt​​=σ(lingx​(x)+lings​1(sDt−1​))=σ(lings​d(sdt​))​

103g=torch.sigmoid(hg[:,self.hidden\_size:])104105s=h\*g+s\*(1-g)106107returns

#

බහුස්ථර පුනරාවර්තන අධිවේගී මාර්ග ජාලය

110classRHN(Module):

#

පුනරාවර්තනඅධිවේගී මාර්ග ජාල ස්ථර ජාලයක් නිර්මාණය කරන්න, එක් එක් ගැඹුර depth , D. n_layers

115def\_\_init\_\_(self,input\_size:int,hidden\_size:int,depth:int,n\_layers:int):

#

120super().\_\_init\_\_()121self.n\_layers=n\_layers122self.hidden\_size=hidden\_size

#

එක්එක් ස්ථරය සඳහා සෛල සාදන්න. පළමු ස්ථරයට පමණක් ආදානය කෙලින්ම ලැබෙන බව සලකන්න. සෙසු ස්ථර පහත ස්ථරයෙන් ආදානය ලබා ගනී

125self.cells=nn.ModuleList([RHNCell(input\_size,hidden\_size,depth)]+126[RHNCell(hidden\_size,hidden\_size,depth)for\_inrange(n\_layers-1)])

#

x හැඩය state ඇති [seq_len, batch_size, input_size] අතර හැඩය [batch_size, hidden_size] ඇත.

128defforward(self,x:torch.Tensor,state:Optional[torch.Tensor]=None):

#

133time\_steps,batch\_size=x.shape[:2]

#

රාජ්යයආරම්භ කරන්න නම් None

136ifstateisNone:137s=[x.new\_zeros(batch\_size,self.hidden\_size)for\_inrange(self.n\_layers)]138else:

#

එක්එක් ස්ථරයේ තත්වය ලබා ගැනීම සඳහා ප්රතිලෝම රාජ්යය ගොඩගසන්න

📝ඔබට ටෙන්සර් සමඟ වැඩ කළ හැකි නමුත් මෙය නිදොස් කිරීමට පහසුය

142s=torch.unbind(state)

#

එක්එක් කාල පියවරේදී අවසාන ස්ථරයේ ප්රතිදානයන් එකතු කිරීමට අරා.

145out=[]

#

එක්එක් කාල පියවර සඳහා ජාලය හරහා ධාවනය කරන්න

148fortinrange(time\_steps):

#

පළමුස්ථරයට ආදානය යනු ආදානය ම වේ

150inp=x[t]

#

ස්ථරහරහා ලූප්

152forlayerinrange(self.n\_layers):

#

ස්ථරයේතත්වය ලබා ගන්න

154s[layer]=self.cells[layer](inp,s[layer])

#

ඊළඟස්ථරයට ආදානය මෙම ස්ථරයේ තත්වයයි

156inp=s[layer]

#

අවසානස්ථරයේ ප්රතිදානය එකතු කරන්න

158out.append(s[-1])

#

ප්රතිදානයන්සහ ප්රාන්ත ගොඩගසන්න

161out=torch.stack(out)162s=torch.stack(s)163164returnout,s

Trending Research Paperslabml.ai