def __init__(self, nlatent, input_nc, nef, norm_layer):
super(Latent_Encoder, self).__init__()
use_bias = False
kw = 3
sequence = [
nn.Conv2d(input_nc, nef, kernel_size=kw, stride=2, padding=1, bias=True),
nn.ReLU(True),
nn.Conv2d(nef, 2*nef, kernel_size=kw, stride=2, padding=1, bias=use_bias),
norm_layer(2*nef),
nn.ReLU(True),
nn.Conv2d(2*nef, 4*nef, kernel_size=kw, stride=2, padding=1, bias=use_bias),
norm_layer(4*nef),
nn.ReLU(True),
nn.Conv2d(4*nef, 8*nef, kernel_size=kw, stride=2, padding=1, bias=use_bias),
norm_layer(8*nef),
nn.ReLU(True),
nn.Conv2d(8*nef, 8*nef, kernel_size=4, stride=1, padding=0, bias=use_bias),
norm_layer(8*nef),
nn.ReLU(True),
]
self.conv_modules = nn.Sequential(*sequence)
# make sure we return mu and logvar for latent code normal distribution
self.enc_mu = nn.Conv2d(8*nef, nlatent, kernel_size=1, stride=1, padding=0, bias=True)
self.enc_logvar = nn.Conv2d(8*nef, nlatent, kernel_size=1, stride=1, padding=0, bias=True)
utils.init_weights(self)
def __init__(self, input_nc, ndf):
super(Discriminator, self).__init__()
norm_layer = InstanceNorm
# A bunch of convolutions one after another
model = [
nn.Conv2d(input_nc, ndf, 4, stride=2, padding=1),
nn.LeakyReLU(0.2, inplace=True)
]
model += [
nn.Conv2d(ndf, ndf * 2, 4, stride=2, padding=1),
norm_layer(ndf * 2),
nn.LeakyReLU(0.2, inplace=True)
]
model += [
nn.Conv2d(ndf * 2, ndf * 4, 4, stride=2, padding=1),
norm_layer(ndf * 4),
nn.LeakyReLU(0.2, inplace=True)
]
# Return 1 channel prediction map
model += [nn.Conv2d(ndf * 4, 1, 4, padding=1)]
self.model = nn.Sequential(*model)
utils.init_weights(self)
def __init__(self,
input_nc,
output_nc,
ngf,
use_dropout=False,
n_res_blocks=6):
super(Generator, self).__init__()
# Initial convolution block
model = [
nn.ReflectionPad2d(3), # Reference from CycleGAN
nn.Conv2d(input_nc, ngf, 7),
InstanceNorm(ngf),
nn.ReLU(inplace=True)
]
# Downsampling
in_features = ngf
out_features = in_features * 2
for _ in range(2):
model += [
nn.Conv2d(in_features, out_features, 3, stride=2, padding=1),
InstanceNorm(out_features),
nn.ReLU(inplace=True)
]
in_features = out_features
out_features = in_features * 2
# Residual blocks
for _ in range(n_res_blocks):
model += [ResBlock(in_features, use_dropout)]
# Upsampling
out_features = in_features // 2
for _ in range(2):
model += [
nn.ConvTranspose2d(in_features,
out_features,
3,
stride=2,
padding=1,
output_padding=1),
InstanceNorm(out_features),
nn.ReLU(inplace=True)
]
in_features = out_features
out_features = in_features // 2
# Output layer
model += [
nn.ReflectionPad2d(3),
nn.Conv2d(64, output_nc, 7),
nn.Tanh()
]
self.model = nn.Sequential(*model)
utils.init_weights(self)
def __init__(self,in_ch,out_ch,mid_ch,layers,kernel_size,bias):
super(Sigma_mu_Net, self).__init__()
#
self.layers = layers
self.relu = nn.ReLU(inplace=True)
#
self.lyr=[]
self.lyr.append(nn.Conv2d(in_ch,mid_ch,kernel_size=1,bias=bias))
self.lyr.append(nn.ReLU(inplace=True))
for l in range(layers-2):
self.lyr.append(nn.Conv2d(mid_ch,mid_ch,kernel_size=1,bias=bias))
self.lyr.append(nn.ReLU(inplace=True))
self.lyr.append(nn.Conv2d(mid_ch,out_ch,kernel_size=1,bias=bias))
self.conv=nn.Sequential(*self.lyr)
init_weights(self.conv)
def __init__(self, in_ch, out_ch, mid_ch, blindspot_conv_type,
blindspot_conv_bias, br1_blindspot_conv_ks, br1_block_num,
br2_blindspot_conv_ks, br2_block_num, activate_fun):
super(DBSN_Model, self).__init__()
#
if activate_fun == 'Relu':
# self.relu = nn.ReLU(inplace=True)
self.relu = partial(nn.ReLU, inplace=True)
elif activate_fun == 'LeakyRelu':
# self.relu = nn.LeakyReLU(0.1)
self.relu = partial(nn.LeakyReLU, negative_slope=0.1)
else:
raise ValueError('activate_fun [%s] is not found.' %
(activate_fun))
# Head of DBSN
lyr = []
lyr.append(
nn.Conv2d(in_ch, mid_ch, kernel_size=1, bias=blindspot_conv_bias))
lyr.append(self.relu())
self.dbsn_head = nn.Sequential(*lyr)
init_weights(self.dbsn_head)
self.br1 = DBSN_branch(mid_ch, blindspot_conv_type,
blindspot_conv_bias, br1_blindspot_conv_ks,
br1_block_num, activate_fun)
self.br2 = DBSN_branch(mid_ch, blindspot_conv_type,
blindspot_conv_bias, br2_blindspot_conv_ks,
br2_block_num, activate_fun)
# Concat two branches
self.concat = nn.Conv2d(mid_ch * 2,
mid_ch,
kernel_size=1,
bias=blindspot_conv_bias)
self.concat.apply(weights_init_kaiming)
# 1x1 convs
lyr = []
lyr.append(
nn.Conv2d(mid_ch, mid_ch, kernel_size=1, bias=blindspot_conv_bias))
lyr.append(self.relu())
lyr.append(
nn.Conv2d(mid_ch, mid_ch, kernel_size=1, bias=blindspot_conv_bias))
lyr.append(self.relu())
lyr.append(
nn.Conv2d(mid_ch, out_ch, kernel_size=1, bias=blindspot_conv_bias))
self.dbsn_tail = nn.Sequential(*lyr)
init_weights(self.dbsn_tail)
def __init__(self, inplanes, bs_conv_type, bs_conv_bias, bs_conv_ks,
block_num, activate_fun):
super(DBSN_branch, self).__init__()
#
if activate_fun == 'Relu':
# self.relu = nn.ReLU(inplace=True)
self.relu = partial(nn.ReLU, inplace=True)
elif activate_fun == 'LeakyRelu':
# self.relu = nn.LeakyReLU(0.1)
self.relu = partial(nn.LeakyReLU, negative_slope=0.1)
else:
raise ValueError('activate_fun [%s] is not found.' %
(activate_fun))
#
dilation_base = (bs_conv_ks + 1) // 2
#
lyr = []
lyr.append(
BlindSpotConv(inplanes,
inplanes,
bs_conv_ks,
stride=1,
dilation=1,
bias=bs_conv_bias,
conv_type=bs_conv_type))
lyr.append(self.relu())
lyr.append(
nn.Conv2d(inplanes, inplanes, kernel_size=1, bias=bs_conv_bias))
lyr.append(self.relu())
lyr.append(
nn.Conv2d(inplanes, inplanes, kernel_size=1, bias=bs_conv_bias))
lyr.append(self.relu())
#
for i in range(block_num):
lyr.append(
Inception_block(inplanes,
kernel_size=3,
dilation=dilation_base,
bias=bs_conv_bias,
activate_fun=activate_fun))
#
lyr.append(
nn.Conv2d(inplanes, inplanes, kernel_size=1, bias=bs_conv_bias))
self.branch = nn.Sequential(*lyr)
init_weights(self.branch)
def __init__(self, conf, device, is_train=True):
super(InterpolationGAN, self).__init__()
self.conf = conf
self.device = device
# Generator 생성 및 초기화
self.G_S = Base.Stoch_Generator(
conf['nlatent'], conf['T_nc'], conf['S_nc'], conf['ngf'],
conf['use_dropout'], conf['n_res_blocks']) # T를 S로 변환하는 Generator
self.G_T = Base.Stoch_Generator(
conf['nlatent'], conf['S_nc'], conf['T_nc'], conf['ngf'],
conf['use_dropout'], conf['n_res_blocks']) # S를 T로 변환하는 Generator
# Domainess encoded latent vector Generator 생성 및 초기화
self.G_D = nn.Linear(1, conf['nlatent'])
utils.init_weights(self.G_D)
if is_train:
# Discriminator 생성 및 초기화
self.D_S = Base.Discriminator(
conf['S_nc'], conf['ndf']) # domain S를 구분하는 Discriminator
self.D_T = Base.Discriminator(
conf['T_nc'], conf['ndf']) # domain T를 구분하는 Discriminator
# Criterion 및 Optimizer 생성
self.optimizer_G = torch.optim.Adam(itertools.chain(
self.G_D.parameters(), self.G_S.parameters(),
self.G_T.parameters()),
lr=conf['lr'],
betas=(conf['beta'], 0.999))
self.optimizer_D = torch.optim.Adam(itertools.chain(
self.D_S.parameters(), self.D_T.parameters()),
lr=conf['lr'],
betas=(conf['beta'], 0.999))
self.criterionGAN = nn.MSELoss(reduction='mean')
self.criterion_cycle = nn.L1Loss(reduction='mean')
# Answer for discriminator
self.ans_real = Variable(torch.ones(
[self.conf['batch_size'], 1, 23, 23]),
requires_grad=False).to(device)
self.ans_fake = Variable(torch.zeros(
[self.conf['batch_size'], 1, 23, 23]),
requires_grad=False).to(device)
def __init__(self, in_ch, out_ch, mid_ch, layers, kernel_size, bias):
super(Sigma_n_Net, self).__init__()
#
self.layers = layers
self.relu = nn.ReLU(inplace=True)
#
if layers == 1:
self.conv_final = nn.Conv2d(in_ch,
out_ch,
kernel_size,
padding=(kernel_size - 1) // 2,
bias=bias)
nn.init.zeros_(self.conv_final.weight)
nn.init.zeros_(self.conv_final.bias)
else:
self.lyr = []
self.lyr.append(
nn.Conv2d(in_ch,
mid_ch,
kernel_size,
padding=(kernel_size - 1) // 2,
bias=bias))
self.lyr.append(nn.ReLU(inplace=True))
for l in range(layers - 2):
self.lyr.append(
nn.Conv2d(mid_ch,
mid_ch,
kernel_size,
padding=(kernel_size - 1) // 2,
bias=bias))
self.lyr.append(nn.ReLU(inplace=True))
self.conv = nn.Sequential(*self.lyr)
init_weights(self.conv)
#
self.conv_final = nn.Conv2d(mid_ch,
out_ch,
kernel_size,
padding=(kernel_size - 1) // 2,
bias=bias)
nn.init.zeros_(self.conv_final.weight)
nn.init.zeros_(self.conv_final.bias)
def __init__(self, nlatent, ndf):
super(Latent_Discriminator, self).__init__()
self.nlatent = nlatent
use_bias = True
sequence = [
nn.Linear(nlatent, ndf),
nn.BatchNorm1d(ndf),
nn.LeakyReLU(0.2, True),
nn.Linear(ndf, ndf),
nn.BatchNorm1d(ndf),
nn.LeakyReLU(0.2, True),
nn.Linear(ndf, ndf),
nn.BatchNorm1d(ndf),
nn.LeakyReLU(0.2, True),
nn.Linear(ndf, 1)
]
self.model = nn.Sequential(*sequence)
utils.init_weights(self)
def __init__(self, nlatent, input_nc, output_nc, ngf=64, use_dropout=False, n_blocks=9):
super(Stoch_Generator, self).__init__()
norm_layer = CondInstanceNorm
model = [
nn.ReflectionPad2d(3),
nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, stride=1, bias=True),
norm_layer(ngf, nlatent),
nn.ReLU(True),
nn.Conv2d(ngf, 2*ngf, kernel_size=3, padding=1, stride=1, bias=True),
norm_layer(2*ngf, nlatent),
nn.ReLU(True),
nn.Conv2d(2*ngf, 4*ngf, kernel_size=3, padding=1, stride=2, bias=True),
norm_layer(4*ngf, nlatent),
nn.ReLU(True)
]
for i in range(n_blocks):
model += [ CINResnetBlock(x_dim=4*ngf, z_dim=nlatent, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=True) ]
model += [
nn.ConvTranspose2d(4*ngf, 2*ngf, kernel_size=3, stride=2, padding=1,
output_padding=1, bias=True),
norm_layer(2*ngf , nlatent),
nn.ReLU(True),
nn.Conv2d(2*ngf, ngf, kernel_size=3, padding=1, stride=1, bias=True),
norm_layer(ngf, nlatent),
nn.ReLU(True),
nn.Conv2d(ngf, output_nc, kernel_size=7, padding=3),
nn.Tanh()
]
self.model = TwoInputSequential(*model)
utils.init_weights(self)
def __init__(self, params, is_train=True):
super(CycleGAN, self).__init__()
self.params = params
# Device 설정
if params.cuda: # 후에 multi-GPU coding할 수 있으면 적용
self.device = torch.device('cuda:{}'.format(params.gpu_id))
else:
self.device = torch.device('cpu')
# Generator 생성 및 초기화
self.G_S = Base.Generator(params.T_nc, params.S_nc, params.use_dropout,
params.n_res_blocks) # T를 S로 변환하는 Generator
self.G_T = Base.Generator(params.S_nc, params.T_nc, params.use_dropout,
params.n_res_blocks) # S를 T로 변환하는 Generator
if params.cuda:
self.G_S.cuda()
self.G_T.cuda()
utils.init_weights(self.G_S)
utils.init_weights(self.G_T)
# Discriminator 생성 및 초기화
if is_train:
self.D_S = Base.Discriminator(
params.S_nc) # domain S를 구분하는 Discriminator
self.D_T = Base.Discriminator(
params.T_nc) # domain T를 구분하는 Discriminator
if params.cuda:
self.D_S.cuda()
self.D_T.cuda()
utils.init_weights(self.D_S)
utils.init_weights(self.D_T)
Tensor = torch.cuda.FloatTensor if params.cuda else torch.Tensor
self.real = Variable(Tensor(params.batch_size).fill_(1.0),
requires_grad=False)
self.fake = Variable(Tensor(params.batch_size).fill_(0.0),
requires_grad=False)
# Model 구성요소 이름 저장
if is_train:
self.model_names = ['G_S', 'G_T', 'D_S', 'D_T']
self.loss_names = [
'G_S', 'D_S', 'Cycle_S', 'Ident_S', 'G_T', 'D_T', 'Cycle_T',
'Ident_T'
]
else:
self.model_names = ['G_S', 'G_T']
# Visual name을 넣을 것인가 말 것인가.
# Losses 및 Optimizer 생성
if is_train:
assert (params.S_nc == params.T_nc) # Identity Loss를 사용하려면 필요
# Buffers to save previously generated images
self.save_fake_S = ImageBuffer(params.buf_size)
self.save_fake_T = ImageBuffer(params.buf_size)
# Losses
self.criterion_GAN = nn.MSELoss(
) # Adversarial loss at CycleGAN section 3.1
self.criterion_cycle = nn.L1Loss(
) # Cycle consistency loss at CycleGAN section 3.2
self.criterion_identity = nn.L1Loss(
) # Identity loss at CycleGAN section 5.2
# Optimizer
self.optimizer_G = torch.optim.Adam(itertools.chain(
self.G_S.parameters(), self.G_T.parameters()),
lr=params.lr,
betas=(params.beta, 0.999))
self.optimizer_D = torch.optim.Adam(itertools.chain(
self.D_S.parameters(), self.D_T.parameters()),
lr=params.lr,
betas=(params.beta, 0.999))
def __init__(self, inplanes, kernel_size, dilation, bias, activate_fun):
super(Inception_block, self).__init__()
#
if activate_fun == 'Relu':
# self.relu = nn.ReLU(inplace=True)
self.relu = partial(nn.ReLU, inplace=True)
elif activate_fun == 'LeakyRelu':
# self.relu = nn.LeakyReLU(0.1)
self.relu = partial(nn.LeakyReLU, negative_slope=0.1)
else:
raise ValueError('activate_fun [%s] is not found.' %
(activate_fun))
#
pad_size = (kernel_size + (kernel_size - 1) * (dilation - 1) - 1) // 2
# inception_br1 ----------------------------------------------
lyr_br1 = []
# 1x1 conv
lyr_br1.append(nn.Conv2d(inplanes, inplanes, kernel_size=1, bias=bias))
lyr_br1.append(self.relu())
# # case1: two 3x3 dilated-conv
# lyr_br1.append(nn.Conv2d(inplanes, inplanes, kernel_size, padding=pad_size, dilation=dilation, bias=bias))
# lyr_br1.append(self.relu())
# lyr_br1.append(nn.Conv2d(inplanes, inplanes, kernel_size, padding=pad_size, dilation=dilation, bias=bias))
# lyr_br1.append(self.relu())
# case2: one 5x5 dilated-conv
tmp_kernel_size = 5
tmp_pad_size = (tmp_kernel_size + (tmp_kernel_size - 1) *
(dilation - 1) - 1) // 2
lyr_br1.append(
nn.Conv2d(inplanes,
inplanes,
kernel_size=tmp_kernel_size,
padding=tmp_pad_size,
dilation=dilation,
bias=bias))
lyr_br1.append(self.relu())
self.inception_br1 = nn.Sequential(*lyr_br1)
init_weights(self.inception_br1)
#
# inception_br2 ----------------------------------------------
lyr_br2 = []
# 1x1 conv
lyr_br2.append(nn.Conv2d(inplanes, inplanes, kernel_size=1, bias=bias))
lyr_br2.append(self.relu())
# 3x3 dilated-conv
lyr_br2.append(
nn.Conv2d(inplanes,
inplanes,
kernel_size,
padding=pad_size,
dilation=dilation,
bias=bias))
lyr_br2.append(self.relu())
self.inception_br2 = nn.Sequential(*lyr_br2)
init_weights(self.inception_br2)
#
# inception_br3 ----------------------------------------------
lyr_br3 = []
# 1x1 conv
lyr_br3.append(nn.Conv2d(inplanes, inplanes, kernel_size=1, bias=bias))
lyr_br3.append(self.relu())
self.inception_br3 = nn.Sequential(*lyr_br3)
init_weights(self.inception_br3)
# Concat three inception branches
self.concat = nn.Conv2d(inplanes * 3,
inplanes,
kernel_size=1,
bias=bias)
self.concat.apply(weights_init_kaiming)
# 1x1 convs
lyr = []
lyr.append(nn.Conv2d(inplanes, inplanes, kernel_size=1, bias=bias))
lyr.append(self.relu())
lyr.append(nn.Conv2d(inplanes, inplanes, kernel_size=1, bias=bias))
lyr.append(self.relu())
self.middle_1x1_convs = nn.Sequential(*lyr)
init_weights(self.middle_1x1_convs)
