docs/si/transformers/switch/index.html
[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/transformers/switch/ init.py)
මෙයකඩදාසි ස්විච් ට්රාන්ස්ෆෝමර්වල කුඩාපයිටෝච් ක්රියාත්මක කිරීමකි: සරල හා කාර්යක්ෂම ස්පාර්ටිටි සහිත ට්රිලියන පරාමිති ආකෘති වලට පරිමාණය කිරීම. අපගේ ක්රියාත්මක කිරීම සඳහා ඇත්තේ පරාමිතීන් මිලියන කිහිපයක් පමණක් වන අතර සමාන්තරව බෙදා හරින ලද පුහුණුව ආදර්ශයට නොගනී. එය තනි GPU පුහුණුව කරන්නේ, නමුත් අපි කඩදාසි විස්තර කර ඇති පරිදි මාරුවීමේ සංකල්පය ක්රියාත්මක කරමු.
ස්විච්ට්රාන්ස්ෆෝමරය ටෝකනය මත පදනම්ව පරාමිතීන් අතර මාරුවීමෙන් එක් එක් ටෝකනය සඳහා විවිධ පරාමිතීන් භාවිතා කරයි. එබැවින්, එක් එක් ටෝකනය සඳහා තෝරා ගනු ලබන්නේ පරාමිතීන්ගෙන් කොටසක් පමණි. එබැවින් ඔබට වැඩි පරාමිතීන් තිබිය හැකි නමුත් අඩු පරිගණකමය පිරිවැයක් ඇත.
මාරුවීමසිදුවන්නේ එක් එක් ට්රාන්ස්ෆෝමර් බ්ලොක් එකේ ස්ථාන-නැණවත් Feedforward ජාලයේ (FFN) ය. ස්ථාන-නැණවත් පෝෂක ජාලය අනුක්රමිකව පූර්ණ සම්බන්ධිත ස්ථර දෙකකින් සමන්විත වේ. ස්විච් ට්රාන්ස්ෆෝමරයේ අපට FFNs (බහු විශේෂ experts යින්) කිහිපයක් ඇති අතර, රවුටරයක් මත පදනම්ව භාවිතා කළ යුත්තේ කුමන එකද යන්න අපි තෝරා ගත්තෙමු. ප්රතිදානය යනු එෆ්එෆ්එන් තෝරා ගැනීම සඳහා වන සම්භාවිතාවන් සමූහයක් වන අතර, අපි ඉහළම සම්භාවිතාව ඇති එකක් තෝරාගෙන එය ඇගයීමට ලක් කරමු. එබැවින් අත්යවශ්යයෙන්ම පරිගණකමය පිරිවැය තනි එෆ්එෆ්එන් එකක් තිබීම හා සමාන වේ. අපගේ ක්රියාත්මක කිරීමේදී මෙය ඔබට බොහෝ හෝ විශාල එෆ්එෆ්එන්එස් ඇති විට සමාන්තරගත නොවේ. බෙදා හරින ලද සැකසුමක ඔබට එක් එක් FFN (සෑම ඉතා විශාල) වෙනත් උපාංගයක ඇත.
විශේෂexperts යන් (එෆ්එෆ්එන්එස්) අතර බර සමතුලිත කිරීම සඳහා කඩදාසි තවත් පාඩු යෙදුමක් හඳුන්වා දෙන අතර රවුටින් සමතුලිත නොවන විට ටෝකන අතහැර දැමීම සාකච්ඡා කරයි.
කුඩාෂේක්ස්පියර් දත්ත කට්ටුවේ ස්විච් ට්රාන්ස්ෆෝමරයක් පුහුණු කිරීම සඳහා පුහුණු කේතය සහ සටහන් පොතක් මෙන්න.
40importtorch41fromtorchimportnn4243fromlabml\_helpers.moduleimportModule44fromlabml\_nn.transformers.feed\_forwardimportFeedForward45fromlabml\_nn.transformers.mhaimportMultiHeadAttention46fromlabml\_nn.utilsimportclone\_module\_list
49classSwitchFeedForward(Module):
capacity_factor පරමාදර්ශී සමබර බරට සාපේක්ෂව සාධකයක් ලෙස එක් එක් විශේෂ expert යාගේ ධාරිතාවයිdrop_tokens ධාරිතාවයට වඩා වැඩි ටෝකන විශේෂ expert යෙකු වෙත යොමු කළහොත් ටෝකන අතහැර දැමිය යුතුද යන්න නියම කරයිis_scale_prob රවුටින් සම්භාවිතාව අනුව එෆ්එෆ්එන් වෙත ආදානය ගුණ කළ යුතුද යන්න නියම කරයිn_experts විශේෂඥයන් සංඛ්යාවexpert විශේෂ expert ස්තරය, එෆ්එෆ්එන් මොඩියුලයකිd_model යනු ටෝකන කාවැද්දීම තුළ ඇති විශේෂාංග ගණනd_ff යනු FFN හි සැඟවුණු ස්ථරයේ ඇති ලක්ෂණ ගණනdropout FFN හි අතහැර දැමීමේ සම්භාවිතාව54def\_\_init\_\_(self,\*,55capacity\_factor:float,56drop\_tokens:bool,57is\_scale\_prob:bool,58n\_experts:int,59expert:FeedForward,60d\_model:int):
71super().\_\_init\_\_()7273self.capacity\_factor=capacity\_factor74self.is\_scale\_prob=is\_scale\_prob75self.n\_experts=n\_experts76self.drop\_tokens=drop\_tokens
FFNsහි පිටපත් සාදන්න
79self.experts=clone\_module\_list(expert,n\_experts)
රවුටින්ස්තරය සහ සොෆ්ට්මැක්ස්
81self.switch=nn.Linear(d\_model,n\_experts)82self.softmax=nn.Softmax(dim=-1)
x හැඩය සහිත මාරුවීමේ මොඩියුලයට ආදානය වේ [seq_len, batch_size, d_model]84defforward(self,x:torch.Tensor):
පසුවහැඩයන් වෙනස් කිරීම සඳහා හැඩය අල්ලා ගන්න
90seq\_len,batch\_size,d\_model=x.shape
අනුක්රමයසහ කණ්ඩායම් මානයන් සමතලා කරන්න
92x=x.view(-1,d\_model)
එක්එක් ටෝකන සඳහා මාර්ගගත කිරීමේ සම්භාවිතාව ලබා ගන්න. pi(x)=∑jNeh(x)jeh(x)i විශේෂ experts යන්ගේ සංඛ්යාව N n_experts කොතැනද සහ h(⋅) ටෝකන් කාවැද්දීම් රේඛීය පරිවර්තනය වේ.
98route\_prob=self.softmax(self.switch(x))
උපරිමමාර්ගගත කිරීමේ සම්භාවිතාව සහ මාර්ග ලබා ගන්න. අපි ඉහළම සම්භාවිතාව සහිත විශේෂ expert යා වෙත ගමන් කරමු
102route\_prob\_max,routes=torch.max(route\_prob,dim=-1)
එක්එක් විශේෂ. යා වෙත යන ටෝකන වල දර්ශක ලබා ගන්න
105indexes\_list=[torch.eq(routes,i).nonzero(as\_tuple=True)[0]foriinrange(self.n\_experts)]
ප්රතිදානයන්ගබඩා කිරීම සඳහා හිස් ටෙන්සරයක් ආරම්භ කරන්න
108final\_output=x.new\_zeros(x.shape)
එක්එක් විශේෂඥයාගේ ධාරිතාව. expertcapacity=numberofexpertstokensperbatch×capacityfactor
114capacity=int(self.capacity\_factor\*len(x)/self.n\_experts)
එක්එක් විශේෂ. යා වෙත යොමු කරන ලද ටෝකන ගණන.
116counts=x.new\_tensor([len(indexes\_list[i])foriinrange(self.n\_experts)])
පහතවැටුණු ටෝකන වල හිස් ලැයිස්තුවක් ආරම්භ කරන්න
119dropped=[]
නම්පමණක් ටෝකන drop_tokens අතහරින්න True .
121ifself.drop\_tokens:
එක්එක් විශේෂ. යන් තුළ ටෝකන අතහරින්න
123foriinrange(self.n\_experts):
විශේෂexpert යා ධාරිතාව වැඩි නොවේ නම් නොසලකා හරින්න
125iflen(indexes\_list[i])\<=capacity:126continue
අතහැරදැමීමට පෙර දර්ශක කලවම් කරන්න
128indexes\_list[i]=indexes\_list[i][torch.randperm(len(indexes\_list[i]))]
පහතවැටුණු ටෝකන ලෙස ධාරිතාවයට වඩා ටෝකන එකතු කරන්න
130dropped.append(indexes\_list[i][capacity:])
විශේෂexpert යාගේ ධාරිතාව දක්වා ටෝකන පමණක් තබා ගන්න
132indexes\_list[i]=indexes\_list[i][:capacity]
විශේෂexpert එෆ්එෆ්එන්එස් හි ප්රතිදානයන් ලබා ගන්න
135expert\_output=[self.experts[i](x[indexes\_list[i],:])foriinrange(self.n\_experts)]
අවසානනිමැවුමට පවරන්න
138foriinrange(self.n\_experts):139final\_output[indexes\_list[i],:]=expert\_output[i]
පහතවැටුණු ටෝකන හරහා යන්න
142ifdropped:143dropped=torch.cat(dropped)144final\_output[dropped,:]=x[dropped,:]145146ifself.is\_scale\_prob:
සම්භාවිතාවවිසින් විශේෂඥ ප්රතිදානයන් විසින් ගුණ y=pi(x)Ei(x)
148final\_output=final\_output\*route\_prob\_max.view(-1,1)149else:
අගයන්පරිමාණය නොකරන්න, p^p=1 එවිට අනුක්රමික ගලා යන පරිදි ගුණ කරන්න (මෙය අප අත්හදා බැලූ දෙයකි).
152final\_output=final\_output\*(route\_prob\_max/route\_prob\_max.detach()).view(-1,1)
අවසානනිමැවුමේ හැඩය නැවත වෙනස් කරන්න [seq_len, batch_size, d_model]
155final\_output=final\_output.view(seq\_len,batch\_size,d\_model)
ආපසු
බරතුලනය කිරීමේ අලාභය සහ ලොග් වීම සඳහා මේවා භාවිතා වේ
166returnfinal\_output,counts,route\_prob.sum(0),len(dropped),route\_prob\_max
ස්විච්පෝෂක මොඩියුලයේ අමතර ප්රතිදානයන් හැසිරවීමත් සමඟ මෙය සාමාන්ය ට්රාන්ස්ෆෝමර් කොටුවට සමාන වේ.
169classSwitchTransformerLayer(Module):
d_model ටෝකනය කාවැද්දීමේ ප්රමාණයයිattn අවධානය යොමු මොඩියුලය වේfeed_forward යනු ආහාර ඉදිරි මොඩියුලයයි (මෙම නඩුවේ මාරුවීමේ මොඩියුලය වන)dropout_prob ස්වයං අවධානයෙන් පසු ඉවත් වීමේ සම්භාවිතාව සහ FFN177def\_\_init\_\_(self,\*,178d\_model:int,179attn:MultiHeadAttention,180feed\_forward:SwitchFeedForward,181dropout\_prob:float):
188super().\_\_init\_\_()189self.size=d\_model190self.attn=attn191self.feed\_forward=feed\_forward192self.dropout=nn.Dropout(dropout\_prob)193self.norm\_self\_attn=nn.LayerNorm([d\_model])194self.norm\_ff=nn.LayerNorm([d\_model])
196defforward(self,\*,197x:torch.Tensor,198mask:torch.Tensor):
ස්වයංඅවධානය යොමු කිරීමට පෙර දෛශික සාමාන්යකරණය කරන්න
200z=self.norm\_self\_attn(x)
ස්වයංඅවධානය හරහා ධාවනය කරන්න, i.e. යතුරු සහ වටිනාකම් ස්වයං සිට
202self\_attn=self.attn(query=z,key=z,value=z,mask=mask)
ස්වයංඅවධානය ප්රතිඵල එකතු
204x=x+self.dropout(self\_attn)
පෝෂණයසඳහා සාමාන්යකරණය කරන්න
207z=self.norm\_ff(x)
මාරුවීමේපෝෂක-ඉදිරි ජාලය හරහා ගමන් කරන්න
209ff,counts,route\_prob,n\_dropped,route\_prob\_max=self.feed\_forward(z)
ප්රතිපෝෂණඉදිරි ප්රති results ල නැවත එක් කරන්න
211x=x+self.dropout(ff)212213returnx,counts,route\_prob,n\_dropped,route\_prob\_max
216classSwitchTransformer(Module):
221def\_\_init\_\_(self,layer:SwitchTransformerLayer,n\_layers:int):222super().\_\_init\_\_()
ට්රාන්ස්ෆෝමර්ස්ථරයේ පිටපත් සාදන්න
224self.layers=clone\_module\_list(layer,n\_layers)
අවසානසාමාන්යකරණ ස්තරය
226self.norm=nn.LayerNorm([layer.size])
228defforward(self,x:torch.Tensor,mask:torch.Tensor):
එක්එක් ට්රාන්ස්ෆෝමර් ස්ථරය හරහා ධාවනය කරන්න
230counts,route\_prob,n\_dropped,route\_prob\_max=[],[],[],[]231forlayerinself.layers:232x,f,p,n\_d,p\_max=layer(x=x,mask=mask)233counts.append(f)234route\_prob.append(p)235n\_dropped.append(n\_d)236route\_prob\_max.append(p\_max)
අවසානවශයෙන්, දෛශික සාමාන්යකරණය කරන්න
238x=self.norm(x)
240returnx,torch.stack(counts),torch.stack(route\_prob),n\_dropped,torch.stack(route\_prob\_max)