docs/si/transformers/primer_ez/index.html
[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/transformers/primer_ez/ init.py)
මෙය PyTorch කඩදාසි ප්රයිමර් ක්රියාත්මක කිරීම: භාෂා ආකෘති නිර්මාණය සඳහා කාර්යක්ෂම ට්රාන්ස්ෆෝමර් සෙවීම .
කතුවරුන්ට්රාන්ස්ෆෝමර් ගෘහ නිර්මාණ ශිල්පය සඳහා පරිණාමීය සෙවීමක් කරයි. සෙවුම් ප්රයිමර් භාවිතයෙන් සොයාගත් ගෘහ නිර්මාණ ශිල්පය ඔවුන් නම් කරයි (ප්රයිම්ටිව්ස් ට්රාන්ස්ෆෝමර් සෙවූ). ප්රයිමර්EZ යනු මුල් ට්රාන්ස්ෆෝමරය හා සසඳන විට ප්රයිමර් හි වඩාත්ම ශක්තිමත් වෙනස් කිරීම් දෙක සහිත ගෘහ නිර්මාණ ශිල්පයයි. ප්රයිමර් EZ වැනිලා ට්රාන්ස්ෆෝමරය වඩා වේගයෙන් දුම්රිය.
සෙවුමමගින් සොයාගත් වඩාත්ම effective ලදායී වෙනස් කිරීම වන්නේ ස්ථාන-නැණවත් පෝෂක මොඩියුලයේRelU වෙනුවට චතුරස්රාකාර RelU භාවිතා කිරීමයි.
y=max(x,0)2
ඊළඟeffective ලදායී වෙනස් කිරීම යනු විමසුම්, යතුරු සහ අගයන් සඳහා බහු-හිස ප්රක්ෂේපණය කිරීමෙන් පසු ගැඹුරට අනුව 3×1 කැටි ගැසුමකි. මෙම convolution අනුක්රමය මානයක් ඔස්සේ සහ නාලිකාව (ගැඹුර-අනුව) වේ. පැහැදිලි කිරීම සඳහා, එක් එක් හිසෙහි නාලිකා ගණන සංකෝචනය නම් එක් එක් dk නාලිකා සඳහා 1×3 කර්නල් ඇත. dk
ප්රයිමර්EZ සඳහාඅත්හදා බැලීමේ කේතය මෙන්න.
40importtorch41fromtorchimportnn4243fromlabml\_helpers.moduleimportModule44fromlabml\_nn.transformersimportMultiHeadAttention
y=max(x,0)2
SquaredRelU තත්ත්වය නැණවත් feedforward මොඩියුලයතුළ සක්රිය කාර්යය ලෙස භාවිතා කරයි.
47classSquaredReLU(Module):
57def\_\_init\_\_(self):58super().\_\_init\_\_()59self.relu=nn.ReLU()
61defforward(self,x:torch.Tensor):
Reluඅයදුම් කරන්න
63x=self.relu(x)
එයවර්ග කරන්න
65returnx\*x
68classSpatialDepthWiseConvolution(Module):
d_k එක් එක් හිසෙහි නාලිකා ගණන වේ73def\_\_init\_\_(self,d\_k:int,kernel\_size:int=3):
77super().\_\_init\_\_()78self.kernel\_size=kernel\_size
අපිපයිටෝර්ච් Conv1d මොඩියුලය භාවිතා කරමු. එක් එක් නාලිකාව සඳහා වෙනම සංවහනයක් (විවිධ කර්නල් සමඟ) සිදු වන පරිදි නාලිකා ගණනට සමාන වන පරිදි කණ්ඩායම් ගණන අපි සකස් කරමු. අපි දෙපැත්තටම පුරවන එකතු කර පසුව නිවැරදි වඩාත්ම kernel_size - 1 ප්රති
. ල ලබා ගනිමු
83self.conv=nn.Conv1d(in\_channels=d\_k,out\_channels=d\_k,84kernel\_size=(kernel\_size,),padding=(kernel\_size-1,),groups=d\_k)
x හැඩය ඇත [seq_len, batch_size, heads, d_k]
86defforward(self,x:torch.Tensor):
හැඩයලබා ගන්න
92seq\_len,batch\_size,heads,d\_k=x.shape
කිරීමටඅවසර [batch_size, heads, d_k, seq_len]
94x=x.permute(1,2,3,0)
හැඩයවෙනස් කරන්න [batch_size * heads, d_k, seq_len]
96x=x.view(batch\_size\*heads,d\_k,seq\_len)
1Dකැටි ගැසුමේ ආකෘතියේ ආදානය පිළිගනී [N, channels, sequence]
99x=self.conv(x)
අපිදෙපැත්තෙන්ම ආවරණයකින් සමන්විත බැවින් නිවැරදි වඩාත්ම kernel_size - 1 ප්රති results ල බෝග කරන්න
101x=x[:,:,:-(self.kernel\_size-1)]
නැවතහැඩගස්වන්න [batch_size, heads, d_k, seq_len]
103x=x.view(batch\_size,heads,d\_k,seq\_len)
කිරීමටඅවසර [seq_len, batch_size, heads, d_k]
105x=x.permute(3,0,1,2)
108returnx
අපි බහු-ප්රධාන අවධානය අපගේ මුල් ක්රියාත්මක කිරීම දීර් and කරන අතර විමසුම, යතුර සහ වටිනාකම් ප්රක්ෂේපණ සඳහා අවකාශීය ගැඹුර-නැණවත් සම්මුතිය එක් කරමු.
111classMultiDConvHeadAttention(MultiHeadAttention):
119def\_\_init\_\_(self,heads:int,d\_model:int,dropout\_prob:float=0.1):120super().\_\_init\_\_(heads,d\_model,dropout\_prob)
බහු-ප්රධාන අවධානය විමසුම නිර්මාණය කරනු ඇත, ප්රධාන සහ අගය ප්රක්ෂේපනය මොඩියුල self.query``self.key , සහ self.value .
අපිඔවුන් එක් එක් කිරීමට අවකාශීය ගැඹුර-නැණවත් convolution ස්ථරය ඒකාබද්ධ හා වෙනුවට self.query``self.key , සහ self.value .
📝 මෙය සහ වැනිලා ට්රාන්ස්ෆෝමර් බහු-හිස අවධානය අතර වෙනස පැහැදිලිව පෙන්වන බැවින් මෙම පිරිසිදු ක්රියාත්මක කිරීම තේරුම් ගැනීම පහසු යැයි අපට හැඟේ.
130self.query=nn.Sequential(self.query,SpatialDepthWiseConvolution(self.d\_k))131self.key=nn.Sequential(self.key,SpatialDepthWiseConvolution(self.d\_k))132self.value=nn.Sequential(self.value,SpatialDepthWiseConvolution(self.d\_k))