def __init__(self, in_feat, out_feat):
super(Conv3x3Drop, self).__init__()
self.conv1 = nn.Sequential(spectral_norm(nn.Conv2d(in_feat, out_feat,
kernel_size=3,
stride=1,
padding=1)),
nn.ReLU())
self.conv2 = nn.Sequential(spectral_norm(nn.Conv2d(out_feat, out_feat,
kernel_size=3,
stride=1,
padding=1)),
nn.ReLU())
def __init__(self, input_nc, ndf=64, n_layers=3, norm_layer=nn.BatchNorm2d, use_sigmoid=False):
super(NLayerDiscriminator, self).__init__()
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
attention = False
kw = 4
padw = 1
sequence = [
spectral_norm(nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw)),
nn.LeakyReLU(0.2, True)
]
nf_mult = 1
nf_mult_prev = 1
for n in range(1, n_layers):
nf_mult_prev = nf_mult
nf_mult = min(2**n, 8)
sequence += [
# nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult,
# kernel_size=kw, stride=2, padding=padw, bias=use_bias),
spectral_norm(nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult,
kernel_size=kw, stride=2, padding=padw, bias=use_bias)),
nn.LeakyReLU(0.2, True)
]
if attention:
sequence += Self_Attn(ndf * nf_mult, 'relu')
nf_mult_prev = nf_mult
nf_mult = min(2**n_layers, 8)
sequence += [
# nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult,
# kernel_size=kw, stride=1, padding=padw, bias=use_bias),
spectral_norm(nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult,
kernel_size=kw, stride=1, padding=padw, bias=use_bias)),
nn.LeakyReLU(0.2, True)
]
if attention:
sequence += Self_Attn(ndf * nf_mult, 'relu')
sequence += [spectral_norm(nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw))]
if use_sigmoid:
sequence += [nn.Sigmoid()]
self.model = nn.Sequential(*sequence)
def __init__(self, in_feat, out_feat):
super(UpSample, self).__init__()
self.up = nn.Upsample(scale_factor=2, mode='nearest')
self.deconv = spectral_norm(nn.ConvTranspose2d(in_feat,
out_feat,
kernel_size=2,
stride=2))
def __init__(self, num_channels=1, num_classes=1):
super(KUnetGenerator, self).__init__()
num_feat = [64, 128, 256, 512, 1024]
self.down1 = nn.Sequential(Conv3x3(num_channels, num_feat[0]))
self.down2 = nn.Sequential(nn.MaxPool2d(kernel_size=2),
Conv3x3(num_feat[0], num_feat[1]))
self.down3 = nn.Sequential(nn.MaxPool2d(kernel_size=2),
Conv3x3(num_feat[1], num_feat[2]))
self.down4 = nn.Sequential(nn.MaxPool2d(kernel_size=2),
Conv3x3(num_feat[2], num_feat[3]))
# self.bottom = nn.Sequential(nn.MaxPool2d(kernel_size=2),
# Conv3x3(num_feat[3], num_feat[4]))
self.bottom = nn.Sequential(spectral_norm(nn.Conv2d(num_feat[3], num_feat[3],
kernel_size=3,
stride=1,
padding=1)),
nn.ReLU())
self.up1 = UpConcat(num_feat[3], num_feat[3])
# self.upconv1 = Conv3x3(num_feat[4], num_feat[3])
self.upconv1 = nn.Sequential(spectral_norm(nn.Conv2d(num_feat[3], num_feat[3],
kernel_size=3,
stride=1,
padding=1)),
nn.ReLU())
self.up2 = UpConcat(num_feat[3], num_feat[2])
self.upconv2 = Conv3x3(num_feat[3], num_feat[2])
self.up3 = UpConcat(num_feat[2], num_feat[1])
self.upconv3 = Conv3x3(num_feat[2], num_feat[1])
self.up4 = UpConcat(num_feat[1], num_feat[0])
self.upconv4 = Conv3x3(num_feat[1], num_feat[0])
self.final = nn.Sequential(spectral_norm(nn.Conv2d(num_feat[0],
num_classes,
kernel_size=1)),
nn.Tanh())
def __init__(self, input_nc, ndf=64, norm_layer=nn.BatchNorm2d, use_sigmoid=False):
super(PixelDiscriminator, self).__init__()
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
self.net = [
spectral_norm(nn.Conv2d(input_nc, ndf, kernel_size=1, stride=1, padding=0)),
nn.LeakyReLU(0.2, True),
spectral_norm(nn.Conv2d(ndf, ndf * 2, kernel_size=1, stride=1, padding=0, bias=use_bias)),
# spectral_norm(nn.Conv2d(ndf, ndf * 2, kernel_size=1, stride=1, padding=0, bias=use_bias)),
norm_layer(ndf * 2),
nn.LeakyReLU(0.2, True),
spectral_norm(nn.Conv2d(ndf * 2, 1, kernel_size=1, stride=1, padding=0, bias=use_bias))]
if use_sigmoid:
self.net.append(nn.Sigmoid())
self.net = nn.Sequential(*self.net)
def build_conv_block(self, dim, padding_type, norm_layer, use_dropout, use_bias, spec_norm):
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)
if spec_norm:
conv_block += [spectral_norm(nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias)),
norm_layer(dim),
nn.ReLU(True)]
else:
conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias),
norm_layer(dim),
nn.ReLU(True)]
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)
if spec_norm:
conv_block += [spectral_norm(nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias)),
norm_layer(dim)]
else:
conv_block += [nn.Conv2d(dim, dim, kernel_size=3, padding=p, bias=use_bias),
norm_layer(dim)]
return nn.Sequential(*conv_block)
def __init__(self, input_channels=64, hidden_channels=[32],
kernel_size=5, bias=True, num_classes=1):
super(BDCLSTM, self).__init__()
self.forward_net = CLSTM(
input_channels, hidden_channels, kernel_size, bias)
self.reverse_net = CLSTM(
input_channels, hidden_channels, kernel_size, bias)
self.pad = nn.ReflectionPad2d(3)
self.conv = spectral_norm(nn.Conv2d(
2 * hidden_channels[-1], num_classes, kernel_size=7))
# self.soft = nn.Softmax2d()
self.soft = nn.Tanh()
def __init__(self, in_feat, out_feat):
super(UpConcat, self).__init__()
self.up = nn.UpsamplingBilinear2d(scale_factor=2)
# self.deconv = nn.ConvTranspose2d(in_feat, out_feat,
# kernel_size=3,
# stride=1,
# dilation=1)
self.deconv = spectral_norm(nn.ConvTranspose2d(in_feat,
out_feat,
kernel_size=2,
stride=2))
def conv_trans_block(in_dim,out_dim,act_fn,spec_norm=True):
if spec_norm:
model = nn.Sequential(
spectral_norm(nn.ConvTranspose2d(in_dim,out_dim, kernel_size=3, stride=2, padding=1,output_padding=1)),
# nn.BatchNorm2d(out_dim),
act_fn,
)
else:
model = nn.Sequential(
nn.ConvTranspose2d(in_dim, out_dim, kernel_size=3, stride=2, padding=1, output_padding=1),
nn.BatchNorm2d(out_dim),
act_fn,
)
return model
def conv_block_3(in_dim,out_dim,act_fn,spec_norm=True):
if spec_norm:
model = nn.Sequential(
conv_block(in_dim,out_dim,act_fn,spec_norm),
conv_block(out_dim,out_dim,act_fn,spec_norm),
spectral_norm(nn.Conv2d(out_dim,out_dim, kernel_size=3, stride=1, padding=1)),
# nn.BatchNorm2d(out_dim),
)
else:
model = nn.Sequential(
conv_block(in_dim, out_dim, act_fn, spec_norm=False),
conv_block(out_dim, out_dim, act_fn, spec_norm=False),
nn.Conv2d(out_dim, out_dim, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(out_dim),
)
return model
def __init__(self, input_nc, output_nc, ngf=64, num_downs=4, spec_norm=True):
super(FusionGenerator, self).__init__()
self.in_dim = input_nc
self.out_dim = ngf
self.final_out_dim = output_nc
act_fn = nn.LeakyReLU(0.2, inplace=True)
act_fn_2 = nn.ReLU()
print("\n------Initiating FusionNet------\n")
print "%d fusion blocks, %d filters \n" %(num_downs, self.out_dim * (2 ** num_downs))
# encoder
self.down_1 = Conv_residual_conv(self.in_dim, self.out_dim, act_fn, spec_norm)
self.pool_1 = maxpool()
self.down_2 = Conv_residual_conv(self.out_dim, self.out_dim * 2, act_fn, spec_norm)
self.pool_2 = maxpool()
self.down_3 = Conv_residual_conv(self.out_dim * 2, self.out_dim * 4, act_fn, spec_norm)
self.pool_3 = maxpool()
self.down_4 = Conv_residual_conv(self.out_dim * 4, self.out_dim * 8, act_fn, spec_norm)
self.pool_4 = maxpool()
# bridge
self.bridge = Conv_residual_conv(self.out_dim * 8, self.out_dim * 16, act_fn, spec_norm)
# decoder
self.deconv_1 = conv_trans_block(self.out_dim * 16, self.out_dim * 8, act_fn_2, spec_norm)
self.up_1 = Conv_residual_conv(self.out_dim * 8, self.out_dim * 8, act_fn_2, spec_norm)
self.deconv_2 = conv_trans_block(self.out_dim * 8, self.out_dim * 4, act_fn_2, spec_norm)
self.up_2 = Conv_residual_conv(self.out_dim * 4, self.out_dim * 4, act_fn_2, spec_norm)
self.deconv_3 = conv_trans_block(self.out_dim * 4, self.out_dim * 2, act_fn_2, spec_norm)
self.up_3 = Conv_residual_conv(self.out_dim * 2, self.out_dim * 2, act_fn_2, spec_norm)
self.deconv_4 = conv_trans_block(self.out_dim * 2, self.out_dim, act_fn_2, spec_norm)
self.up_4 = Conv_residual_conv(self.out_dim, self.out_dim, act_fn_2, spec_norm)
# output
if spec_norm:
self.out = spectral_norm(nn.Conv2d(self.out_dim, self.final_out_dim, kernel_size=3, stride=1, padding=1))
else:
self.out = nn.Conv2d(self.out_dim, self.final_out_dim, kernel_size=3, stride=1, padding=1)
self.out_2 = nn.Tanh()
def __init__(self, input_channels, hidden_channels,
kernel_size, bias=True):
super(CLSTMCell, self).__init__()
assert hidden_channels % 2 == 0
self.input_channels = input_channels
self.hidden_channels = hidden_channels
self.bias = bias
self.kernel_size = kernel_size
self.num_features = 4
self.padding = (kernel_size - 1) // 2
self.conv = nn.Sequential(spectral_norm(nn.Conv2d(self.input_channels + self.hidden_channels,
self.num_features * self.hidden_channels,
self.kernel_size,
1,
self.padding)),
nn.Dropout(0.1))
def __init__(self, outer_nc, inner_nc, input_nc=None,
submodule=None, outermost=False, innermost=False, norm_layer=nn.BatchNorm2d, use_dropout=False, spec_norm=True, return_feature=False):
super(UnetSkipConnectionBlock, self).__init__()
self.outermost = outermost
self.return_feature = return_feature
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
if input_nc is None:
input_nc = outer_nc
# check if GAN or simple U-Net
if spec_norm == False:
print('spectral norm disabled')
downconv = nn.Conv2d(input_nc, inner_nc, kernel_size=4,
stride=2, padding=1, bias=use_bias)
downrelu = nn.LeakyReLU(0.2, True)
downnorm = norm_layer(inner_nc)
uprelu = nn.ReLU(True)
upnorm = norm_layer(outer_nc)
if outermost:
upconv = nn.ConvTranspose2d(inner_nc * 2, inner_nc,
kernel_size=4, stride=2,
padding=1)
conv = nn.Conv2d(inner_nc, outer_nc, kernel_size=1)
down = [downconv]
up = [uprelu, upconv, conv, nn.Tanh()]
model = down + [submodule] + up
elif innermost:
upconv = nn.ConvTranspose2d(inner_nc, outer_nc,
kernel_size=4, stride=2,
padding=1, bias=use_bias)
down = [downrelu, downconv]
up = [uprelu, upconv, upnorm]
model = down + up
else:
upconv = nn.ConvTranspose2d(inner_nc * 2, outer_nc,
kernel_size=4, stride=2,
padding=1, bias=use_bias)
down = [downrelu, downconv, downnorm]
up = [uprelu, upconv, upnorm]
if use_dropout:
model = down + [submodule] + up + [nn.Dropout(0.5)]
else:
model = down + [submodule] + up
else:
downconv = spectral_norm(nn.Conv2d(input_nc, inner_nc, kernel_size=4,
stride=2, padding=1, bias=use_bias))
downrelu = nn.LeakyReLU(0.2, True)
downnorm = norm_layer(inner_nc)
uprelu = nn.ReLU(True)
upnorm = norm_layer(outer_nc)
if outermost:
upconv = spectral_norm(nn.ConvTranspose2d(inner_nc * 2, inner_nc,
kernel_size=4, stride=2,
padding=1))
down = [downconv]
conv = spectral_norm(nn.Conv2d(inner_nc, outer_nc, kernel_size=1))
up = [uprelu, upconv, conv, nn.Tanh()]
model = down + [submodule] + up
elif innermost:
upconv = spectral_norm(nn.ConvTranspose2d(inner_nc, outer_nc,
kernel_size=4, stride=2,
padding=1, bias=use_bias))
down = [downrelu, downconv]
up = [uprelu, upconv, upnorm]
model = down + up
else:
upconv = spectral_norm(nn.ConvTranspose2d(inner_nc * 2, outer_nc,
kernel_size=4, stride=2,
padding=1, bias=use_bias))
down = [downrelu, downconv, downnorm]
up = [uprelu, upconv, upnorm]
if use_dropout:
model = down + [submodule] + up + [nn.Dropout(0.5)]
else:
model = down + [submodule] + up
self.model = nn.Sequential(*model)
def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect', spec_norm=True, return_feature=False):
assert(n_blocks >= 0)
super(ResnetGenerator, self).__init__()
self.input_nc = input_nc
self.output_nc = output_nc
self.ngf = ngf
self.return_feature = return_feature
if type(norm_layer) == functools.partial:
use_bias = norm_layer.func == nn.InstanceNorm2d
else:
use_bias = norm_layer == nn.InstanceNorm2d
if spec_norm:
model = [nn.ReflectionPad2d(3),
spectral_norm(nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0,
bias=use_bias)),
norm_layer(ngf),
nn.ReLU(True)]
else:
model = [nn.ReflectionPad2d(3),
nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0,
bias=use_bias),
norm_layer(ngf),
nn.ReLU(True)]
n_downsampling = 2
for i in range(n_downsampling):
mult = 2**i
if spec_norm:
model += [spectral_norm(nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3,
stride=2, padding=1, bias=use_bias)),
norm_layer(ngf * mult * 2),
nn.ReLU(True)]
else:
model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3,
stride=2, padding=1, bias=use_bias),
norm_layer(ngf * mult * 2),
nn.ReLU(True)]
mult = 2**n_downsampling
for i in range(n_blocks):
model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias, spec_norm=spec_norm)]
for i in range(n_downsampling):
mult = 2**(n_downsampling - i)
if spec_norm:
model += [spectral_norm(nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=2,
padding=1, output_padding=1,
bias=use_bias)),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
else:
model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2),
kernel_size=3, stride=2,
padding=1, output_padding=1,
bias=use_bias),
norm_layer(int(ngf * mult / 2)),
nn.ReLU(True)]
if self.return_feature:
self.model = nn.Sequential(*model)
else:
model += [nn.ReflectionPad2d(3)]
model += [spectral_norm(nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0))]
model += [nn.Tanh()]
self.model = nn.Sequential(*model)