docs/si/capsule_networks/index.html
[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/capsule_networks/ init.py)
මෙය PyTorch ක්රියාත්මක කිරීම/නිබන්ධනයකි ඩයිනමික් රවුටින් කැප්සියුල අතර .
කැප්සියුලජාලය යනු ස්නායුක ජාල ගෘහ නිර්මාණ ශිල්පයක් වන අතර එය කැප්සියුල ලෙස ලක්ෂණ කාවැද්දීම සහ ඡන්දය ප්රකාශ කිරීමේ යාන්ත්රණයක් සමඟ ඊළඟ ස්ථරයට ගමන් කරයි.
ආකෘතිවලවෙනත් ක්රියාත්මක කිරීම් වලදී මෙන් නොව, අපි නියැදියක් ඇතුළත් කර ඇත, මන්ද මොඩියුල සමඟ සමහර සංකල්ප තේරුම් ගැනීමට අපහසු බැවිනි. MNIST දත්ත සමුදාය වර්ගීකරණය කිරීම සඳහා කැප්සියුල භාවිතා කරන ආකෘතියක් සඳහා වියුක්ත කේතය මෙයයි
කැප්සියුලනෙට්වර්ක් හි මූලික මොඩියුලවල ක්රියාත්මක කිරීම් මෙම ගොනුව සතුව ඇත.
කඩදාසිසමඟ මා සතුව තිබූ ව්යාකූලතා පැහැදිලි කිරීම සඳහා මම ජින්ඩොන්ග්වාන්ග්/පයිටෝච්-කැප්සුලෙනෙට් භාවිතා කළෙමි.
MNISTදත්ත කට්ටලය පිළිබඳ කැප්සියුල ජාලයක් පුහුණු කිරීම සඳහා සටහන් පොතක් මෙන්න.
33importtorch.nnasnn34importtorch.nn.functionalasF35importtorch.utils.data3637fromlabml\_helpers.moduleimportModule
මෙයසමීකරණයෙන් ලබා දී ඇති කඩදාසි වලින් ස්කොෂ් (1)ශ්රිතයකි.
vj=1+∥sj∥2∥sj∥2∥sj∥sj
∥sj∥sj එක් එක් ප්රමාණයට වඩා කුඩා දිගක් ඇති කැප්සියුල 1+∥sj∥2∥sj∥2 හැකිලෙන අතර, සියලු කැප්සියුල වල දිග සාමාන්යකරණය කරයි.
40classSquash(Module):
55def\_\_init\_\_(self,epsilon=1e-8):56super().\_\_init\_\_()57self.epsilon=epsilon
හි s හැඩය [batch_size, n_capsules, n_features]
59defforward(self,s:torch.Tensor):
∥sj∥2
65s2=(s\*\*2).sum(dim=-1,keepdims=True)
අපිඑය ශුන්ය බවට පත් නොවන බවට වග බලා ගන්න ∥sj∥ කිරීමට ගණනය විට epsilon එකතු. මෙය ශුන්ය බවට පත් වුවහොත් එය nan සාරධර්ම ලබා දීම ආරම්භ කරන අතර පුහුණුව අසමත් වේ. vj=1+∥sj∥2∥sj∥2∥sj∥2+ϵsj
71return(s2/(1+s2))\*(s/torch.sqrt(s2+self.epsilon))
කඩදාසිවල විස්තර කර ඇති මාර්ගගත කිරීමේ යාන්ත්රණය මෙයයි. ඔබේ මාදිලිවල බහු රවුටින් ස්ථර භාවිතා කළ හැකිය.
මෙයමෙම ස්තරය sj සඳහා ගණනය කිරීම සහ _ක්රියා පටිපාටිය 1_හි විස්තර කර ඇති රවුටින් ඇල්ගොරිතම ඒකාබද්ධ කරයි.
74classRouter(Module):
in_caps යනු කැප්සියුල ගණන in_d වන අතර පහත ස්ථරයෙන් කැප්සියුලයකට ඇති ලක්ෂණ ගණන වේ. out_caps මෙම ස්තරය සඳහා සමාන වේ. out_d
iterations යනු කඩදාසි වලින් සංකේතවත් කරන r මාර්ගගත කිරීමේ පුනරාවර්තන සංඛ්යාවකි.
85def\_\_init\_\_(self,in\_caps:int,out\_caps:int,in\_d:int,out\_d:int,iterations:int):
92super().\_\_init\_\_()93self.in\_caps=in\_caps94self.out\_caps=out\_caps95self.iterations=iterations96self.softmax=nn.Softmax(dim=1)97self.squash=Squash()
මෙයබර අනුකෘතියකි Wij. මෙම ස්ථරයේ එක් එක් කැප්සියුලයට පහළ ස්ථරයේ එක් එක් කැප්සියුලය සිතියම්
ගත කරයි
101self.weight=nn.Parameter(torch.randn(in\_caps,out\_caps,in\_d,out\_d),requires\_grad=True)
හැඩය u වේ [batch_size, n_capsules, n_features] . මේවා පහළ ස්ථරයේ සිට කැප්සියුල වේ.
103defforward(self,u:torch.Tensor):
u^j∣i=Wijui මෙන්න j මෙම ස්ථරයේ කැප්සියුල දර්ශකය සඳහා භාවිතා i වන අතර පහත ස්ථරයේ (පෙර) කැප්සියුල දර්ශකය කිරීමට භාවිතා කරයි.
112u\_hat=torch.einsum('ijnm,bin-\>bijm',self.weight,u)
ආරම්භකපිවිසුම් bij යනු කැප්සියුලය සමඟ සම්බන්ධ විය i යුතු ලොග් පූර්ව jසම්භාවිතාවයි. අපි මේවා ශුන්යයෙන් ආරම්භ කරමු
117b=u.new\_zeros(u.shape[0],self.in\_caps,self.out\_caps)118119v=None
පුනරාවර්තනයකරන්න
122foriinrange(self.iterations):
සොෆ්ට්මැක්ස්රවුටින් cij=∑kexp(bik)exp(bij)
124c=self.softmax(b)
sj=i∑ciju^j∣i
126s=torch.einsum('bij,bijm-\>bjm',c,u\_hat)
vj=squash(sj)
128v=self.squash(s)
aij=vj⋅u^j∣i
130a=torch.einsum('bjm,bijm-\>bij',v,u\_hat)
bij←bij+vj⋅u^j∣i
132b=b+a133134returnv
එක්එක් නිමැවුම් කැප්සියුලය සඳහා වෙනම ආන්තික අලාභයක් භාවිතා වන අතර සම්පූර්ණ අලාභය ඒවායේ එකතුවයි. එක් එක් නිමැවුම් කැප්සියුලයේ දිග යනු ආදානයේ පන්තිය පවතින සම්භාවිතාවයි.
එක්එක් නිමැවුම් කැප්සියුලය හෝ පන්තිය සඳහා k නැතිවීම, Lk=Tkmax(0,m+−∥vk∥)2+λ(1−Tk)max(0,∥vk∥−m−)2
Tk k යනු පන්තිය පවතින අතර 0 වෙනත් ආකාරයකින් 1 නම්. අලාභයේ පළමු සංරචකය වන්නේ පන්තිය නොමැති 0 විට වන අතර දෙවන සංරචකය වන්නේ පන්තිය පවතී 0 නම් වේ. අනාවැකි අන්තයට max(0,x) යාම වළක්වා ගැනීමට මෙම භාවිතා කරයි. m+ කඩදාසි 0.1 තුළ සිටීමට 0.9 හා m− වීමට සකසා ඇත.
λ පහතට-බර පුහුණු ආරම්භක අදියර තුළ පහත වැටීම සිට සියලු කරල් දිග නතර කිරීම සඳහා භාවිතා වේ.
137classMarginLoss(Module):
157def\_\_init\_\_(self,\*,n\_labels:int,lambda\_:float=0.5,m\_positive:float=0.9,m\_negative:float=0.1):158super().\_\_init\_\_()159160self.m\_negative=m\_negative161self.m\_positive=m\_positive162self.lambda\_=lambda\_163self.n\_labels=n\_labels
v , vj මෙම squashed ප්රතිදානය කැප්සියුල වේ. මෙය හැඩය ඇත [batch_size, n_labels, n_features] ; එනම්, එක් එක් ලේබලය සඳහා කැප්සියුලයක් ඇත.
labels ලේබල, සහ හැඩය ඇත [batch_size] .
165defforward(self,v:torch.Tensor,labels:torch.Tensor):
∥vj∥
173v\_norm=torch.sqrt((v\*\*2).sum(dim=-1))
L labels හැඩයේ එක් උණුසුම් කේතනය කරන ලද ලේබල [batch_size, n_labels]
177labels=torch.eye(self.n\_labels,device=labels.device)[labels]
Lk=Tkmax(0,m+−∥vk∥)2+λ(1−Tk)max(0,∥vk∥−m−)2 loss හැඩය ඇත [batch_size, n_labels] . අපි සියලු Lk සඳහා ගණනය කිරීම සමාන්තරකරණය කර kඇත.
183loss=labels\*F.relu(self.m\_positive-v\_norm)+\184self.lambda\_\*(1.0-labels)\*F.relu(v\_norm-self.m\_negative)
k∑Lk
187returnloss.sum(dim=-1).mean()