ContextQMD
Back to Annotated Deep Learning Paper Implementations

පැච්ඔබට අවශ්ය සියලුම ද? (කොන්වී මික්සර්)

docs/si/conv_mixer/index.html

latest11.8 KB
Original Source

homeconv_mixer

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

#

පැච්ඔබට අවශ්ය සියලුම ද? (කොන්වී මික්සර්)

මෙය PyTorch කඩදාසි ක්රියාත්මක කිරීමයි පැච් ඔබට අවශ්යද?.

ConvMixer MLP-මික්සර්සමාන වේ. එම්එල්පී-මික්සර් අවකාශීය හා නාලිකා මානයන් මිශ්ර කිරීම වෙන් කරයි, අවකාශීය මානය හරහා එම්එල්පී යෙදීමෙන් සහ පසුව නාලිකා මානය හරහා එම්එල්පී යෙදීමෙන් (අවකාශීය එම්එල්පී වීඅයිටී අවධානය ප්රතිස්ථාපනය කරන අතර නාලිකාව එම්එල්පී යනු එෆ්එෆ්එන් වේ vit).

ConvMixerනාලිකාව මිශ්ර 1×1 කිරීම සඳහා convvolution සහ අවකාශීය මිශ්ර කිරීම සඳහා ගැඹුර-wise convolution භාවිතා කරයි. එය අවකාශය හරහා සම්පූර්ණ එම්එල්පී වෙනුවට කැටි ගැස්වීමක් බැවින්, එය VIT හෝ MLP-මික්සර් වලට වඩා වෙනස්ව අසල ඇති කාණ්ඩ පමණක් මිශ්ර කරයි. එසේම, MLP-මික්සර් එක් එක් මිශ්රණය සඳහා ස්ථර දෙකක MLPs භාවිතා කරන අතර ConvMixer එක් එක් මිශ්රණය සඳහා තනි ස්ථරයක් භාවිතා කරයි.

කඩදාසිනිර්දේශ කරන්නේ නාලිකා මිශ්රණය හරහා ඇති අවශේෂ සම්බන්ධතාවය ඉවත් කිරීම (ලක්ෂ්ය-අනුව කැටි ගැන්විම) සහ අවකාශීය මිශ්රණයට වඩා අවශේෂ සම්බන්ධතාවයක් පමණක් තිබීම (ගැඹුර-wise convolution) ය. ස්ථර සාමාන්යකරණය වෙනුවට කණ්ඩායම් සාමාන්යකරණය ද ඔවුන් භාවිතා කරයි.

CIFRA-10 හි ConvMixer පුහුණු කරන අත්හදා බැලීමක් මෙන්න.

38importtorch39fromtorchimportnn4041fromlabml\_helpers.moduleimportModule42fromlabml\_nn.utilsimportclone\_module\_list

#

කොන්ක්රීට්මික්සර් ස්ථරය

මෙයතනි කොන්වීමික්සර් ස්ථරයකි. ආකෘතියට මේවායින් මාලාවක් ඇත.

45classConvMixerLayer(Module):

#

  • d_model පැච් කාවැද්දීම් වල නාලිකා ගණන, h
  • kernel_size අවකාශීය සංවහනයේ කර්නලයේ ප්රමාණය, k
54def\_\_init\_\_(self,d\_model:int,kernel\_size:int):

#

59super().\_\_init\_\_()

#

ගැඹුරු-ප්රඥාවන්තසංකෝචනය යනු එක් එක් නාලිකාව සඳහා වෙනම කැටි ගැසුමකි. නාලිකා සංඛ්යාවට සමාන කණ්ඩායම් සංඛ්යාවක් සමඟ සංකෝචනය වන ස්ථරයක් සමඟ අපි මෙය සිදු කරමු. එබැවින් සෑම නාලිකාවක්ම තමන්ගේම කණ්ඩායමක් වේ.

63self.depth\_wise\_conv=nn.Conv2d(d\_model,d\_model,64kernel\_size=kernel\_size,65groups=d\_model,66padding=(kernel\_size-1)//2)

#

ගැඹුරු-අනුවකැටි ගැසීමෙන් පසු සක්රිය කිරීම

68self.act1=nn.GELU()

#

ගැඹුරු-අනුවකැටි ගැසීමෙන් පසු සාමාන්යකරණය

70self.norm1=nn.BatchNorm2d(d\_model)

#

ලක්ෂ්ය-නැණවත්කැටි 1×1 ගැසීමකි. එනම් පැච් කාවැද්දීම් රේඛීය පරිවර්තනයකි

74self.point\_wise\_conv=nn.Conv2d(d\_model,d\_model,kernel\_size=1)

#

ලක්ෂ්යයඅනුව කැටි ගැසීමෙන් පසු සක්රිය කිරීම

76self.act2=nn.GELU()

#

ලක්ෂ්යයඅනුව කැටි ගැසීමෙන් පසු සාමාන්යකරණය

78self.norm2=nn.BatchNorm2d(d\_model)

#

80defforward(self,x:torch.Tensor):

#

ගැඹුර-නැණවත්කැටි කිරීම වටා ඇති අවශේෂ සම්බන්ධතාවය සඳහා

82residual=x

#

ගැඹුරු-නැණවත්කැටි කිරීම, සක්රිය කිරීම සහ සාමාන්යකරණය කිරීම

85x=self.depth\_wise\_conv(x)86x=self.act1(x)87x=self.norm1(x)

#

අවශේෂසම්බන්ධතාවය එක් කරන්න

90x+=residual

#

ලක්ෂ්ය-නැණවත්කැටි ගැන්විම, සක්රිය කිරීම සහ සාමාන්යකරණය

93x=self.point\_wise\_conv(x)94x=self.act2(x)95x=self.norm2(x)

#

98returnx

#

පැච්කාවැද්දීම් ලබා ගන්න

මෙයරූපය ප්රමාණයෙන් පැච් වලට බෙදෙන p×p අතර එක් එක් පැච් සඳහා කාවැද්දීම ලබා දෙයි.

101classPatchEmbeddings(Module):

#

  • d_model පැච් කාවැද්දීම් වල නාලිකා ගණන h
  • patch_size පැච් වල ප්රමාණය, p
  • in_channels ආදාන රූපයේ නාලිකා ගණන (rgb සඳහා 3)
110def\_\_init\_\_(self,d\_model:int,patch\_size:int,in\_channels:int):

#

116super().\_\_init\_\_()

#

අපිකර්නල් ප්රමාණයෙන් හා ලප ප්රමාණය සමාන stride දිග සමග convolution ස්ථරය නිර්මාණය කරන්න. මෙය රූපය පැච් වලට බෙදීමට හා එක් එක් පැච් එකේ රේඛීය පරිවර්තනයක් කිරීමට සමාන වේ.

121self.conv=nn.Conv2d(in\_channels,d\_model,kernel\_size=patch\_size,stride=patch\_size)

#

සක්රියකිරීමේ කාර්යය

123self.act=nn.GELU()

#

කණ්ඩායම්සාමාන්යකරණය

125self.norm=nn.BatchNorm2d(d\_model)

#

  • x යනු හැඩයේ ආදාන රූපයයි [batch_size, channels, height, width]
127defforward(self,x:torch.Tensor):

#

කැටිගැසුණු ස්ථරය යොදන්න

132x=self.conv(x)

#

සක්රියකිරීම සහ සාමාන්යකරණය

134x=self.act(x)135x=self.norm(x)

#

138returnx

#

වර්ගීකරණහිස

රූපපංතිවල ලොග්-සම්භාවිතාවන් පුරෝකථනය කිරීම සඳහා ඔවුන් සාමාන්ය තටාක කිරීම (සියලු පැච් කාවැද්දීම් වල මධ්යන්යය ගනිමින්) සහ අවසාන රේඛීය පරිවර්තනයක් සිදු කරයි.

141classClassificationHead(Module):

#

  • d_model පැච් කාවැද්දීම් වල නාලිකා ගණන, h
  • n_classes වර්ගීකරණ කාර්යයේ පන්ති ගණන වේ
151def\_\_init\_\_(self,d\_model:int,n\_classes:int):

#

156super().\_\_init\_\_()

#

සාමාන්යතටාකය

158self.pool=nn.AdaptiveAvgPool2d((1,1))

#

රේඛීයස්ථරය

160self.linear=nn.Linear(d\_model,n\_classes)

#

162defforward(self,x:torch.Tensor):

#

සාමාන්යතටාක

164x=self.pool(x)

#

කාවැද්දීමලබා ගන්න, හැඩය x ඇත [batch_size, d_model, 1, 1]

166x=x[:,:,0,0]

#

රේඛීයස්ථරය

168x=self.linear(x)

#

171returnx

#

ConvMixer

මෙයපැච් කාවැද්දීම් බ්ලොක්, කොන්වීමික්සර් ස්ථර ගණනාවක් සහ වර්ගීකරණ හිසක් ඒකාබද්ධ කරයි.

174classConvMixer(Module):

#

181def\_\_init\_\_(self,conv\_mixer\_layer:ConvMixerLayer,n\_layers:int,182patch\_emb:PatchEmbeddings,183classification:ClassificationHead):

#

191super().\_\_init\_\_()

#

පැච්කාවැද්දීම්

193self.patch\_emb=patch\_emb

#

වර්ගීකරණහිස

195self.classification=classification

#

ConvMixer ස්ථරයේ පිටපත් සාදන්න

197self.conv\_mixer\_layers=clone\_module\_list(conv\_mixer\_layer,n\_layers)

#

  • x යනු හැඩයේ ආදාන රූපයයි [batch_size, channels, height, width]
199defforward(self,x:torch.Tensor):

#

පැච්කාවැද්දීම් ලබා ගන්න. මෙය හැඩයේ ආතතිකයක් ලබා දෙයි [batch_size, d_model, height / patch_size, width / patch_size] .

204x=self.patch\_emb(x)

#

ConvMixer ස්ථර හරහා ගමන් කරන්න

207forlayerinself.conv\_mixer\_layers:208x=layer(x)

#

වර්ගීකරණහිස, පිවිසුම් ලබා ගැනීමට

211x=self.classification(x)

#

214returnx

Trending Research Paperslabml.ai