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

පොන්ඩර්නෙට්: මෙනෙහි කිරීමට ඉගෙනීම

මෙය PonderNet කඩදාසි PyTorch ක්රියාත්මක කිරීම: පොන්ඩර් වෙත ඉගෙනීම .

PonderNetආදානය මත පදනම්ව ගණනය කිරීම අනුවර්තනය කරයි. ආදානය මත පදනම්ව පුනරාවර්තන ජාලයක් සඳහා ගත යුතු පියවර ගණන එය වෙනස් කරයි. පොන්ඩර්නෙට් මෙය ඉගෙන ගන්නේ අවසානය සිට අවසානය දක්වා වූ ශ්රේණියේ සම්භවයක් සමඟය.

පොන්ඩර්නෙට්හි ආකෘතියේ පියවර ශ්රිතයක් ඇත

y^n,hn+1,λn=s(x,hn)

x ආදානය කොතැනද, y^n ප්රාන්තය ද n, පියවරෙන් පියවර පුරෝකථනය λn ද, hn වර්තමාන පියවරේදී නතර කිරීමේ සම්භාවිතාව (නතර කිරීම).

s ඕනෑම ස්නායුක ජාලයක් විය හැකිය (උදා: LSTM, MLP, GRU, අවධානය යොමු කිරීමේ ස්ථරය).

පියවරෙන්පියවර නතර කිරීමේ කොන්දේසි විරහිත සම්භාවිතාව n නම්,

pn=λnj=1∏n−1(1−λj)

පෙරකිසිදු පියවරකින් නතර නොවී පියවරෙන් පියවර නතර කිරීමේ සම්භාවිතාව මෙයයි n.

අනුමානයඅතරතුර, අපි නතර කිරීමේ සම්භාවිතාව මත පදනම්ව නියැදීමෙන් නතර λn කර අවසාන නිමැවුම y^n ලෙස අඩක් ස්ථරයේ පුරෝකථනය ලබා ගනිමු.

පුහුණුවඅතරතුර, අපි සියලු ස්ථරවලින් අනාවැකි ලබා ගන්නා අතර ඒවා එක් එක් සඳහා පාඩු ගණනය කරමු. ඉන්පසු එක් එක් ස්ථරයේ නතර වීමේ සම්භාවිතාව මත පදනම්ව අලාභයේ බර තැබූ සාමාන්යය ගන්න pn.

පියවරශ්රිතය පරිත්යාග කරන ලද උපරිම පියවර ගණනකට අදාළ Nවේ.

පොන්ඩර්නෙට්හි සමස්ත අලාභය වන්නේ

LLRecLReg=LRec+βLReg=n=1∑NpnL(y,y^n)=KL(pn∥pG(λp))

L ඉලක්කය y හා අනාවැකිය අතර සාමාන්ය පාඩු කාර්යය y^nවේ.

KL යනු කුල්බැක් - ලයිබ්ලර් අපසරනයයි.

pG යනු පරාමිතිකරණය කරන ලද ජ්යාමිතික බෙදා λpහැරීමයි . λp සමග කිසිදු සම්බන්ධයක් නැත λn; අපි හුදෙක් කඩදාසි ලෙස එම අංකනය ඇලී සිටිති. PrpG(λp)(X=k)=(1−λp)kλp.

නියාමනයකිරීමේ අලාභය ජාලය λp1 පියවර ගැනීම සඳහා නැඹුරුව ඇති අතර සියලු පියවර සඳහා ශුන්ය නොවන සම්භාවිතාවන් දිරිගන්වයි; එනම් ගවේෂණය ප්රවර්ධනය කරයි.

Pority Task පිළිබඳ පොන්ඩර්නෙට් පුහුණු experiment.py කිරීම සඳහා පුහුණු කේතය මෙන්න.

65fromtypingimportTuple6667importtorch68fromtorchimportnn6970fromlabml\_helpers.moduleimportModule

සමානාත්මතාකාර්ය සඳහා GRU සමඟ පොන්ඩර්නෙට්

මෙයපියවර ශ්රිතය ලෙස GRU සෛලයක් භාවිතා කරන සරල ආකෘතියකි.

මෙමආකෘතිය ආදාන දෛශිකයක් වන Parity Task සඳහා වේ n_elems . දෛශිකයේ සෑම මූලද්රව්යයක්ම එක්කෝ 0 , 1 නැතහොත් -1 ප්රතිදානය යනු සමානාත්මතාවයයි - 1 s ගණන ඔත්තේ නම් සත්ය වන ද්විමය අගයකි සහ වෙනත් ආකාරයකින් අසත්යය.

ආකෘතියේපුරෝකථනය යනු සමානාත්මතාවයේ ලොග් 1සම්භාවිතාවයි.

73classParityPonderGRU(Module):

n_elems ආදාන දෛශිකයේ මූලද්රව්ය ගණන
n_hidden GRU හි රාජ්ය දෛශික ප්රමාණය වේ
max_steps පියවර උපරිම සංඛ්යාව N

87def\_\_init\_\_(self,n\_elems:int,n\_hidden:int,max\_steps:int):

93super().\_\_init\_\_()9495self.max\_steps=max\_steps96self.n\_hidden=n\_hidden

GRU hn+1=sh(x,hn)

100self.gru=nn.GRUCell(n\_elems,n\_hidden)

y^n=sy(hn) අපට ආදානය x ලෙස h සහ ආදානය ලෙස ස්තරයක් භාවිතා කළ හැකි නමුත් සරල බව සඳහා අපි මෙය සමඟ ගියෙමු.

104self.output\_layer=nn.Linear(n\_hidden,1)

λn=sλ(hn)

106self.lambda\_layer=nn.Linear(n\_hidden,1)107self.lambda\_prob=nn.Sigmoid()

ගණනයඇත්තටම අනුමාන කාලය නතර කරන බව එසේ අනුමානය තුළ සකස් කිරීමට විකල්පයක්

109self.is\_halt=False

x හැඩයේ ආදානය වේ [batch_size, n_elems]

මෙමtensors හතරක් tuple ප්රතිදානය:

p1…pN හැඩයේ ආතතියෙන් [N, batch_size] 2. y^1…y^N හැඩයේ ආතතියක් තුළ [N, batch_size] - සමානාත්මතාවයේ ලොග් සම්භාවිතාව 1 3. pm හැඩය [batch_size] 4. y^m මෙම ගණනය පියවර නතර කරන ලදී [batch_size] එහිදී හැඩය m

111defforward(self,x:torch.Tensor)-\>Tuple[torch.Tensor,torch.Tensor,torch.Tensor,torch.Tensor]:

124batch\_size=x.shape[0]

අපටආරම්භක තත්වය ලැබේ h1=sh(x)

127h=x.new\_zeros((x.shape[0],self.n\_hidden))128h=self.gru(x,h)

ගබඩාකිරීමට ලැයිස්තු p1…pN සහ y^1…y^N

131p=[]132y=[]

∏j=1n−1(1−λj)

134un\_halted\_prob=h.new\_ones((batch\_size,))

සාම්පලගණනය කිරීම නවතා දමා ඇති නඩත්තු කිරීම සඳහා දෛශිකයක්

137halted=h.new\_zeros((batch\_size,))

pm හා y^m එහිදී ගණනය පියවර නතර කරන ලදී m

139p\_m=h.new\_zeros((batch\_size,))140y\_m=h.new\_zeros((batch\_size,))

N පියවර සඳහා අවධාරණය කරන්න

143forninrange(1,self.max\_steps+1):

අවසානපියවර λN=1 සඳහා නතර කිරීමේ සම්භාවිතාව

145ifn==self.max\_steps:146lambda\_n=h.new\_ones(h.shape[0])

λn=sλ(hn)

148else:149lambda\_n=self.lambda\_prob(self.lambda\_layer(h))[:,0]

y^n=sy(hn)

151y\_n=self.output\_layer(h)[:,0]

pn=λnj=1∏n−1(1−λj)

154p\_n=un\_halted\_prob\*lambda\_n

යාවත්කාලීනකරන්න ∏j=1n−1(1−λj)

156un\_halted\_prob=un\_halted\_prob\*(1-lambda\_n)

නතරකිරීමේ සම්භාවිතාව මත පදනම්ව නතර කරන්න λn

159halt=torch.bernoulli(lambda\_n)\*(1-halted)

එකතුකරන්න pn සහ y^n

162p.append(p\_n)163y.append(y\_n)

යාවත්කාලීනකිරීම pm සහ වර්තමාන පියවරේදී නවතා දැමූ දේ මත y^m පදනම්ව n

166p\_m=p\_m\*(1-halt)+p\_n\*halt167y\_m=y\_m\*(1-halt)+y\_n\*halt

නතරකරන ලද සාම්පල යාවත්කාලීන කරන්න

170halted=halted+halt

ඊළඟතත්වය ලබා ගන්න hn+1=sh(x,hn)

172h=self.gru(x,h)

සියලුමසාම්පල නතර කර ඇත්නම් ගණනය කිරීම නවත්වන්න

175ifself.is\_haltandhalted.sum()==batch\_size:176break

179returntorch.stack(p),torch.stack(y),p\_m,y\_m

ප්රතිසංස්කරණඅලාභය

LRec=n=1∑NpnL(y,y^n)

L ඉලක්කය y හා අනාවැකිය අතර සාමාන්ය පාඩු කාර්යය y^nවේ.

182classReconstructionLoss(Module):

loss_func පාඩු ශ්රිතය වේ L

191def\_\_init\_\_(self,loss\_func:nn.Module):

195super().\_\_init\_\_()196self.loss\_func=loss\_func

p හැඩයේ ආතතියෙන් යුක්ත වේ p1…pN [N, batch_size]
y_hat හැඩයේ ආතතියෙන් යුක්ත වේ y^1…y^N [N, batch_size, ...]
y හැඩයේ ඉලක්කයයි [batch_size, ...]

198defforward(self,p:torch.Tensor,y\_hat:torch.Tensor,y:torch.Tensor):

එකතුව ∑n=1NpnL(y,y^n)

206total\_loss=p.new\_tensor(0.)

නැවතනැවත කරන්න N

208forninrange(p.shape[0]):

pnL(y,y^n) එක් එක් නියැදිය සහ ඒවායේ මධ්යන්යය සඳහා

210loss=(p[n]\*self.loss\_func(y\_hat[n],y)).mean()

සම්පූර්ණඅලාභයට එකතු කරන්න

212total\_loss=total\_loss+loss

215returntotal\_loss

අලාභයවිධිමත් කිරීම

LReg=KL(pn∥pG(λp))

KL යනු කුල්බැක් - ලයිබ්ලර් අපසරනයයි.

විධිමත්කිරීමේ අලාභය ජාලය λp1 පියවර ගැනීම කෙරෙහි නැඹුරුවීම සහ සියලු පියවර සඳහා ශුන්ය නොවන සම්භාවිතාවන් දිරිගැන්වීම; එනම් ගවේෂණය ප්රවර්ධනය කරයි.

218classRegularizationLoss(Module):

lambda_p යනු λp - ජ්යාමිතික ව්යාප්තියේ සාර්ථක සම්භාවිතාව
max_steps ඉහළම N; අපි මෙය පූර්ව ගණනය කිරීමට භාවිතා කරමු pG(λp)

234def\_\_init\_\_(self,lambda\_p:float,max\_steps:int=1\_000):

239super().\_\_init\_\_()

ගණනයකිරීම සඳහා හිස් දෛශිකය pG(λp)

242p\_g=torch.zeros((max\_steps,))

(1−λp)k

244not\_halted=1.

නැවතනැවත කරන්න max_steps

246forkinrange(max\_steps):

PrpG(λp)(X=k)=(1−λp)kλp

248p\_g[k]=not\_halted\*lambda\_p

යාවත්කාලීනකරන්න (1−λp)k

250not\_halted=not\_halted\*(1-lambda\_p)

සුරකින්න PrpG(λp)

253self.p\_g=nn.Parameter(p\_g,requires\_grad=False)

එල්. එල්-අපසරනය අහිමි

256self.kl\_div=nn.KLDivLoss(reduction='batchmean')

p හැඩයේ ආතතියෙන් යුක්ත වේ p1…pN [N, batch_size]

258defforward(self,p:torch.Tensor):

p වෙත සම්ප්රේෂණය කරන්න [batch_size, N]

263p=p.transpose(0,1)

PrpG(λp) දක්වා ලබා ගැනීමට N හා කණ්ඩායම මානයක් හරහා එය පුළුල්

265p\_g=self.p\_g[None,:p.shape[1]].expand\_as(p)

කේඑල්-අපසරනයගණනය කරන්න. Pytorch KL-අපසරනය ක්රියාත්මක කිරීම ලොග් සම්භාවිතාව පිළිගනී.

270returnself.kl\_div(p.log(),p\_g)

Trending Research Papers labml.ai