def __init__(self, oc, nz, ngf, use_swish, sz):
super(FastGANGenerator, self).__init__()
self.sz = sz
dims = {
4: 16 * ngf,
8: 8 * ngf,
16: 4 * ngf,
32: 2 * ngf,
64: 2 * ngf,
128: ngf,
256: ngf // 2,
512: ngf // 4,
1024: ngf // 8
}
self.init_blk = FastGANGenInitBlk(nz, dims[4])
self.blk_8 = FastGANUpBlk(dims[4], dims[8])
self.blk_16 = FastGANUpBlk(dims[8], dims[16])
self.blk_32 = FastGANUpBlk(dims[16], dims[32])
self.blk_64 = FastGANUpBlk(dims[32], dims[64])
self.blk_128 = FastGANUpBlk(dims[64], dims[128])
self.blk_256 = FastGANUpBlk(dims[128], dims[256])
self.blk_512 = FastGANUpBlk(dims[256], dims[512])
self.blk_1024 = FastGANUpBlk(dims[512], dims[1024])
self.se_128_8 = FastGANSEBlk(dims[128], dims[8], use_swish)
self.se_256_16 = FastGANSEBlk(dims[256], dims[16], use_swish)
self.se_512_32 = FastGANSEBlk(dims[512], dims[32], use_swish)
self.last_conv1 = SpectralNorm(
nn.Conv2d(dims[128], oc, 1, 1, 0, bias=False))
self.last_conv2 = SpectralNorm(
nn.Conv2d(dims[sz], oc, 3, 1, 1, bias=False))
def __init__(self,
num_classes=10,
non_negative=[True, True, True, True],
norm=[False, False, False, False]):
super(MNIST_Small_ConvNet, self).__init__()
self.conv1 = RobustConv2d(1,
16,
4,
2,
padding=1,
non_negative=non_negative[0])
if norm[0]:
self.conv1 = SpectralNorm(self.conv1)
self.conv2 = RobustConv2d(16,
32,
4,
1,
padding=1,
non_negative=non_negative[1])
if norm[1]:
self.conv2 = SpectralNorm(self.conv2)
self.fc1 = RobustLinear(13 * 13 * 32,
100,
non_negative=non_negative[2])
if norm[2]:
self.fc1 = SpectralNorm(self.fc1)
self.fc2 = RobustLinear(100, 10, non_negative=non_negative[3])
if norm[3]:
self.fc2 = SpectralNorm(self.fc2)
self.activation = F.relu
self.score_function = self.fc2
def __init__(self, ic, oc, norm_type='instancenorm'):
super(ResBlock, self).__init__()
self.ic = ic
self.oc = oc
self.norm_type = norm_type
self.relu = nn.ReLU(inplace=True)
self.reflection_pad1 = nn.ReflectionPad2d(1)
self.reflection_pad2 = nn.ReflectionPad2d(1)
self.conv1 = nn.Conv2d(ic, oc, 3, 1, 0, bias=False)
self.conv2 = nn.Conv2d(oc, oc, 3, 1, 0, bias=False)
if (self.norm_type == 'spectralnorm'):
self.conv1 = SpectralNorm(self.conv1)
self.conv2 = SpectralNorm(self.conv2)
self.bn1 = Nothing()
self.bn2 = Nothing()
else:
if (self.norm_type == 'batchnorm'):
self.bn1 = nn.BatchNorm2d(oc)
self.bn2 = nn.BatchNorm2d(oc)
elif (self.norm_type == 'instancenorm'):
self.bn1 = nn.InstanceNorm2d(oc)
self.bn2 = nn.InstanceNorm2d(oc)
def __init__(self, nf, total_residual_blocks):
super(ResidualBlockSpectralNorm, self).__init__()
self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
self.conv1 = SpectralNorm(nn.Conv2d(nf, nf, 3, 1, 1, bias=True))
self.conv2 = SpectralNorm(nn.Conv2d(nf, nf, 3, 1, 1, bias=True))
initialize_weights([self.conv1, self.conv2], 1)
def __init__(self,
inc,
outc=None,
kernel=3,
stride=1,
activ='lrelu',
norm='bn',
sn=False):
super(ResidualBlock, self).__init__()
if outc is None:
outc = inc // stride
self.activ = get_activ(activ)
pad = kernel // 2
if sn:
self.input = SpectralNorm(nn.Conv2d(inc, outc, 1, 1, padding=0))
self.blocks = nn.Sequential(
SpectralNorm(nn.Conv2d(inc, outc, kernel, 1, pad)),
get_norm(norm, outc), nn.LeakyReLU(0.2),
SpectralNorm(nn.Conv2d(outc, outc, kernel, 1, pad)),
get_norm(norm, outc))
else:
self.input = nn.Conv2d(inc, outc, 1, 1, padding=0)
self.blocks = nn.Sequential(
nn.Conv2d(inc, outc, kernel, 1, kernel), get_norm(norm, outc),
nn.LeakyReLU(0.2), nn.Conv2d(outc, outc, kernel, 1, kernel),
get_norm(norm, outc))
def __init__(self, channels, leak=0.2):
super(Discriminator, self).__init__()
self.leak = leak
self.conv1 = SpectralNorm(
nn.Conv2d(channels, 64, 3, stride=1, padding=(1, 1)))
self.conv2 = SpectralNorm(
nn.Conv2d(64, 64, 4, stride=2, padding=(1, 1))) # x/2
self.conv3 = SpectralNorm(
nn.Conv2d(64, 128, 3, stride=1, padding=(1, 1)))
self.conv4 = SpectralNorm(
nn.Conv2d(128, 128, 4, stride=2, padding=(1, 1))) # x/2
self.conv5 = SpectralNorm(
nn.Conv2d(128, 256, 3, stride=1, padding=(1, 1)))
self.conv6 = SpectralNorm(
nn.Conv2d(256, 256, 4, stride=2, padding=(1, 1))) # x/2
self.conv7 = SpectralNorm(
nn.Conv2d(256, 512, 3, stride=1, padding=(1, 1)))
self.conv8 = SpectralNorm(
nn.Conv2d(512, 512, 4, stride=2, padding=(1, 1))) # x/2
self.conv9 = SpectralNorm(
nn.Conv2d(512, 1024, 3, stride=1, padding=(1, 1))) # x
self.fc = SpectralNorm(nn.Linear(4 * 4 * 1024, 1)) # dens
def __init__(self, ic, oc, upsample=True, use_sn=False):
super(Generative_ResBlock, self).__init__()
self.conv1 = nn.Conv2d(ic, oc, 3, 1, 1)
self.conv2 = nn.Conv2d(oc, oc, 3, 1, 1)
self.conv3 = nn.Conv2d(ic, oc, 1, 1, 0)
if (use_sn == False):
model_list = [
nn.BatchNorm2d(ic),
nn.ReLU(inplace=True), self.conv1
]
elif (use_sn == True):
model_list = [
nn.BatchNorm2d(ic),
nn.ReLU(inplace=True),
SpectralNorm(self.conv1)
]
if (upsample == True):
model_list.append(UpSample())
model_list.extend([
nn.BatchNorm2d(oc),
nn.ReLU(inplace=True),
])
if (use_sn == False):
model_list.append(self.conv2)
elif (use_sn == True):
model_list.append(SpectralNorm(self.conv2))
self.model = nn.Sequential(*model_list)
bypass_list = [self.conv3]
if (upsample == True):
bypass_list.append(UpSample())
self.bypass = nn.Sequential(*bypass_list)
def build_conv_block(self, dim, padding_type, activation, use_dropout):
conv_block = []
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReflectionPad2d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad2d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' %
padding_type)
conv_block += [
SpectralNorm(nn.Conv2d(dim, dim, kernel_size=3, padding=p)),
activation
]
if use_dropout:
conv_block += [nn.Dropout(0.5)]
p = 0
if padding_type == 'reflect':
conv_block += [nn.ReflectionPad2d(1)]
elif padding_type == 'replicate':
conv_block += [nn.ReplicationPad2d(1)]
elif padding_type == 'zero':
p = 1
else:
raise NotImplementedError('padding [%s] is not implemented' %
padding_type)
conv_block += [
SpectralNorm(nn.Conv2d(dim, dim, kernel_size=3, padding=p))
]
return nn.Sequential(*conv_block)
def convU(in_channels,
out_channels,
conv_layer,
norm_layer,
kernel_size=3,
stride=1,
dilation=1,
bias=True):
return nn.Sequential(
SpectralNorm(
conv_layer(in_channels,
out_channels,
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
padding=((kernel_size - 1) // 2) * dilation,
bias=bias)),
# conv_layer(in_channels, out_channels, kernel_size=kernel_size, stride=stride, dilation=dilation, padding=((kernel_size-1)//2)*dilation, bias=bias),
# nn.BatchNorm2d(out_channels),
nn.LeakyReLU(0.2),
SpectralNorm(
conv_layer(out_channels,
out_channels,
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
padding=((kernel_size - 1) // 2) * dilation,
bias=bias)),
)
def __init__(self,
in_channels,
out_channels,
hidden_channels=None,
upsample=False,
n_classes=0,
leak=0):
super(ResBlockGenerator, self).__init__()
hidden_channels = out_channels if hidden_channels is None else hidden_channels
self.upsample = upsample
self.learnable_sc = (in_channels != out_channels) or upsample
self.conv1 = SpectralNorm(conv3x3(in_channels,
hidden_channels)).apply(init_weight)
self.conv2 = SpectralNorm(conv3x3(hidden_channels,
out_channels)).apply(init_weight)
self.conv3 = SpectralNorm(conv1x1(in_channels,
out_channels)).apply(init_weight)
self.upsampling = nn.Upsample(scale_factor=2)
self.n_cl = n_classes
if n_classes == 0:
self.bn1 = nn.BatchNorm2d(in_channels)
self.bn2 = nn.BatchNorm2d(hidden_channels)
else:
self.bn1 = ConditionalNorm(in_channels, n_classes)
self.bn2 = ConditionalNorm(hidden_channels, n_classes)
if leak > 0:
self.activation = nn.LeakyReLU(leak)
else:
self.activation = nn.ReLU()
def __init__(self, in_channels, out_channels, stride=1):
super(ResBlockDiscriminator, self).__init__()
self.conv1 = nn.Conv2d(in_channels, out_channels, 3, 1, padding=1)
self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, padding=1)
nn.init.xavier_uniform_(self.conv1.weight.data, 1.)
nn.init.xavier_uniform_(self.conv2.weight.data, 1.)
if stride == 1:
self.model = nn.Sequential(nn.ReLU(), SpectralNorm(self.conv1),
nn.ReLU(), SpectralNorm(self.conv2))
else:
self.model = nn.Sequential(
nn.ReLU(), SpectralNorm(self.conv1), nn.ReLU(),
SpectralNorm(self.conv2),
nn.AvgPool2d(2, stride=stride, padding=0))
self.bypass = nn.Sequential()
if stride != 1:
self.bypass_conv = nn.Conv2d(in_channels,
out_channels,
1,
1,
padding=0)
nn.init.xavier_uniform_(self.bypass_conv.weight.data, np.sqrt(2))
self.bypass = nn.Sequential(
SpectralNorm(self.bypass_conv),
nn.AvgPool2d(2, stride=stride, padding=0))
def __init__(self, z_dim=128, channels=3, ch=32, n_classes=0, leak=0):
super(Generator32, self).__init__()
self.ch = ch
self.dense = SpectralNorm(nn.Linear(z_dim,
4 * 4 * 8 * ch)).apply(init_weight)
self.final = SpectralNorm(conv3x3(ch, channels)).apply(init_weight)
self.block1 = ResBlockGenerator(8 * ch,
4 * ch,
upsample=True,
n_classes=n_classes,
leak=leak)
self.block2 = ResBlockGenerator(4 * ch,
2 * ch,
upsample=True,
n_classes=n_classes,
leak=leak)
self.block3 = ResBlockGenerator(2 * ch,
ch,
upsample=True,
n_classes=n_classes,
leak=leak)
self.bn = nn.BatchNorm2d(ch)
if leak > 0:
self.activation = nn.LeakyReLU(leak)
else:
self.activation = nn.ReLU()
def __init__(self, ic = 1, oc = 1, norm_type = 'instancenorm', use_sn = False): super(ResBlock, self).__init__() self.ic = ic self.oc = oc self.norm_type = norm_type self.use_sn = use_sn self.relu = nn.ReLU(inplace = True) self.reflection_pad1 = nn.ReflectionPad1d(15) self.reflection_pad2 = nn.ReflectionPad1d(15) self.conv1 = nn.Conv1d(ic, oc, 31, 1, 0, bias = False) self.conv2 = nn.Conv1d(oc, oc, 31, 1, 0, bias = False) if(self.use_sn == True): self.conv1 = SpectralNorm(self.conv1) self.conv2 = SpectralNorm(self.conv2) if(self.norm_type == 'batchnorm'): self.bn1 = nn.BatchNorm1d(oc) self.bn2 = nn.BatchNorm1d(oc) elif(self.norm_type == 'instancenorm'): self.bn1 = nn.InstanceNorm1d(oc) self.bn2 = nn.InstanceNorm1d(oc)
def conv_block(in_channels,
out_channels,
kernel_size=3,
stride=1,
dilation=1,
bias=True):
"""Conv block used in MSDilationBlock."""
return nn.Sequential(
SpectralNorm(
nn.Conv2d(in_channels,
out_channels,
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
padding=((kernel_size - 1) // 2) * dilation,
bias=bias)),
nn.LeakyReLU(0.2),
SpectralNorm(
nn.Conv2d(out_channels,
out_channels,
kernel_size=kernel_size,
stride=stride,
dilation=dilation,
padding=((kernel_size - 1) // 2) * dilation,
bias=bias)),
)
def __init__(self, big_c, small_c, use_swish):
super(FastGANSEBlk, self).__init__()
self.branch = nn.Sequential(
nn.AdaptiveAvgPool2d(4),
SpectralNorm(nn.Conv2d(small_c, big_c, 4, 1, 0, bias=False)),
nn.SiLU() if use_swish else nn.LeakyReLU(0.1),
SpectralNorm(nn.Conv2d(big_c, big_c, 1, 1, 0, bias=False)),
nn.Sigmoid())
def __init__(self, ic, oc):
super(FirstDiscBlk, self).__init__()
self.model = nn.Sequential(SpectralNorm(nn.Conv2d(ic, oc, 3, 1, 1)),
nn.ReLU(),
SpectralNorm(nn.Conv2d(oc, oc, 3, 1, 1)),
nn.AvgPool2d(2))
self.shortcut = nn.Sequential(nn.AvgPool2d(2),
SpectralNorm(nn.Conv2d(ic, oc, 1, 1, 0)))
def __init__(self, sz):
super(SNDCGANDiscriminator, self).__init__()
final_sz = sz // 8
self.conv1 = nn.Sequential(SpectralNorm(nn.Conv2d(3, 64, 3, 1, 1)),
nn.LeakyReLU(0.1))
self.conv2 = nn.Sequential(SpectralNorm(nn.Conv2d(64, 128, 4, 2, 1)),
nn.LeakyReLU(0.1))
self.conv3 = nn.Sequential(SpectralNorm(nn.Conv2d(128, 128, 3, 1, 1)),
nn.LeakyReLU(0.1))
self.conv4 = nn.Sequential(SpectralNorm(nn.Conv2d(128, 256, 4, 2, 1)),
nn.LeakyReLU(0.1))
self.conv5 = nn.Sequential(SpectralNorm(nn.Conv2d(256, 256, 3, 1, 1)),
nn.LeakyReLU(0.1))
self.conv6 = nn.Sequential(SpectralNorm(nn.Conv2d(256, 512, 4, 2, 1)),
nn.LeakyReLU(0.1))
self.conv7 = nn.Sequential(SpectralNorm(nn.Conv2d(512, 512, 3, 1, 1)),
nn.LeakyReLU(0.1))
self.fc = nn.Sequential(
Reshape(-1, 512 * final_sz * final_sz),
SpectralNorm(nn.Linear(512 * final_sz * final_sz, 1)))
for m in self.modules():
if (isinstance(m, (nn.Linear, nn.Conv2d, nn.ConvTranspose2d))):
m.weight.data.normal_(0.0, 0.02)
if (m.bias is not None):
m.bias.data.zero_()
def __init__(self, sz, nc, ndf = 64, use_sigmoid = True, use_bn = True, norm_type = 'batchnorm', activation_type = 'leakyrelu'): super(DCGAN_D, self).__init__() assert sz > 4, "Image size should be bigger than 4" assert sz & (sz-1) == 0, "Image size should be a power of 2" self.sz = sz self.nc = nc self.ndf = ndf self.use_bn = use_bn self.norm_type = norm_type cur_ndf = ndf layers = [ConvBlock(self.nc, self.ndf, 4, 2, use_bn = False, activation_type = activation_type)] for i in range(int(math.log2(self.sz)) - 3): layers.append(ConvBlock(cur_ndf, cur_ndf * 2, 4, 2, use_bn = self.use_bn, norm_type = norm_type, activation_type = activation_type)) cur_ndf *= 2 if(self.norm_type == 'spectralnorm'): layers.append(SpectralNorm(nn.Conv2d(cur_ndf, 1, 4, 1, 0, bias = False))) else: layers.append(nn.Conv2d(cur_ndf, 1, 4, 1, 0, bias = False)) self.main = nn.Sequential(*layers) self.sigmoid = nn.Sigmoid() self.use_sigmoid = use_sigmoid for m in self.modules(): if(isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d)): m.weight.data.normal_(0.0, 0.02) if(m.bias is not None): m.bias.data.zero_()
def __init__(self, ni, no, ks, stride, pad = None, use_bn = True, use_pixelshuffle = False, norm_type = 'batchnorm', activation_type = 'leakyrelu'): super(ConvBlock, self).__init__() self.use_bn = use_bn self.use_pixelshuffle = use_pixelshuffle self.norm_type = norm_type if(pad == None): pad = ks // 2 // stride if(use_pixelshuffle): self.conv = nn.Conv2d(ni // 4, no, ks, stride, pad, bias = False) self.pixelshuffle = nn.PixelShuffle(2) else: self.conv = nn.Conv2d(ni, no, ks, stride, pad, bias = False) if(self.use_bn == True): if(self.norm_type == 'batchnorm'): self.bn = nn.BatchNorm2d(no) elif(self.norm_type == 'instancenorm'): self.bn = nn.InstanceNorm2d(no) elif(self.norm_type == 'spectralnorm'): self.conv = SpectralNorm(self.conv) if(activation_type == 'relu'): self.act = nn.ReLU(inplace = True) elif(activation_type == 'leakyrelu'): self.act = nn.LeakyReLU(0.2, inplace = True) elif(activation_type == 'elu'): self.act = nn.ELU(inplace = True) elif(activation_type == 'selu'): self.act = nn.SELU(inplace = True)
def __init__(self, sz, nz, nc, ngf = 64, use_bn = True, norm_type = 'batchnorm', activation_type = 'leakyrelu'): super(DCGAN_G_PixelShuffle, self).__init__() self.sz = sz self.nz = nz self.nc = nc self.ngf = ngf self.norm_type = norm_type cur_ngf = ngf * self.sz // 8 layers = [ConvBlock(self.nz, cur_ngf, 4, 1, 3, use_bn = use_bn, use_pixelshuffle = False, norm_type = norm_type, activation_type = activation_type)] for i in range(int(math.log2(self.sz)) - 3): layers.append(ConvBlock(cur_ngf, cur_ngf // 2, 3, 1, 1, use_bn = use_bn, use_pixelshuffle = True, norm_type = norm_type, activation_type = activation_type)) cur_ngf = cur_ngf // 2 if(self.norm_type == 'spectralnorm'): layers.extend([nn.PixelShuffle(2), SpectralNorm(nn.Conv2d(self.ngf // 4, self.nc, 3, 1, 1, bias = False)), nn.Tanh()]) else: layers.extend([nn.PixelShuffle(2), nn.Conv2d(self.ngf // 4, self.nc, 3, 1, 1, bias = False), nn.Tanh()]) self.main = nn.Sequential(*layers) for m in self.modules(): if(isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d)): m.weight.data.normal_(0.0, 0.02) if(m.bias is not None): m.bias.data.zero_()
def __init__(self, channels=3, ch=32, n_classes=0, leak=0, att=False):
super(Discriminator64, self).__init__()
if leak > 0:
self.activation = nn.LeakyReLU(leak)
else:
self.activation = nn.ReLU()
self.ch = ch
self.att = att
self.block1 = OptimizedBlock(channels, ch, leak=leak)
if att:
self.attention = Attention(ch)
self.block2 = ResBlockDiscriminator(ch,
ch * 2,
downsample=True,
leak=leak)
self.block3 = ResBlockDiscriminator(ch * 2,
ch * 4,
downsample=True,
leak=leak)
self.block4 = ResBlockDiscriminator(ch * 4,
ch * 8,
downsample=True,
leak=leak)
self.block5 = ResBlockDiscriminator(ch * 8, ch * 16, leak=leak)
self.fc = SpectralNorm(nn.Linear(self.ch * 16, 1)).apply(init_weight)
if n_classes > 0:
self.embed_y = nn.Embedding(n_classes, ch * 16).apply(init_weight)
def __init__(self, in_channels,conv_layer=nn.Conv2d, norm_layer=nn.BatchNorm2d, kernel_size=3, dilation=[1,1,1,1], bias=True):
super(MSDilateBlock, self).__init__()
self.conv1 = convU(in_channels, in_channels,conv_layer, norm_layer, kernel_size,dilation=dilation[0], bias=bias)
self.conv2 = convU(in_channels, in_channels,conv_layer, norm_layer, kernel_size,dilation=dilation[1], bias=bias)
self.conv3 = convU(in_channels, in_channels,conv_layer, norm_layer, kernel_size,dilation=dilation[2], bias=bias)
self.conv4 = convU(in_channels, in_channels,conv_layer, norm_layer, kernel_size,dilation=dilation[3], bias=bias)
self.convi = SpectralNorm(conv_layer(in_channels*4, in_channels, kernel_size=kernel_size, stride=1, padding=(kernel_size-1)//2, bias=bias))
def __init__(self, ni, no, ks, stride, pad = None, pad_type = 'Zero', output_pad = 0, use_bn = True, use_sn = False, norm_type = 'batchnorm', activation_type = 'leakyrelu'): super(DeConvBlock, self).__init__() self.use_bn = use_bn self.use_sn = use_sn self.norm_type = norm_type self.pad_type = pad_type if(pad is None): pad = ks // 2 // stride if(self.pad_type == 'Zero'): self.deconv = nn.ConvTranspose1d(ni, no, ks, stride, pad, output_padding = output_pad, bias = False) elif(self.pad_type == 'Reflection'): self.deconv = nn.ConvTranspose1d(ni, no, ks, stride, 0, output_padding = output_pad, bias = False) self.reflection = nn.ReflectionPad1d(pad) if(self.use_bn == True): if(self.norm_type == 'batchnorm'): self.bn = nn.BatchNorm1d(no) elif(self.norm_type == 'instancenorm'): self.bn = nn.InstanceNorm1d(no) if(self.use_sn == True): self.deconv = SpectralNorm(self.deconv) if(activation_type == 'relu'): self.act = nn.ReLU(inplace = True) elif(activation_type == 'leakyrelu'): self.act = nn.LeakyReLU(0.2, inplace = True) elif(activation_type == 'elu'): self.act = nn.ELU(inplace = True) elif(activation_type == 'selu'): self.act = nn.SELU(inplace = True) elif(activation_type == None): self.act = Nothing()
def __init__(self, ic, hc, oc, downsample):
super(DiscBlk, self).__init__()
if downsample:
self.avgpool = nn.AvgPool2d(2)
else:
self.avgpool = nn.Identity()
self.model = nn.Sequential(nn.ReLU(),
SpectralNorm(nn.Conv2d(ic, hc, 3, 1, 1)),
nn.ReLU(),
SpectralNorm(nn.Conv2d(hc, oc, 3, 1, 1)))
if ic != oc or downsample:
self.shortcut = nn.Sequential(
SpectralNorm(nn.Conv2d(ic, oc, 1, 1, 0)), nn.AvgPool2d(2))
else:
self.shortcut = nn.Identity()
def __init__(self, ic, hc, oc, sz):
super(FastGANDiscInitBlk, self).__init__()
if sz == 256:
self.model = nn.Sequential(
SpectralNorm(nn.Conv2d(ic, oc, 3, 1, 1, bias=False)),
nn.LeakyReLU(0.2))
if sz == 512:
self.model = nn.Sequential(
SpectralNorm(nn.Conv2d(ic, oc, 4, 2, 1, bias=False)),
nn.LeakyReLU(0.2),
)
if sz == 1024:
self.model = nn.Sequential(
SpectralNorm(nn.Conv2d(ic, hc, 4, 2, 1, bias=False)),
nn.LeakyReLU(0.2),
SpectralNorm(nn.Conv2d(hc, oc, 4, 2, 1, bias=False)),
nn.BatchNorm2d(oc), nn.LeakyReLU(0.2))
def __init__(self, num_out):
super().__init__(
nn.Sequential(
SpectralNorm(nn.Conv2d(3, num_out, 4, 2, 1, bias=False)),
nn.LeakyReLU(0.2, inplace=True),
SpectralLeakyConv(num_out, num_out * 2, 4, 2, 1),
SpectralLeakyConv(num_out * 2, num_out * 4, 4, 2, 1),
SpectralLeakyConv(num_out * 4, num_out * 8, 4, 2, 1)))
def conv3x3(in_planes, out_planes):
"3x3 convolution with padding"
return SpectralNorm(
nn.Conv2d(in_planes,
out_planes,
kernel_size=3,
stride=1,
padding=1,
bias=False))
def __init__(self, ic, ndf):
super(SNGANDiscriminator32, self).__init__()
self.ndf = ndf
self.model = nn.Sequential(FirstDiscBlk(ic, ndf),
DiscBlk(ndf, ndf, ndf, True),
DiscBlk(ndf, ndf, ndf, False),
DiscBlk(ndf, ndf, ndf, False), nn.ReLU(),
nn.AdaptiveAvgPool2d(1))
self.classifier = SpectralNorm(nn.Linear(ndf, 1, bias=False))
def __init__(self):
super(AdaINDiscriminator64, self).__init__()
self.blk1 = ConvBlock(3, 32)
self.blk2 = ConvBlock(32, 64)
self.blk3 = ConvBlock(64, 128)
self.blk4 = ConvBlock(128, 256)
self.blk5 = ConvBlock(256, 512)
self.fc = SpectralNorm(nn.Linear(512, 1))
nn.init.xavier_uniform_(self.fc.weight.data, 1.0)
def conv_block(n_in, n_out, ks, stride, pad=None, bn=True):
if pad is None:
pad = ks//2//stride
if bn == True:
res = nn.Sequential(
SpectralNorm(nn.Conv2d(n_in, n_out, kernel_size=ks, bias=False, stride=stride, padding=pad)),
nn.BatchNorm2d(n_out),
nn.LeakyReLU(negative_slope=0.2, inplace=True)
)
