homeresnet

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

#

රූපහඳුනාගැනීම සඳහා ගැඹුරු අවශේෂ ඉගෙනීම (රෙස්නෙට්)

මෙය PyTorch කඩදාසි ක්රියාත්මක කිරීම රූප හඳුනාගැනීම සඳහා ගැඹුරු අවශේෂ ඉගෙනීම .

_පිරිහීමේගැටළුව_මඟහරවා ගැනීම සඳහා අවශේෂ කාර්යයන් ලෙස රෙස්නෙට්ස් ස්ථර පුහුණු කරයි. පිරිහීමේ ගැටළුව වන්නේ ස්ථර ගණන ඉතා ඉහළ වන විට ගැඹුරු ස්නායුක ජාල පිරිහීමේ නිරවද්යතාවයයි. ස්ථර ගණන වැඩි වන විට නිරවද්යතාව වැඩි වන අතර පසුව සන්තෘප්ත වන අතර පසුව පිරිහීමට පටන් ගනී.

අමතරස්ථරවලට අනන්යතා සිතියම්ගත කිරීමක් සිදු කිරීමට ඉගෙන ගත හැකි නිසා ගැඹුරු ආකෘති අවම වශයෙන් මෙන්ම නොගැඹුරු ආකෘති ඉටු කළ යුතු බව කඩදාසි තර්ක කරයි.

අවශේෂඉගෙනීම

ස්ථරකිහිපයකින් ඉගෙන ගත යුතු සිතියම්කරණය නම් H(x) , ඒවා අවශේෂ ක්රියාකාරිත්වය පුහුණු කරයි

F(x)=H(x)−x

ඒවෙනුවට. මුල් කාර්යය බවට පත්වේ F(x)+x.

මේඅවස්ථාවේ දී, සඳහා අනන්යතා සිතියම්කරණය ඉගෙන ගැනීමට F(x) ඉගෙනීමට සමාන H(x) වේ 0, එය ඉගෙන ගැනීමට පහසු වේ.

පරාමිතිකස්වරූපයෙන් මෙය ලිවිය හැකිය,

F(x,{Wi​})+x

විශේෂාංගසිතියම් ප්රමාණ F(x,Wi​) හා x වෙනස් වූ විට කඩදාසි යෝජනා කරන්නේ ඉගෙනගත් බර සමඟ රේඛීය ප්රක්ෂේපණයක් Ws​කිරීමයි.

F(x,{Wi​})+Ws​x

කඩදාසිරේඛීය ප්රක්ෂේපණ වෙනුවට ශුන්ය පෑඩින් සමඟ අත්හදා බැලූ අතර රේඛීය ප්රක්ෂේපණ වඩා හොඳින් ක්රියා කරන බව සොයා ගන්නා ලදී. විශේෂාංග සිතියම් ප්රමාණ ගැලපෙන විට අනන්යතා සිතියම්කරණය රේඛීය ප්රක්ෂේපණවලට වඩා හොඳ බව ඔවුන්ට පෙනී ගියේය.

F එක් ස්ථරයකට වඩා තිබිය යුතුය, එසේ නොමැතිනම් F(x,{Wi​})+Ws​x එකතුවට රේඛීය නොවන නොවන අතර රේඛීය තට්ටුවක් මෙන් වනු ඇත.

CIFA-10හි රෙස්නෙට් පුහුණු කිරීම සඳහා පුහුණු කේතය මෙන්න.

57fromtypingimportList,Optional5859importtorch60fromtorchimportnn6162fromlabml\_helpers.moduleimportModule

#

කෙටිමංසම්බන්ධතාවය සඳහා රේඛීය ප්රක්ෂේපණ

ඉහතවිස්තර කර ඇති Ws​x ප්රක්ෂේපණය මෙය සිදු කරයි.

65classShortcutProjection(Module):

#

• in_channels යනු නාලිකා ගණන x
• out_channels යනු නාලිකා ගණන F(x,{Wi​})
• stride සඳහා convolution මෙහෙයුම දී stride දිග Fවේ. විශේෂාංග-සිතියම් ප්රමාණයට ගැලපෙන පරිදි අපි කෙටිමං සම්බන්ධතාවයේ එකම පියවර ගනිමු.

72def\_\_init\_\_(self,in\_channels:int,out\_channels:int,stride:int):

#

79super().\_\_init\_\_()

#

රේඛීයප්රක්ෂේපණය සඳහා සංයුක්ත ස්ථරය Ws​x

82self.conv=nn.Conv2d(in\_channels,out\_channels,kernel\_size=1,stride=stride)

#

කඩදාසිඑක් එක් convolution මෙහෙයුම පසු කණ්ඩායම සාමාන්යකරණය එකතු යෝජනා

84self.bn=nn.BatchNorm2d(out\_channels)

#

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

#

සම්මුතිසහ කණ්ඩායම් සාමාන්යකරණය

88returnself.bn(self.conv(x))

#

අවශේෂකොටස

මෙයකඩදාසි විස්තර කර ඇති අවශේෂ කොටස ක්රියාත්මක කරයි. එය 3×3 කැටි ගැසුණු ස්ථර දෙකක් ඇත.

පළමුconvolution ස්ථරය සිතියම් out_channels , අපි stride දිග සමග ලක්ෂණය සිතියම් ප්රමාණය අඩු කරන in_channels විට වඩා වැඩි කොහෙද in_channels``out_channels වඩා විශාල 1.

සිට out_channels දෙවන convolution ස්ථරය සිතියම් out_channels හා සෑම විටම 1 ක stride දිග ඇත.

සංවහනස්ථර දෙකම කණ්ඩායම් සාමාන්යකරණය කිරීමෙන් පසුව සිදු වේ.

91classResidualBlock(Module):

#

• in_channels යනු නාලිකා ගණන x
• out_channels ප්රතිදාන නාලිකා ගණන වේ
• stride මෙම convolution මෙහෙයුම දී stride දිග වේ.

112def\_\_init\_\_(self,in\_channels:int,out\_channels:int,stride:int):

#

118super().\_\_init\_\_()

#

පළමු 3×3 සංවහන ස්තරය, මෙය සිතියම් ගත කරයි out_channels

121self.conv1=nn.Conv2d(in\_channels,out\_channels,kernel\_size=3,stride=stride,padding=1)

#

පළමුකැටි ගැසීමෙන් පසු කණ්ඩායම් සාමාන්යකරණය

123self.bn1=nn.BatchNorm2d(out\_channels)

#

පළමුසක්රිය කිරීමේ කාර්යය (RELU)

125self.act1=nn.ReLU()

#

දෙවන 3×3 කැටි ගැසුණු ස්ථරය

128self.conv2=nn.Conv2d(out\_channels,out\_channels,kernel\_size=3,stride=1,padding=1)

#

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

130self.bn2=nn.BatchNorm2d(out\_channels)

#

නාලිකාගණන වෙනස් වුවහොත් ස්ට්රයිඩ් දිග නොවේ 1 නම් කෙටිමං සම්බන්ධතාවය ප්රක්ෂේපණයක් විය යුතුය

134ifstride!=1orin\_channels!=out\_channels:

#

ප්රක්ෂේපණය Ws​x

136self.shortcut=ShortcutProjection(in\_channels,out\_channels,stride)137else:

#

අනන්යතාවය x

139self.shortcut=nn.Identity()

#

දෙවනසක්රිය කිරීමේ කාර්යය (RelU) (කෙටිමඟ එකතු කිරීමෙන් පසු)

142self.act2=nn.ReLU()

#

• x හැඩයේ ආදානය වේ [batch_size, in_channels, height, width]

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

#

කෙටිමංසම්බන්ධතාවය ලබා ගන්න

149shortcut=self.shortcut(x)

#

පළමුකැටි කිරීම සහ සක්රිය කිරීම

151x=self.act1(self.bn1(self.conv1(x)))

#

දෙවනකැටි ගැසිම

153x=self.bn2(self.conv2(x))

#

කෙටිමඟඑකතු කිරීමෙන් පසු සක්රිය කිරීමේ කාර්යය

155returnself.act2(x+shortcut)

#

අවශේෂබාධක කොටස

මෙයකඩදාසි වල විස්තර කර ඇති බාධක කොටස ක්රියාත්මක කරයි. එය 1×13×3, සහ 1×1 කැටි ගැසුණු ස්ථර ඇත.

පළමුconvolution ස්ථරය වඩා අඩු කොහෙද 1×1 convolution, bottleneck_channels සමග සිට in_channels සිතියම් bottleneck_channels``in_channels .

දෙවන 3×3 කැටි ගැසුණු ස්ථරය සිතියම් bottleneck_channels සිට bottleneck_channels . විශේෂාංග සිතියම් ප්රමාණය සම්පීඩනය කිරීමට අපට අවශ්ය වන 1 විට වඩා විශාල දිගක් මෙයට තිබිය හැකිය.

තෙවන, අවසාන 1×1 කැටි ගැසුණු ස්ථරය සිතියම් වෙත out_channels . out_channels මෙම stride දිග වඩා වැඩි in_channels නම් වඩා වැඩි ය 1; එසේ නොමැති නම්, සමාන outc​hannels වේ in_channels .

bottleneck_channels වඩා අඩු වන in_channels අතර මෙම හැකිලී අවකාශය මත 3×3 කැටි කිරීම සිදු කරනු ලැබේ (එබැවින් බාධකය). 1×1 සංවහන දෙක අඩු වන අතර නාලිකා ගණන වැඩි කරයි.

158classBottleneckResidualBlock(Module):

#

• in_channels යනු නාලිකා ගණන x
• bottleneck_channels යනු 3×3 සංවහන සඳහා නාලිකා ගණන
• out_channels ප්රතිදාන නාලිකා ගණන වේ
• stride මෙම 3×3 convolution මෙහෙයුම දී stride දිග වේ.

186def\_\_init\_\_(self,in\_channels:int,bottleneck\_channels:int,out\_channels:int,stride:int):

#

193super().\_\_init\_\_()

#

පළමු 1×1 සංවහන ස්තරය, මෙය සිතියම් ගත කරයි bottleneck_channels

196self.conv1=nn.Conv2d(in\_channels,bottleneck\_channels,kernel\_size=1,stride=1)

#

පළමුකැටි ගැසීමෙන් පසු කණ්ඩායම් සාමාන්යකරණය

198self.bn1=nn.BatchNorm2d(bottleneck\_channels)

#

පළමුසක්රිය කිරීමේ කාර්යය (RELU)

200self.act1=nn.ReLU()

#

දෙවන 3×3 කැටි ගැසුණු ස්ථරය

203self.conv2=nn.Conv2d(bottleneck\_channels,bottleneck\_channels,kernel\_size=3,stride=stride,padding=1)

#

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

205self.bn2=nn.BatchNorm2d(bottleneck\_channels)

#

දෙවනසක්රිය කිරීමේ ශ්රිතය (RelU)

207self.act2=nn.ReLU()

#

තෙවන 1×1 සංවහන ස්තරය, මෙම සිතියම් වෙත out_channels .

210self.conv3=nn.Conv2d(bottleneck\_channels,out\_channels,kernel\_size=1,stride=1)

#

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

212self.bn3=nn.BatchNorm2d(out\_channels)

#

නාලිකාගණන වෙනස් වුවහොත් ස්ට්රයිඩ් දිග නොවේ 1 නම් කෙටිමං සම්බන්ධතාවය ප්රක්ෂේපණයක් විය යුතුය

216ifstride!=1orin\_channels!=out\_channels:

#

ප්රක්ෂේපණය Ws​x

218self.shortcut=ShortcutProjection(in\_channels,out\_channels,stride)219else:

#

අනන්යතාවය x

221self.shortcut=nn.Identity()

#

දෙවනසක්රිය කිරීමේ කාර්යය (RelU) (කෙටිමඟ එකතු කිරීමෙන් පසු)

224self.act3=nn.ReLU()

#

• x හැඩයේ ආදානය වේ [batch_size, in_channels, height, width]

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

#

කෙටිමංසම්බන්ධතාවය ලබා ගන්න

231shortcut=self.shortcut(x)

#

පළමුකැටි කිරීම සහ සක්රිය කිරීම

233x=self.act1(self.bn1(self.conv1(x)))

#

දෙවනකැටි ගැසිම සහ සක්රිය කිරීම

235x=self.act2(self.bn2(self.conv2(x)))

#

තෙවනකැටි ගැසිම

237x=self.bn3(self.conv3(x))

#

කෙටිමඟඑකතු කිරීමෙන් පසු සක්රිය කිරීමේ කාර්යය

239returnself.act3(x+shortcut)

#

රෙස්නෙට්ආකෘතිය

මෙයවර්ගීකරණය සඳහා අවසාන රේඛීය ස්තරය සහ සොෆ්ට්මැක්ස් නොමැතිව රෙස්නෙට් ආකෘතියේ පාදමකි.

රෙස්නෙට්සෑදී ඇත්තේ ගොඩගැසී ඇති අවශේෂ කුට්ටි හෝ බාධක අවශේෂ කුට්ටි වලින් ය. විශේෂාංග සිතියම් ප්රමාණය අඩක් පමණ දිග බ්ලොක් කිහිපයකින් පසුව අඩක් පමණ 2වේ. විශේෂාංග සිතියම් ප්රමාණය අඩු වූ විට නාලිකා ගණන වැඩි වේ. අවසාන වශයෙන් විශේෂාංග සිතියම දෛශික නිරූපණයක් ලබා ගැනීම සඳහා සාමාන්යයෙන් සකස් කර ඇත.

242classResNetBase(Module):

#

• n_blocks යනු එක් එක් විශේෂාංග සිතියම් ප්රමාණය සඳහා කුට්ටි ගණන ලැයිස්තුවකි.
• n_channels එක් එක් විශේෂාංග සිතියම් ප්රමාණය සඳහා නාලිකා ගණන වේ.
• bottlenecks යනු බාධක වල නාලිකා ගණන වේ. මෙය නම් None , අවශේෂ කුට්ටි භාවිතා වේ.
• img_channels යනු ආදානයේ ඇති නාලිකා ගණන වේ.
• first_kernel_size ආරම්භක සංවලිත ස්ථරයේ කර්නල් ප්රමාණයයි

256def\_\_init\_\_(self,n\_blocks:List[int],n\_channels:List[int],257bottlenecks:Optional[List[int]]=None,258img\_channels:int=3,first\_kernel\_size:int=7):

#

267super().\_\_init\_\_()

#

එක්එක් විශේෂාංග සිතියම් ප්රමාණය සඳහා බ්ලොක් ගණන සහ නාලිකා ගණන

270assertlen(n\_blocks)==len(n\_channels)

#

බාධක අවශේෂ කුට්ටි භාවිතා කරන්නේ නම්, එක් එක් විශේෂාංග සිතියම් ප්රමාණය සඳහා බාධක වල නාලිකා ගණන සැපයිය යුතුය

273assertbottlenecksisNoneorlen(bottlenecks)==len(n\_channels)

#

පළමුඅවශේෂ කොටසෙහි නාලිකා ගණන img_channels දක්වා ආරම්භක සංවහන ස්ථර සිතියම් (n_channels[0] )

277self.conv=nn.Conv2d(img\_channels,n\_channels[0],278kernel\_size=first\_kernel\_size,stride=2,padding=first\_kernel\_size//2)

#

මූලිකකැටි ගැසීමෙන් පසු කණ්ඩායම් සම්මතය

280self.bn=nn.BatchNorm2d(n\_channels[0])

#

කුට්ටිලැයිස්තුව

283blocks=[]

#

පෙරස්ථරයෙන් (හෝ බ්ලොක්) නාලිකා ගණන

285prev\_channels=n\_channels[0]

#

එක්එක් විශේෂාංග සිතියම් ප්රමාණය හරහා ලූප්

287fori,channelsinenumerate(n\_channels):

#

නවවිශේෂාංග සිතියම් ප්රමාණය සඳහා වන පළමු කොටස, පළමු කොටස 2 හැර දිගු දිගක් ඇත

290stride=2iflen(blocks)==0else1291292ifbottlenecksisNone:

#

සිට prev_channels සිතියම් ගත කරනඅවශේෂ කොටස් channels

294blocks.append(ResidualBlock(prev\_channels,channels,stride=stride))295else:

#

සිට prev_channels සිතියම්ගත කරන බාධක අවශේෂ කොටස් channels

298blocks.append(BottleneckResidualBlock(prev\_channels,bottlenecks[i],channels,299stride=stride))

#

නාලිකාගණන වෙනස් කරන්න

302prev\_channels=channels

#

ඉතිරිකොටස් එකතු කරන්න - විශේෂාංග සිතියම් ප්රමාණය හෝ නාලිකා වල වෙනසක් නොමැත

304for\_inrange(n\_blocks[i]-1):305ifbottlenecksisNone:

#

අවශේෂ කුට්ටි

307blocks.append(ResidualBlock(channels,channels,stride=1))308else:

#

බාධක අවශේෂ කුට්ටි

310blocks.append(BottleneckResidualBlock(channels,bottlenecks[i],channels,stride=1))

#

කුට්ටිගොඩගසන්න

313self.blocks=nn.Sequential(\*blocks)

#

• x හැඩය ඇත [batch_size, img_channels, height, width]

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

#

මූලිකකැටි ගැසීම්සහ කණ්ඩායම් සාමාන්යකරණය

321x=self.bn(self.conv(x))

#

අවශේෂ(හෝ බාධක) කුට්ටි

323x=self.blocks(x)

#

x හැඩයෙන් වෙනස් [batch_size, channels, h, w] කරන්න [batch_size, channels, h * w]

325x=x.view(x.shape[0],x.shape[1],-1)

#

ගෝලීයසාමාන්ය තටාක

327returnx.mean(dim=-1)

Trending Research Paperslabml.ai