def __init__(self, opt):
super(RotateGenerator, self).__init__()
input_nc = 3
norm_layer = get_nonspade_norm_layer(opt, opt.norm_G)
activation = nn.ReLU(False)
# initial conv
self.first_layer = nn.Sequential(nn.ReflectionPad2d(opt.resnet_initial_kernel_size // 2),
norm_layer(nn.Conv2d(input_nc, opt.ngf,
kernel_size=opt.resnet_initial_kernel_size,
padding=0)),
activation)
# downsample
downsample_model = []
mult = 1
for i in range(opt.resnet_n_downsample):
downsample_model += [norm_layer(nn.Conv2d(opt.ngf * mult, opt.ngf * mult * 2,
kernel_size=3, stride=2, padding=1)),
activation]
mult *= 2
self.downsample_layers = nn.Sequential(*downsample_model)
# resnet blocks
resnet_model = []
for i in range(opt.resnet_n_blocks):
resnet_model += [ResnetBlock(opt.ngf * mult,
norm_layer=norm_layer,
activation=activation,
kernel_size=opt.resnet_kernel_size)]
self.resnet_layers = nn.Sequential(*resnet_model)
# upsample
upsample_model = []
for i in range(opt.resnet_n_downsample):
nc_in = int(opt.ngf * mult)
nc_out = int((opt.ngf * mult) / 2)
upsample_model += [norm_layer(nn.ConvTranspose2d(nc_in, nc_out,
kernel_size=3, stride=2,
padding=1, output_padding=1)),
activation]
mult = mult // 2
self.upsample_layers = nn.Sequential(*upsample_model)
# final output conv
self.final_layer = nn.Sequential(nn.ReflectionPad2d(3),
nn.Conv2d(nc_out, opt.output_nc, kernel_size=7, padding=0),
nn.Tanh())
def __init__(self, opt):
super().__init__()
input_nc = opt.label_nc + (1 if opt.contain_dontcare_label else 0) + (0 if opt.no_instance else 1)
norm_layer = get_nonspade_norm_layer(opt, opt.norm_G)
activation = nn.ReLU(False)
model = []
## initial conv
model += [nn.ReflectionPad2d(opt.resnet_initial_kernel_size // 2),
norm_layer(nn.Conv2d(input_nc, opt.ngf,
kernel_size=opt.resnet_initial_kernel_size,
padding=0)),
activation]
### downsample
mult = 1
for i in range(opt.resnet_n_downsample):
model += [norm_layer(nn.Conv2d(opt.ngf * mult, opt.ngf * mult * 2,
kernel_size=3, stride=2, padding=1)),
activation]
mult *= 2
### resnet blocks
for i in range(opt.resnet_n_blocks):
model += [ResnetBlock(opt.ngf * mult,
norm_layer=norm_layer,
activation=activation,
kernel_size=opt.resnet_kernel_size)]
### upsample
for i in range(opt.resnet_n_downsample):
nc_in = int(opt.ngf * mult)
nc_out = int((opt.ngf * mult) / 2)
model += [norm_layer(nn.ConvTranspose2d(nc_in, nc_out,
kernel_size=3, stride=2,
padding=1, output_padding=1)),
activation]
mult = mult // 2
# final output conv
model += [nn.ReflectionPad2d(3),
nn.Conv2d(nc_out, opt.output_nc, kernel_size=7, padding=0),
nn.Tanh()]
self.model = nn.Sequential(*model)
def __init__(self, opt):
super().__init__()
FeatGenerator.modify_commandline_options(opt)
input_nc = opt['FG_c']
keep_conv = opt['FG_keep']
norm_layer = get_nonspade_norm_layer(opt, opt['norm_FG'])
activation = nn.ReLU(True)
model = []
for i in range(keep_conv):
model += [
ResnetBlock(input_nc,
norm_layer=norm_layer,
activation=activation,
kernel_size=opt['FG_resnet_kernel_size'])
]
model += [nn.Conv2d(input_nc, input_nc, 1, 1, 0)]
self.model = nn.Sequential(*model)
def __init__(self, opt):
super().__init__()
input_nc = 3
# print("xxxxx")
# print(opt.norm_G)
norm_layer = get_nonspade_norm_layer(opt, opt.norm_G)
activation = nn.ReLU(False)
model = []
# initial conv
model += [
nn.ReflectionPad2d(opt.resnet_initial_kernel_size // 2),
norm_layer(
nn.Conv2d(
input_nc,
opt.ngf,
kernel_size=opt.resnet_initial_kernel_size,
padding=0,
)
),
activation,
]
# downsample
mult = 1
for i in range(opt.resnet_n_downsample):
model += [
norm_layer(
nn.Conv2d(
opt.ngf * mult,
opt.ngf * mult * 2,
kernel_size=3,
stride=2,
padding=1,
)
),
activation,
]
mult *= 2
# resnet blocks
for i in range(opt.resnet_n_blocks):
model += [
ResnetBlock(
opt.ngf * mult,
norm_layer=norm_layer,
activation=activation,
kernel_size=opt.resnet_kernel_size,
)
]
# upsample
for i in range(opt.resnet_n_downsample):
nc_in = int(opt.ngf * mult)
nc_out = int((opt.ngf * mult) / 2)
model += [
norm_layer(
nn.ConvTranspose2d(
nc_in,
nc_out,
kernel_size=3,
stride=2,
padding=1,
output_padding=1,
)
),
activation,
]
mult = mult // 2
# final output conv
model += [
nn.ReflectionPad2d(3),
nn.Conv2d(nc_out, opt.output_nc, kernel_size=7, padding=0),
nn.Tanh(),
]
self.model = nn.Sequential(*model)
def __init__(self, opt):
super().__init__()
self.opt = opt
output_nc = 3
label_nc = opt.label_nc
input_nc = label_nc + (1 if opt.contain_dontcare_label else
0) + (0 if opt.no_instance else 1)
if opt.mix_input_gen:
input_nc += 4
norm_layer = get_nonspade_norm_layer(opt, 'instance')
activation = nn.ReLU(False)
# initial block
self.init_block = nn.Sequential(*[
nn.ReflectionPad2d(opt.resnet_initial_kernel_size // 2),
norm_layer(
nn.Conv2d(input_nc,
opt.ngf,
kernel_size=opt.resnet_initial_kernel_size,
padding=0)), activation
])
# Downsampling blocks
self.downlayers = nn.ModuleList()
mult = 1
for i in range(opt.resnet_n_downsample):
self.downlayers.append(
nn.Sequential(*[
norm_layer(
nn.Conv2d(opt.ngf * mult,
opt.ngf * mult * 2,
kernel_size=3,
stride=2,
padding=1)), activation
]))
mult *= 2
# Semantic core blocks
self.resnet_core = nn.ModuleList()
if opt.wide:
self.resnet_core += [
ResnetBlock(opt.ngf * mult,
dim2=opt.ngf * mult * 2,
norm_layer=norm_layer,
activation=activation,
kernel_size=opt.resnet_kernel_size)
]
mult *= 2
else:
self.resnet_core += [
ResnetBlock(opt.ngf * mult,
norm_layer=norm_layer,
activation=activation,
kernel_size=opt.resnet_kernel_size)
]
for i in range(opt.resnet_n_blocks - 1):
self.resnet_core += [
ResnetBlock(opt.ngf * mult,
norm_layer=norm_layer,
activation=activation,
kernel_size=opt.resnet_kernel_size,
dilation=2)
]
self.spade_core = nn.ModuleList()
for i in range(opt.spade_n_blocks - 1):
self.spade_core += [
SPADEResnetBlock(opt.ngf * mult,
opt.ngf * mult,
opt,
dilation=2)
]
if opt.wide:
self.spade_core += [
SPADEResnetBlock(
opt.ngf * mult *
(2 if not self.opt.no_skip_connections else 1),
opt.ngf * mult // 2, opt)
]
mult //= 2
else:
self.spade_core += [
SPADEResnetBlock(
opt.ngf * mult *
(2 if not self.opt.no_skip_connections else 1),
opt.ngf * mult, opt)
]
# Upsampling blocks
self.uplayers = nn.ModuleList()
for i in range(opt.resnet_n_downsample):
self.uplayers.append(
SPADEResnetBlock(
mult * opt.ngf *
(3 if not self.opt.no_skip_connections else 2) // 2,
opt.ngf * mult // 2, opt))
mult //= 2
final_nc = opt.ngf
self.conv_img = nn.Conv2d(
(input_nc +
final_nc) if not self.opt.no_skip_connections else final_nc,
output_nc,
3,
padding=1)
self.up = nn.Upsample(scale_factor=2)
def __init__(self, opt):
super().__init__()
Pix2PixHDGenerator.modify_commandline_options(opt)
input_nc = opt['input_nc']
norm_layer = get_nonspade_norm_layer(opt, opt['norm_G'])
activation = nn.ReLU(False)
model = []
# initial conv
model += [
nn.ReflectionPad2d(opt['resnet_initial_kernel_size'] // 2),
norm_layer(
nn.Conv2d(input_nc,
opt['ngf'],
kernel_size=opt['resnet_initial_kernel_size'],
padding=0)), activation
]
# downsample
mult = 1
for i in range(opt['resnet_n_downsample']):
model += [
norm_layer(
nn.Conv2d(opt['ngf'] * mult,
opt['ngf'] * mult * 2,
kernel_size=3,
stride=2,
padding=1)), activation
]
mult *= 2
# resnet blocks
for i in range(opt['resnet_n_blocks']):
model += [
ResnetBlock(opt['ngf'] * mult,
norm_layer=norm_layer,
activation=activation,
kernel_size=opt['resnet_kernel_size'])
]
# upsample
for i in range(opt['resnet_n_upsample']):
nc_in = int(opt['ngf'] * mult)
nc_out = int((opt['ngf'] * mult) / 2)
model += [
norm_layer(
nn.ConvTranspose2d(nc_in,
nc_out,
kernel_size=3,
stride=2,
padding=1,
output_padding=1)), activation
]
# model += [
# nn.Upsample(scale_factor=2, mode='bilinear'),
# nn.ReflectionPad2d(1),
# norm_layer(
# nn.Conv2d(nc_in,
# nc_out,
# kernel_size=3,
# stride=1,
# padding=0))
# ]
mult = mult // 2
# final output conv
model += [
nn.ReflectionPad2d(3),
nn.Conv2d(nc_out, opt['output_nc'], kernel_size=7, padding=0),
nn.Tanh()
]
self.model = nn.Sequential(*model)
