docs/si/gan/stylegan/index.html
[View code on Github](https://github.com/labmlai/annotated_deep_learning_paper_implementations/tree/master/labml_nn/gan/stylegan/ init.py)
මෙය PyTorch කඩදාසි ක්රියාත්මක කිරීමකි StyleGan 2 හඳුන්වා දෙන StyleGan හි රූපයේ ගුණාත්මකභාවය විශ්ලේෂණය කිරීම සහ වැඩි දියුණු කිරීම . StyleGan 2 යනු වැඩි දියුණු කිරීමකි StyleGan කඩදාසි වලින් උත්පාදක අහිතකර ජාල සඳහා ශෛලිය මත පදනම් වූ උත්පාදක ගෘහ නිර්මාණ ශිල්පය. සහ StyleGan පදනම් වී ඇත්තේ කඩදාසි වලින් ප්රගතිශීලී GAN මත ය වැඩි දියුණු කළ ගුණාත්මකභාවය, ස්ථායිතාව සහ විචලනය සඳහා GANs ප්රගතිශීලී වර්ධනය. මෙම පත්රිකා තුනම NVIDIA AIවෙතින් එකම කතුවරුන්ගෙන් වේ.
අපගේක්රියාත්මක කිරීම අවම වේ StyleGAN 2 ආදර්ශ පුහුණු කේතය. ක්රියාත්මක කිරීම සරල ලෙස තබා ගැනීම සඳහා සහාය වන්නේ තනි GPU පුහුණුවක් පමණි. පුහුණු ලූපය ඇතුළුව කේත පේළි 500 කට වඩා අඩු මට්ටමක තබා ගැනීම සඳහා එය හැකිලීමට අපට හැකි විය.
🏃මෙන්න පුහුණු කේතය: experiment.py.
මේවා80K පියවර සඳහා පුහුණුවෙන් පසු ජනනය කරන ලද 64×64 රූප වේ.
අපිමුලින්ම උසස් මට්ටමේ ප්රශ්න පත්ර තුන හඳුන්වා දෙන්නෙමු.
උත්පාදකඅහිතකර ජාලයන් සංරචක දෙකක් ඇත; උත්පාදක යන්ත්රය සහ වෙනස්කම් කරන්නා. උත්පාදක ජාලය අහඹු ගුප්ත දෛශිකයක් (z∈Z) ගෙන යථාර්ථවාදී රූපයක් ජනනය කිරීමට උත්සාහ කරයි. වෙනස්කම් කිරීමේ ජාලය සැබෑ රූප ජනනය කරන ලද රූප වලින් වෙන්කර හඳුනා ගැනීමට උත්සාහ කරයි. අපි ජාල දෙක එකට පුහුණු කරන විට උත්පාදක යන්ත්රය සැබෑ රූප වලින් වෙන් කොට හඳුනාගත නොහැකි රූප ජනනය කිරීමට පටන් ගනී.
ප්රගතිශීලීGAN ප්රමාණයෙන් ඉහළ විභේදන රූප (1080×1080) ජනනය කරයි. එය එසේ කරන්නේ රූපයේ ප්රමාණය ක්රමයෙන් වැඩි කිරීමෙනි. පළමුව, එය 4×4 රූපයක් නිපදවන ජාලයක් පුහුණු කරයි 8×8 , පසුව 16×16 රූපයක්, සහ යනාදිය අපේක්ෂිත රූප විභේදනය දක්වා.
සෑමවිභේදනයකදීම, උත්පාදක ජාලය මඟින් ප්රතිරූපයක් නිපදවයි ගුප්ත අවකාශයේ එය RGB බවට පරිවර්තනය 1×1 වේ. අපි අඩු විභේදනයක සිට ඉහළ විභේදනයක් දක්වා ඉදිරියට යන විට (සිට 4×4 කියන්න 8×8 ) අපි ගුප්ත රූපය පරිමාණය කර 2× නව බ්ලොක් එකක් එකතු කරමු (දෙකක් 3×3 කැටි ගැසුණු ස්ථර) සහ RGB ලබා ගැනීම සඳහා නව 1×1 තට්ටුවක්. 2× පරිමාණය කරන ලද 4×4 RGB රූපයට අවශේෂ සම්බන්ධතාවයක් එක් කිරීමෙන් සංක්රාන්තිය සුමටව සිදු කෙරේ. නව කොටස භාර ගැනීමට ඉඩ දීම සඳහා මෙම අවශේෂ සම්බන්ධතාවයේ බර සෙමෙන් අඩු වේ.
වෙනස්කම්කරන්නා යනු උත්පාදක ජාලයේ දර්පණ පිළිබිඹුවක් වේ. වෙනස්කම් කරන්නාගේ ප්රගතිශීලී වර්ධනය ද ඒ හා සමානව සිදු කෙරේ.
2× සහ 0.5× විශේෂාංග සිතියම් විභේදන පරිමාණය සහ පරිමාණය දක්වයි. 4×4, 8×4,... උත්පාදක යන්ත්රයේ හෝ වෙනස්කම් කිරීමේ කොටසෙහි විශේෂාංග සිතියම් විභේදනය දක්වයි. සෑම වෙනස්කම් කරන්නෙකු සහ උත්පාදක බ්ලොක් එකක් කාන්දු වන RelU සක්රිය කිරීම් සහිත කැටි ගැසුණු ස්ථර 2 කින් සමන්විත වේ.
ක්රියාත්මකකිරීමේදී අප පහත සාකච්ඡා කළ විචලනය සහ සමාන ඉගෙනුම් අනුපාතය වැඩි කිරීම සඳහා ඔවුන් මිනිබැච් සම්මත අපගමනය භාවිතා කරයි. ඔවුන් පික්සල් අනුව සාමාන්යකරණය භාවිතා කරන අතර එහිදී සෑම පික්සෙල් එකකම විශේෂාංග දෛශිකය සාමාන්යකරණය වේ. ඔවුන් සියලු කැටි ගැසුණු ස්ථර ප්රතිදානයන් සඳහා මෙය අදාළ වේ (RGB හැර).
StyleGANහි උත්පාදක යන්ත්රය වැඩි දියුණු කරයි ප්රගතිශීලී GAN වෙනස්කම් කරන ගෘහ නිර්මාණ ශිල්පය එලෙසම තබා ගනී.
එයඅහඹු ගුප්ත දෛශිකය (z∈Z) වෙනස් ගුප්ත අවකාශයකට (w∈W) සිතියම් ගත කරයි, ස්ථර 8 ක ස්නායුක ජාලයක් ඇත. මෙය විචලනයන්ගේ සාධක වඩාත් රේඛීය (disentangled) වන අතරමැදි ගුප්ත W අවකාශයක් ලබා දෙයි.
එවිට w එක් ස්ථරයකට දෛශික ( ශෛලීන් ) දෙකකට පරිවර්තනය වන yi=(ys,i,yb,i)=fAi(w) අතර i, එක් එක් ස්ථරයේ පරිමාණය හා මාරුවීම (පක්ෂග්රාහී වීම) සඳහා භාවිතා වේ AdaIN ක්රියාකරු (සාමාන්යකරණය සහ පරිමාණය): AdaIN(xi,yi)=ys,iσ(xi)xi−μ(xi)+yb,i
උත්පාදකයන්ත්රය යාබද මෝස්තර සහසම්බන්ධිත යැයි උපකල්පනය කිරීම වැළැක්වීම සඳහා, ඔවුන් අහඹු ලෙස විවිධ බ්ලොක් සඳහා විවිධ මෝස්තර භාවිතා කරයි. එනම්, ඒවා ගුප්ත දෛශික දෙකක් (z1,z2) සහ අනුරූප (w1,w2) නියැදි කර සමහර බ්ලොක් සඳහා w1 පදනම් වූ මෝස්තර සහ සමහරක් සඳහා w2 පදනම් වූ මෝස්තර භාවිතා කරයි අහඹු ලෙස කළු පැහැයක් ගනී.
සෑමබ්ලොක් එකකටම ශබ්දය ලබා දී ඇති අතර එමඟින් උත්පාදක යන්ත්රය වඩාත් යථාර්ථවාදී රූප නිර්මාණය කිරීමට උපකාරී වේ. උගත් බරකින් එක් නාලිකාවකට ශබ්දය පරිමාණය වේ.
සියලුමඉහළ සහ පහළ නියැදි මෙහෙයුම් ද්විතියර් සුමටනය සමඟ ඇත.
A රේඛීය ස්ථරයක් දක්වයි. B විකාශන හා පරිමාණ මෙහෙයුමක් දක්වයි (ශබ්දය තනි නාලිකාවකි). StyleGan ප්රගතිශීලී GAN වැනි ප්රගතිශීලී වර්ධනය ද භාවිතා කරයි.
StyleGan2 උත්පාදක යන්ත්රය සහ වෙනස්කම් කරන්නා යන දෙකම වෙනස් කරයි StyleGan.
ඔවුන් AdaIN ක්රියාකරු ඉවත් කර බර මොඩියුලේෂන් සහ ඩිමොඩියුලේෂන් පියවරෙන් එය ප්රතිස්ථාපනය කරයි. මෙමඟින් ජනනය කරන ලද රූපවල ඇති ජල බිඳිති කෞතුක වස්තු ලෙස ඔවුන් හඳුන්වන දේ වැඩි දියුණු කළ යුතු අතර ඒවා AdaIN ක්රියාකරු තුළ සාමාන්යකරණය වීම නිසා ඇතිවේ. ස්ථරයකට ශෛලීය දෛශිකය ගණනය wi∈W කරනු ලැබේ si=fAi(wi).
එවිටකැටි ගැසුණු බර w පහත පරිදි මොඩියුලේට් වේ. (w මෙහි දී අතරමැදි ගුප්ත අවකාශය නොවන පඩි අදහස්, අපි කඩදාසි ලෙස එම අංකනය දැඩිව බැඳී සිටින.)
wi,j,k′=si⋅wi,j,k එවිට එය සාමාන්යකරණය කිරීමෙන් ඉවත් කරනු i ලැබේ, ආදාන නාලිකාව wi,j,k′′=∑i,kwi,j,k′2+ϵwi,j,k′ කොතැනද, ප්රතිදාන නාලිකාව j වන අතර k යනු කර්නල් දර්ශකයයි.
මාර්ගදිග නියාමනය මඟින් ජනනය කරන ලද රූපයේ ශුන්ය නොවන, ස්ථාවර ප්රමාණයේ වෙනසක් ඇති W කිරීම සඳහා ස්ථාවර ප්රමාණයේ පියවරක් දිරිමත් කරයි.
StyleGan2වෙනස්කම් කරන්නා තුළ අවශේෂ සම්බන්ධතා (පහළට නියැදීම සමඟ) භාවිතා කරන අතර උත්පාදක යන්ත්රයේ ඉහළ නියැදීම් සමඟ සම්බන්ධතා මඟ හරින්න (එක් එක් ස්ථරයෙන් RGB ප්රතිදානයන් එකතු කරනු ලැබේ - විශේෂාංග සිතියම්වල අවශේෂ සම්බන්ධතා නොමැත). පුහුණුව ආරම්භයේ දී අඩු විභේදන ස්ථරවල දායකත්වය ඉහළ මට්ටමක පවතින බවත් පසුව අධි-විභේදන ස්ථර භාර ගන්නා බවත් අත්හදා බැලීම් සමඟ ඔවුන් පෙන්වා දෙයි.
148importmath149fromtypingimportTuple,Optional,List150151importnumpyasnp152importtorch153importtorch.nn.functionalasF154importtorch.utils.data155fromtorchimportnn
මෙයරේඛීය ස්ථර 8 ක් සහිත MLP වේ. සිතියම්කරණ ජාලය ගුප්ත දෛශිකය අතරමැදි ගුප්ත z∈W අවකාශයකට සිතියම් ගත w∈Wකරයි. W විචල්යතාවයේ සාධක වඩාත් රේඛීය වන රූප අවකාශයෙන් අවකාශය විසුරුවා හරිනු ඇත.
158classMappingNetwork(nn.Module):
features යනු විශේෂාංග ගණන z සහ wn_layers සිතියම්කරණ ජාලයේ ස්ථර ගණන වේ.173def\_\_init\_\_(self,features:int,n\_layers:int):
178super().\_\_init\_\_()
MLPසාදන්න
181layers=[]182foriinrange(n\_layers):
සමාන ඉගෙනුම්-අනුපාත රේඛීය ස්ථර
184layers.append(EqualizedLinear(features,features))
කාන්දුවන රිලේ
186layers.append(nn.LeakyReLU(negative\_slope=0.2,inplace=True))187188self.net=nn.Sequential(\*layers)
190defforward(self,z:torch.Tensor):
සාමාන්යකරන්න z
192z=F.normalize(z,dim=1)
සිතියම z w
194returnself.net(z)
A රේඛීය ස්ථරයක් දක්වයි. B විකාශන හා පරිමාණ මෙහෙයුමක් දක්වයි (ශබ්දය තනි නාලිකාවකි). toRGB ශෛලීය මොඩියුලේෂන් එකක් ද ඇති අතර එය සරල ලෙස තබා ගැනීම සඳහා රූප සටහනේ පෙන්වා නැත.
උත්පාදකයන්ත්රය ඉගෙන ගත් නියතයකින් ආරම්භ වේ. එවිට එය කුට්ටි මාලාවක් ඇත. විශේෂාංග සිතියම් විභේදනය සෑම බ්ලොක් එකකම දෙගුණ වේ සෑම බ්ලොක් එකක්ම RGB රූපයක් ප්රතිදානය කරන අතර අවසාන RGB රූපය ලබා ගැනීම සඳහා ඒවා පරිමාණය කර සාරාංශගත කර ඇත.
197classGenerator(nn.Module):
log_resolution රූප log2 විභේදනයේ වේd_latent හි මානයන් වේ wn_features වැඩිම යෝජනාව දී convolution ස්ථරය විශේෂාංග සංඛ්යාව (අවසාන වාරණ)max_features ඕනෑම උත්පාදක වාරණයක උපරිම විශේෂාංග ගණන214def\_\_init\_\_(self,log\_resolution:int,d\_latent:int,n\_features:int=32,max\_features:int=512):
221super().\_\_init\_\_()
එක්එක් කොටස සඳහා විශේෂාංග ගණන ගණනය කරන්න
වගේදෙයක් [512, 512, 256, 128, 64, 32]
226features=[min(max\_features,n\_features\*(2\*\*i))foriinrange(log\_resolution-2,-1,-1)]
උත්පාදකකුට්ටි ගණන
228self.n\_blocks=len(features)
පුහුණුකළ හැකි 4×4 නියතය
231self.initial\_constant=nn.Parameter(torch.randn((1,features[0],4,4)))
RGBලබා ගැනීම සඳහා 4×4 විභේදනය සහ ස්ථරය සඳහා පළමු විලාසිතාවේ කොටස
234self.style\_block=StyleBlock(d\_latent,features[0],features[0])235self.to\_rgb=ToRGB(d\_latent,features[0])
උත්පාදකකුට්ටි
238blocks=[GeneratorBlock(d\_latent,features[i-1],features[i])foriinrange(1,self.n\_blocks)]239self.blocks=nn.ModuleList(blocks)
2× නියැදි ස්ථරය දක්වා. විශේෂාංග අවකාශය එක් එක් වාරණ දී sampled දක්වා
ඇත
243self.up\_sample=UpSample()
w වේ w. මිශ්ර-මෝස්තර සඳහා (විවිධ ස්ථර w සඳහා වෙනස් භාවිතා කරන්න), අපි එක් එක් උත්පාදක කොටස wසඳහා වෙනම ලබා දෙන්නෙමු. එහි හැඩය ඇත [n_blocks, batch_size, d_latent] .input_noise යනු එක් එක් කොටස සඳහා ශබ්දය. එක් එක් වාරණ (ආරම්භක හැර) එක් එක් convolution ස්ථරය පසු ශබ්ද යෙදවුම් දෙකක් ඇති නිසා එය ශබ්ද සංවේදක යුගල ලැයිස්තුවකි (රූප සටහන බලන්න).245defforward(self,w:torch.Tensor,input\_noise:List[Tuple[Optional[torch.Tensor],Optional[torch.Tensor]]]):
කණ්ඩායම්ප්රමාණය ලබා ගන්න
255batch\_size=w.shape[1]
කණ්ඩායම්ප්රමාණයට ගැලපෙන පරිදි උගත් නියතය පුළුල් කරන්න
258x=self.initial\_constant.expand(batch\_size,-1,-1,-1)
පළමුවිලාසිතාවේ කොටස
261x=self.style\_block(x,w[0],input\_noise[0][1])
පළමුrgb රූපය ලබා ගන්න
263rgb=self.to\_rgb(x,w[0])
ඉතිරිකොටස් තක්සේරු කරන්න
266foriinrange(1,self.n\_blocks):
විශේෂාංගසිතියම සාම්පල කරන්න
268x=self.up\_sample(x)
උත්පාදක කොටස හරහා එය ධාවනය කරන්න
270x,rgb\_new=self.blocks[i-1](x,w[i],input\_noise[i])
ඉහළටRGB රූපය සාම්පල කර බ්ලොක් එකෙන් rgb වෙත එක් කරන්න
272rgb=self.up\_sample(rgb)+rgb\_new
අවසානRGB රූපය ආපසු ලබා දෙන්න
275returnrgb
A රේඛීය ස්ථරයක් දක්වයි. B විකාශන හා පරිමාණ මෙහෙයුමක් දක්වයි (ශබ්දය තනි නාලිකාවකි). toRGB ශෛලීය මොඩියුලේෂන් එකක් ද ඇති අතර එය සරල ලෙස තබා ගැනීම සඳහා රූප සටහනේ පෙන්වා නැත.
උත්පාදකකොටස ශෛලීය කුට්ටි දෙකකින් (ශෛලීය මොඩියුලේෂන් සහිත3×3 කැටි කිරීම්) සහ RGB ප්රතිදානයකින් සමන්විත වේ.
278classGeneratorBlock(nn.Module):
d_latent හි මානයන් වේ win_features ආදාන විශේෂාංග සිතියමේ විශේෂාංග ගණන වේout_features ප්රතිදාන විශේෂාංග සිතියමේ ඇති විශේෂාංග ගණන294def\_\_init\_\_(self,d\_latent:int,in\_features:int,out\_features:int):
300super().\_\_init\_\_()
පළමු විලාසිතාවේ බ්ලොක් විශේෂාංග සිතියම් ප්රමාණය වෙනස් කරයි out_features
303self.style\_block1=StyleBlock(d\_latent,in\_features,out\_features)
දෙවන ශෛලිය වාරණ
305self.style\_block2=StyleBlock(d\_latent,out\_features,out\_features)
ටොර්ජීබී ස්ථරය
308self.to\_rgb=ToRGB(d\_latent,out\_features)
x හැඩයේ ආදාන විශේෂාංග සිතියමයි [batch_size, in_features, height, width]w හැඩය w සමඟ ඇත [batch_size, d_latent]noise හැඩය ශබ්ද tensors දෙකක් tuple වේ [batch_size, 1, height, width]310defforward(self,x:torch.Tensor,w:torch.Tensor,noise:Tuple[Optional[torch.Tensor],Optional[torch.Tensor]]):
පළමුශබ්ද ටෙන්සර් සහිත පළමු විලාසිතාවේ කොටස. ප්රතිදානය හැඩයෙන් යුක්ත වේ [batch_size, out_features, height, width]
318x=self.style\_block1(x,w,noise[0])
දෙවනශබ්ද ටෙන්සර් සහිත දෙවන විලාසිතාවේ කොටස. ප්රතිදානය හැඩයෙන් යුක්ත වේ [batch_size, out_features, height, width]
321x=self.style\_block2(x,w,noise[1])
RGBරූපය ලබා ගන්න
324rgb=self.to\_rgb(x,w)
විශේෂාංගසිතියම සහ rgb රූපය ආපසු ලබා දෙන්න
327returnx,rgb
A රේඛීය ස්ථරයක් දක්වයි. B විකාශන හා පරිමාණ මෙහෙයුමක් දක්වයි (ශබ්දය තනි නාලිකාවකි).
ස්ටයිල්බ්ලොක් බර මොඩියුලේෂන් කැටි කිරීමේ තට්ටුවක් ඇත.
330classStyleBlock(nn.Module):
d_latent හි මානයන් වේ win_features ආදාන විශේෂාංග සිතියමේ විශේෂාංග ගණන වේout_features ප්රතිදාන විශේෂාංග සිතියමේ ඇති විශේෂාංග ගණන344def\_\_init\_\_(self,d\_latent:int,in\_features:int,out\_features:int):
350super().\_\_init\_\_()
සමාන ඉගෙනීම-අනුපාත රේඛීය ස්ථරයක් සමඟ w (රූප සටහනෙන් දැක්වේ) ශෛලීය දෛශිකය ලබා ගන්න A
353self.to\_style=EqualizedLinear(d\_latent,in\_features,bias=1.0)
සිරුරේබර මොඩියුලේටඩ් කැටි ගැසුණු ස්ථරය
355self.conv=Conv2dWeightModulate(in\_features,out\_features,kernel\_size=3)
ශබ්දපරිමාණය
357self.scale\_noise=nn.Parameter(torch.zeros(1))
නැඹුරුව
359self.bias=nn.Parameter(torch.zeros(out\_features))
සක්රියකිරීමේ කාර්යය
362self.activation=nn.LeakyReLU(0.2,True)
x හැඩයේ ආදාන විශේෂාංග සිතියමයි [batch_size, in_features, height, width]w හැඩය w සමඟ ඇත [batch_size, d_latent]noise හැඩයේ ආතතිකාරයකි [batch_size, 1, height, width]364defforward(self,x:torch.Tensor,w:torch.Tensor,noise:Optional[torch.Tensor]):
දෛශිකශෛලිය ලබා ගන්න s
371s=self.to\_style(w)
බරමොඩියුලේටඩ් කැටි ගැසිම
373x=self.conv(x,s)
පරිමාණයකර ශබ්දය එක් කරන්න
375ifnoiseisnotNone:376x=x+self.scale\_noise[None,:,None,None]\*noise
නැඹුරුවඑකතු කර සක්රිය කිරීමේ කාර්යය ඇගයීමට ලක් කරන්න
378returnself.activation(x+self.bias[None,:,None,None])
A රේඛීය ස්ථරයක් දක්වයි.
1×1 සංවලිත භාවිතයෙන් විශේෂාංග සිතියමකින් RGB රූපයක් ජනනය කරයි.
381classToRGB(nn.Module):
d_latent හි මානයන් වේ wfeatures විශේෂාංග සිතියමේ විශේෂාංග ගණන394def\_\_init\_\_(self,d\_latent:int,features:int):
399super().\_\_init\_\_()
සමාන ඉගෙනීම-අනුපාත රේඛීය ස්ථරයක් සමඟ w (රූප සටහනෙන් දැක්වේ) ශෛලීය දෛශිකය ලබා ගන්න A
402self.to\_style=EqualizedLinear(d\_latent,features,bias=1.0)
ඩිමොඩියුලේෂන්නොමැතිව බර මොඩියුලේටඩ් කැටි ගැසුණු ස්ථරය
405self.conv=Conv2dWeightModulate(features,3,kernel\_size=1,demodulate=False)
නැඹුරුව
407self.bias=nn.Parameter(torch.zeros(3))
සක්රියකිරීමේ කාර්යය
409self.activation=nn.LeakyReLU(0.2,True)
x හැඩයේ ආදාන විශේෂාංග සිතියමයි [batch_size, in_features, height, width]w හැඩය w සමඟ ඇත [batch_size, d_latent]411defforward(self,x:torch.Tensor,w:torch.Tensor):
දෛශිකශෛලිය ලබා ගන්න s
417style=self.to\_style(w)
බරමොඩියුලේටඩ් කැටි ගැසිම
419x=self.conv(x,style)
නැඹුරුවඑකතු කර සක්රිය කිරීමේ කාර්යය ඇගයීමට ලක් කරන්න
421returnself.activation(x+self.bias[None,:,None,None])
මෙමස්තරය ශෛලීය දෛශිකය මගින් සංවහන බර පරිමාණයට ලක් කරන අතර එය සාමාන්යකරණය කිරීමෙන් ඩිමොඩියුලේට් කරයි.
424classConv2dWeightModulate(nn.Module):
in_features ආදාන විශේෂාංග සිතියමේ විශේෂාංග ගණන වේ
out_features ප්රතිදාන විශේෂාංග සිතියමේ ඇති විශේෂාංග ගණන
kernel_size යනු සංවහන කර්නලයේ ප්රමාණයයි
demodulate ධජය යනු එහි සම්මත අපගමනය අනුව බර සාමාන්යකරණය කළ යුතුද යන්නයි
eps සාමාන්යකරණය ϵ සඳහා වේ
431def\_\_init\_\_(self,in\_features:int,out\_features:int,kernel\_size:int,432demodulate:float=True,eps:float=1e-8):
440super().\_\_init\_\_()
නිමැවුම්විශේෂාංග ගණන
442self.out\_features=out\_features
බරසාමාන්යකරණය කළ යුතුද යන්න
444self.demodulate=demodulate
පෑඩින්ප්රමාණය
446self.padding=(kernel\_size-1)//2
සමාන ඉගෙනුම් අනුපාතය සහිත බර පරාමිතිය
449self.weight=EqualizedWeight([out\_features,in\_features,kernel\_size,kernel\_size])
ϵ
451self.eps=eps
x හැඩයේ ආදාන විශේෂාංග සිතියමයි [batch_size, in_features, height, width]s හැඩයේ ශෛලිය මත පදනම් වූ පරිමාණ ආතන්ය [batch_size, in_features]453defforward(self,x:torch.Tensor,s:torch.Tensor):
කණ්ඩායම්ප්රමාණය, උස සහ පළල ලබා ගන්න
460b,\_,h,w=x.shape
පරිමාණයන්නැවත සකස් කරන්න
463s=s[:,None,:,None,None]
ඉගෙනීමේ අනුපාතය සමාන බර ලබා ගන්න
465weights=self.weight()[None,:,:,:,:]
w‘i,j,k=si∗wi,j,k ආදාන නාලිකාව j යනු ප්රතිදාන නාලිකාව වන අතර කර්නල් දර්ශකය k වේ. i
ප්රතිresult ලය හැඩය ඇත [batch_size, out_features, in_features, kernel_size, kernel_size]
470weights=weights\*s
විරූපණයකරන්න
473ifself.demodulate:
σj=i,k∑(wi,j,k′)2+ϵ
475sigma\_inv=torch.rsqrt((weights\*\*2).sum(dim=(2,3,4),keepdim=True)+self.eps)
wi,j,k′′=∑i,k(wi,j,k′)2+ϵwi,j,k′
477weights=weights\*sigma\_inv
නැවතහැඩගස්වා x
480x=x.reshape(1,-1,h,w)
බරනැවත සකස් කරන්න
483\_,\_,\*ws=weights.shape484weights=weights.reshape(b\*self.out\_features,\*ws)
නියැදිනැණවත් කර්නලය සමඟ සංකෝචනය කාර්යක්ෂමව ගණනය කිරීම සඳහා කාණ්ඩගත කැටි ගැන්විම භාවිතා කරන්න. එනම් කණ්ඩායමේ එක් එක් නියැදිය සඳහා අපට වෙනස් කර්නලයක් (බර) ඇත
488x=F.conv2d(x,weights,padding=self.padding,groups=b)
නැවත x``[batch_size, out_features, height, width] හැඩගස්වා ආපසු යන්න
491returnx.reshape(-1,self.out\_features,h,w)
වෙනස්කම්කරන්නා පළමුව රූපය එකම විභේදනයේ විශේෂාංග සිතියමකට පරිවර්තනය කර පසුව අවශේෂ සම්බන්ධතා සහිත කුට්ටි මාලාවක් හරහා එය ධාවනය කරයි. විශේෂාංග ගණන දෙගුණ කරන අතර විභේදනය එක් එක් බ්ලොක් 2× එකේ පහළ-නියැදි කර ඇත.
494classDiscriminator(nn.Module):
log_resolution රූප log2 විභේදනයේ වේn_features වැඩිම යෝජනාව දී convolution ස්ථරය විශේෂාංග සංඛ්යාව (පළමු වාරණ)max_features ඕනෑම උත්පාදක වාරණයක උපරිම විශේෂාංග ගණන508def\_\_init\_\_(self,log\_resolution:int,n\_features:int=64,max\_features:int=512):
514super().\_\_init\_\_()
RGBරූපය විශේෂාංග n_features ගණනාවක් සහිත විශේෂාංග සිතියමක් බවට පරිවර්තනය කිරීමේ ස්ථරය.
517self.from\_rgb=nn.Sequential(518EqualizedConv2d(3,n\_features,1),519nn.LeakyReLU(0.2,True),520)
එක්එක් කොටස සඳහා විශේෂාංග ගණන ගණනය කරන්න.
වගේදෙයක් [64, 128, 256, 512, 512, 512] .
525features=[min(max\_features,n\_features\*(2\*\*i))foriinrange(log\_resolution-1)]
527n\_blocks=len(features)-1
වෙනස්කම්කරන්නා කුට්ටි
529blocks=[DiscriminatorBlock(features[i],features[i+1])foriinrange(n\_blocks)]530self.blocks=nn.Sequential(\*blocks)
533self.std\_dev=MiniBatchStdDev()
සම්මතඅපගමනය සිතියම එකතු කිරීමෙන් පසු විශේෂාංග ගණන
535final\_features=features[-1]+1
අවසාන 3×3 කැටි ගැසුණු ස්ථරය
537self.conv=EqualizedConv2d(final\_features,final\_features,3)
වර්ගීකරණයලබා ගැනීම සඳහා අවසාන රේඛීය ස්ථරය
539self.final=EqualizedLinear(2\*2\*final\_features,1)
x යනු හැඩයේ ආදාන රූපයයි [batch_size, 3, height, width]541defforward(self,x:torch.Tensor):
රූපයසාමාන්යකරණය කිරීමට උත්සාහ කරන්න (මෙය මුළුමනින්ම විකල්පයකි, නමුත් මුල් පුහුණුව ටිකක් වේගවත් කරන්න)
547x=x-0.5
RGBවෙතින් පරිවර්තනය කරන්න
549x=self.from\_rgb(x)
වෙනස්කම් කරන්නා කුට්ටි හරහා ධාවනය කරන්න
551x=self.blocks(x)
කුඩා කණ්ඩායම් සම්මත අපගමනය ගණනය කිරීම සහ තක්සේරු කිරීම
554x=self.std\_dev(x)
3×3 කැටි ගැසිම
556x=self.conv(x)
සමතලාකරන්න
558x=x.reshape(x.shape[0],-1)
වර්ගීකරණලකුණු ආපසු ලබා දෙන්න
560returnself.final(x)
Disturistatorබ්ලොක් අවශේෂ සම්බන්ධතාවයක් සහිත 3×3 ව්යාංජන දෙකකින් සමන්විත වේ.
563classDiscriminatorBlock(nn.Module):
in_features ආදාන විශේෂාංග සිතියමේ විශේෂාංග ගණන වේout_features ප්රතිදාන විශේෂාංග සිතියමේ ඇති විශේෂාංග ගණන574def\_\_init\_\_(self,in\_features,out\_features):
579super().\_\_init\_\_()
අවශේෂසම්බන්ධතාවය සඳහා පහළ-නියැදීම් සහ 1×1 කැටි ගැසීම ස්ථරය
581self.residual=nn.Sequential(DownSample(),582EqualizedConv2d(in\_features,out\_features,kernel\_size=1))
3×3 ව්යාකූලතා දෙකක්
585self.block=nn.Sequential(586EqualizedConv2d(in\_features,in\_features,kernel\_size=3,padding=1),587nn.LeakyReLU(0.2,True),588EqualizedConv2d(in\_features,out\_features,kernel\_size=3,padding=1),589nn.LeakyReLU(0.2,True),590)
පහළ-නියැදිස්ථරය
593self.down\_sample=DownSample()
අවශේෂඑකතු 21 කිරීමෙන් පසු පරිමාණ සාධකය
596self.scale=1/math.sqrt(2)
598defforward(self,x):
අවශේෂසම්බන්ධතාවය ලබා ගන්න
600residual=self.residual(x)
සම්මුතීන්
603x=self.block(x)
පහළ-නියැදිය
605x=self.down\_sample(x)
අවශේෂසහ පරිමාණය එකතු කරන්න
608return(x+residual)\*self.scale
කුඩාකණ්ඩායම් සම්මත අපගමනය විශේෂාංග සිතියමේ ඇති එක් එක් ලක්ෂණය සඳහා කුඩා කණ්ඩායමක් (හෝ කුඩා කණ්ඩායම තුළ ඇති උප කණ්ඩායම්) හරහා සම්මත අපගමනය ගණනය කරයි. එවිට එය සියලු සම්මත අපගමනයන්හි මධ්යන්යය ගෙන එය එක් අමතර අංගයක් ලෙස විශේෂාංග සිතියමට එකතු කරයි.
611classMiniBatchStdDev(nn.Module):
group_size සම්මත අපගමනය ගණනය කිරීම සඳහා සාම්පල ගණන වේ.623def\_\_init\_\_(self,group\_size:int=4):
627super().\_\_init\_\_()628self.group\_size=group\_size
x විශේෂාංග සිතියමයි630defforward(self,x:torch.Tensor):
කණ්ඩායම්ප්රමාණය කණ්ඩායම් ප්රමාණය අනුව බෙදිය හැකි දැයි පරීක්ෂා කරන්න
635assertx.shape[0]%self.group\_size==0
සාම්පලකණ්ඩායම් වලට බෙදන්න group_size , එක් එක් ලක්ෂණය සඳහා සම්මත අපගමනය ගණනය කිරීමට අපට අවශ්ය බැවින් අපි විශේෂාංග සිතියම තනි මානයකට සමතලා කරමු.
638grouped=x.view(self.group\_size,-1)
group_size සාම්පල අතර එක් එක් ලක්ෂණය සඳහා සම්මත අපගමනය ගණනය
μiσi=N1g∑xg,i=N1g∑(xg,i−μi)2+ϵ
645std=torch.sqrt(grouped.var(dim=0)+1e-8)
මධ්යන්යසම්මත අපගමනය ලබා ගන්න
647std=std.mean().view(1,1,1,1)
විශේෂාංගසිතියමට එක් කිරීම සඳහා සම්මත අපගමනය පුළුල් කරන්න
649b,\_,h,w=x.shape650std=std.expand(b,-1,h,w)
විශේෂාංගසිතියමට සම්මත අපගමනය (සංයුක්ත කරන්න)
652returntorch.cat([x,std],dim=1)
පහළ-නියැදිමෙහෙයුම ද්විලීන අන්තර්නිවේෂණය 2× භාවිතා කරමින් එක් එක් විශේෂාංග නාලිකාව සහ පරිමාණය සුමටනය කරයි. මෙය පදනම් වී ඇත්තේ කඩදාසි මත ය Convolutional Networks Shift-Invariant නැවතත්.
655classDownSample(nn.Module):
667def\_\_init\_\_(self):668super().\_\_init\_\_()
ස්තරයසුමටනය
670self.smooth=Smooth()
672defforward(self,x:torch.Tensor):
සුමටනයහෝ බොඳ කිරීම
674x=self.smooth(x)
පහළටපරිමාණය කර ඇත
676returnF.interpolate(x,(x.shape[2]//2,x.shape[3]//2),mode='bilinear',align\_corners=False)
දක්වා-නියැදිමෙහෙයුම මඟින් රූපය ඉහළට ගෙන යන 2× අතර එක් එක් විශේෂාංග නාලිකාව සුමටනය කරයි . මෙය පදනම් වී ඇත්තේ කඩදාසි මත ය Convolutional Networks Shift-Invariant නැවතත්.
679classUpSample(nn.Module):
690def\_\_init\_\_(self):691super().\_\_init\_\_()
දක්වා-නියැදීම්ස්ථරය
693self.up\_sample=nn.Upsample(scale\_factor=2,mode='bilinear',align\_corners=False)
ස්තරයසුමටනය
695self.smooth=Smooth()
697defforward(self,x:torch.Tensor):
ඉහළටනියැදිය සහ සුමටනය
699returnself.smooth(self.up\_sample(x))
මෙමස්තරය එක් එක් නාලිකාව බොඳ කරයි
702classSmooth(nn.Module):
711def\_\_init\_\_(self):712super().\_\_init\_\_()
කර්නලයබොඳ කිරීම
714kernel=[[1,2,1],715[2,4,2],716[1,2,1]]
කර්නලයPyTorch ටෙන්සරයක් බවට පරිවර්තනය කරන්න
718kernel=torch.tensor([[kernel]],dtype=torch.float)
කර්නලයසාමාන්යකරණය කරන්න
720kernel/=kernel.sum()
කර්නලයස්ථාවර පරාමිතියක් ලෙස සුරකින්න (ශ්රේණියේ යාවත්කාලීන කිරීම් නොමැත)
722self.kernel=nn.Parameter(kernel,requires\_grad=False)
පෑඩින්ස්ථරය
724self.pad=nn.ReplicationPad2d(1)
726defforward(self,x:torch.Tensor):
ආදානවිශේෂාංග සිතියමේ හැඩය ලබා ගන්න
728b,c,h,w=x.shape
සුමටනයසඳහා නැවත සකස් කරන්න
730x=x.view(-1,1,h,w)
පෑඩින්එකතු කරන්න
733x=self.pad(x)
කර්නලයසමඟ සුමටනය (බොඳ කිරීම)
736x=F.conv2d(x,self.kernel)
නැවතහැඩගස්වා නැවත පැමිණීම
739returnx.view(b,c,h,w)
මෙයරේඛීය ස්තරයක් සඳහා ඉගෙනීමේ අනුපාත සමාන බර භාවිතා කරයි.
742classEqualizedLinear(nn.Module):
in_features ආදාන විශේෂාංග සිතියමේ විශේෂාංග ගණන වේout_features ප්රතිදාන විශේෂාංග සිතියමේ ඇති විශේෂාංග ගණනbias යනු නැඹුරුව ආරම්භ කිරීම නියතය751def\_\_init\_\_(self,in\_features:int,out\_features:int,bias:float=0.):
758super().\_\_init\_\_()
760self.weight=EqualizedWeight([out\_features,in\_features])
නැඹුරුව
762self.bias=nn.Parameter(torch.ones(out\_features)\*bias)
764defforward(self,x:torch.Tensor):
රේඛීයපරිවර්තනය
766returnF.linear(x,self.weight(),bias=self.bias)
මෙයකැටි ගැසුණු ස්ථරයක් සඳහා ඉගෙනීම-අනුපාත සමාන බර භාවිතා කරයි.
769classEqualizedConv2d(nn.Module):
in_features ආදාන විශේෂාංග සිතියමේ විශේෂාංග ගණන වේ
out_features ප්රතිදාන විශේෂාංග සිතියමේ ඇති විශේෂාංග ගණන
kernel_size යනු සංවහන කර්නලයේ ප්රමාණයයි
padding එක් එක් ප්රමාණයේ මානයන්හි දෙපස එකතු කළ යුතු පෑඩින් වේ
778def\_\_init\_\_(self,in\_features:int,out\_features:int,779kernel\_size:int,padding:int=0):
786super().\_\_init\_\_()
පෑඩින්ප්රමාණය
788self.padding=padding
790self.weight=EqualizedWeight([out\_features,in\_features,kernel\_size,kernel\_size])
නැඹුරුව
792self.bias=nn.Parameter(torch.ones(out\_features))
794defforward(self,x:torch.Tensor):
සංවලිත
796returnF.conv2d(x,self.weight(),bias=self.bias,padding=self.padding)
මෙයපදනම් වී ඇත්තේ ප්රගතිශීලී GAN කඩදාසි වල හඳුන්වා දී ඇති සමාන ඉගෙනුම් අනුපාතය මත ය. N(0,c) ඔවුන් බර ආරම්භ කරනවා වෙනුවට බර ආරම්භ කර N(0,1) එය භාවිතා කරන c විට ඒවා ගුණ කරන්න. wi=cw^i
ගබඩාකරන ලද w^ පරාමිතීන්හි අනුක්රමික ගුණ කරන c නමුත් ආදම් වැනි ප්රශස්තිකයන් වර්ග කළ ශ්රේණියක ධාවන මධ්යන්යයකින් ඒවා සාමාන්යකරණය කරන බැවින් මෙයට බලපෑමක් ඇති නොකරයි.
ප්රශස්තිකරණයාවත්කාලීන w^ කිරීම් ඉගෙනුම් අනුපාතයට සමානුපාතික λවේ. නමුත් w ඵලදායී පඩි සමානුපාතිකව යාවත්කාලීන වේ cλ. සමාන ඉගෙනුම් අනුපාතය තොරව, ඵලදායී පඩි පමණක් සමානුපාතිකව යාවත්කාලීන ලැබෙනු ඇත λ.
එබැවින්අපි මෙම බර පරාමිතීන් c සඳහා ඉගෙනුම් අනුපාතය effectively ලදායී ලෙස පරිමාණය කරමු.
799classEqualizedWeight(nn.Module):
shape බර පරාමිතියේ හැඩයයි820def\_\_init\_\_(self,shape:List[int]):
824super().\_\_init\_\_()
ඔහුආරම්භ කිරීම නියතය
827self.c=1/math.sqrt(np.prod(shape[1:]))
සමඟබර ආරම්භ කරන්න N(0,1)
829self.weight=nn.Parameter(torch.randn(shape))
බරගුණ කිරීමේ සංගුණකය
832defforward(self):
බරවැඩි c කර ආපසු යන්න
834returnself.weight\*self.c
කඩදාසිවලින් R1 විධිමත් කිරීමේ ද ality ුවම මෙයයි GANs සඳහා පුහුණු ක්රම ඇත්ත වශයෙන්ම අභිසාරී වන්නේ කුමක්ද?.
R1(ψ)=2γEpD(x)[∥∇xDψ(x)2∥]
ඒතමයි අපි රූප සම්බන්ධයෙන් වෙනස්කම් කරන්නාගේ L2 සම්මතය අඩු කිරීමට උත්සාහ කරන්නේ සැබෑ රූප සඳහා (PD).
837classGradientPenalty(nn.Module):
x වේ x∼D
d වේ D(x)
853defforward(self,x:torch.Tensor,d:torch.Tensor):
කණ්ඩායම්ප්රමාණය ලබා ගන්න
860batch\_size=x.shape[0]
සම්බන්ධයෙන්අනුක්රමික ගණනය කරන්න x. D(x) grad_outputs අපට අනුක්රමික අවශ්ය 1 බැවින් සකසා ඇති අතර D(x), මෙම අලාභය මත බර සම්බන්ධයෙන් අනුක්රමික ගණනය කළ යුතු බැවින් අපි ප්රස්ථාරයක් නිර්මාණය කර රඳවා තබා ගත යුතුය.
866gradients,\*\_=torch.autograd.grad(outputs=d,867inputs=x,868grad\_outputs=d.new\_ones(d.shape),869create\_graph=True)
සම්මතයගණනය කිරීම සඳහා අනුක්රමික නැවත සකස් කරන්න
872gradients=gradients.reshape(batch\_size,-1)
සම්මතයගණනය කරන්න ∥∇xD(x)2∥
874norm=gradients.norm(2,dim=-1)
අලාභයආපසු ලබා දෙන්න ∥∇xDψ(x)2∥
876returntorch.mean(norm\*\*2)
මෙමනියාමනය මඟින් රූපයේ ස්ථාවර ප්රමාණයේ වෙනසක් ඇති කිරීම w සඳහා ස්ථාවර ප්රමාණයේ පියවරක් දිරිමත් කරයි.
Ew∼f(z),y∼N(0,I)(∥Jw⊤y∥2−a)2
ජැකෝබියන් Jw කොහෙද Jw=∂w∂g, w සිතියම්කරණ w∈W ජාලයෙන් සාම්පල ලබා ඇත, සහ y ඒවා ශබ්දය සහිත රූප N(0,I).
a පුහුණුව ඉදිරියට යත්ම ඝාතීය චලනය වන සාමාන්යය වේ. ∥Jw⊤y∥2
Jw⊤y ජැකොබියන් භාවිතයෙන් පැහැදිලිව ගණනය නොකර ගණනය කරනු ලැබේ Jw⊤y=∇w(g(w)⋅y)
879classPathLengthPenalty(nn.Module):
beta ඝාතීය චලනය වන සාමාන්යය ගණනය කිරීම සඳහා β භාවිතා කරන නියතය a903def\_\_init\_\_(self,beta:float):
907super().\_\_init\_\_()
β
910self.beta=beta
ගණනයකරන ලද පියවර ගණන N
912self.steps=nn.Parameter(torch.tensor(0.),requires\_grad=False)
පුහුණුවේ i-th පියවරේදී එහි වටිනාකම Jw⊤y i=1∑Nβ(N−i)[Jw⊤y]i [Jw⊤y]i කොතැනද? ඝාතීය එකතුව
916self.exp\_sum\_a=nn.Parameter(torch.tensor(0.),requires\_grad=False)
ww හැඩයේ කණ්ඩායමයි [batch_size, d_latent]x හැඩයේ ජනනය කරන ලද රූප වේ [batch_size, 3, height, width]918defforward(self,w:torch.Tensor,x:torch.Tensor):
උපාංගයලබා ගන්න
925device=x.device
පික්සල්ගණන ලබා ගන්න
927image\_size=x.shape[2]\*x.shape[3]
ගණනයකරන්න y∈N(0,I)
929y=torch.randn(x.shape,device=device)
රූපප්රමාණයේ වර්ග මූලය ගණනය (g(w)⋅y) කර සාමාන්යකරණය කරන්න. මෙය පරිමාණය යනු කඩදාසි වල සඳහන් නොවන නමුත් ඒවා ක්රියාත්මකකිරීමේදී දක්නට ලැබුණි.
933output=(x\*y).sum()/math.sqrt(image\_size)
ලබාගැනීම සඳහා අනුක්රමික ගණනය කරන්න Jw⊤y
936gradients,\*\_=torch.autograd.grad(outputs=output,937inputs=w,938grad\_outputs=torch.ones(output.shape,device=device),939create\_graph=True)
L2හි සාමාන්යය ගණනය කරන්න Jw⊤y
942norm=(gradients\*\*2).sum(dim=2).mean(dim=1).sqrt()
පළමුපියවරෙන් පසු විධිමත් කරන්න
945ifself.steps\>0:
ගණනයකරන්න a 1−βN1i=1∑Nβ(N−i)[Jw⊤y]i
948a=self.exp\_sum\_a/(1-self.beta\*\*self.steps)
දpenalty ුවම ගණනය කරන්න Ew∼f(z),y∼N(0,I)(∥Jw⊤y∥2−a)2
952loss=torch.mean((norm-a)\*\*2)953else:
අපටගණනය කළ නොහැකි නම් ව්යාජ අලාභයක් ආපසු ලබා දෙන්න a
955loss=norm.new\_tensor(0)
මධ්යන්යයගණනය කරන්න ∥Jw⊤y∥2
958mean=norm.mean().detach()
ඝාතීයමුදලක් යාවත්කාලීන කරන්න
960self.exp\_sum\_a.mul\_(self.beta).add\_(mean,alpha=1-self.beta)
වර්ධකය N
962self.steps.add\_(1.)
දpenalty ුවම ආපසු දෙන්න
965returnloss