def __init__(self):
super(ShallowConv, self).__init__()
with self.init_scope():
self.c_1 = L.Convolution2D(1, 3, 7, 2, 3)
self.i_1 = InstanceNormalization(3)
self.c_2 = L.Convolution2D(3, 6, 7, 4, 4)
self.i_2 = InstanceNormalization(6)
self.l_1 = L.Linear(None, 10)
def __init__(self, in_ch, out_ch):
super(Resblock, self).__init__()
w = initializers.Normal(0.02)
with self.init_scope():
self.c0 = L.Convolution2D(in_ch, out_ch, 3, 1, 1, initialW=w)
self.c1 = L.Convolution2D(out_ch, out_ch, 3, 1, 1, initialW=w)
self.bn0 = InstanceNormalization(out_ch)
self.bn1 = InstanceNormalization(out_ch)
def SepConv_BN(x,
filters,
prefix,
stride=1,
kernel_size=3,
rate=1,
depth_activation=False,
epsilon=1e-3):
""" SepConv with BN between depthwise & pointwise. Optionally add activation after BN
Implements right "same" padding for even kernel sizes
Args:
x: input tensor
filters: num of filters in pointwise convolution
prefix: prefix before name
stride: stride at depthwise conv
kernel_size: kernel size for depthwise convolution
rate: atrous rate for depthwise convolution
depth_activation: flag to use activation between depthwise & poinwise convs
epsilon: epsilon to use in BN layer
"""
if stride == 1:
depth_padding = 'same'
else:
kernel_size_effective = kernel_size + (kernel_size - 1) * (rate - 1)
pad_total = kernel_size_effective - 1
pad_beg = pad_total // 2
pad_end = pad_total - pad_beg
x = ZeroPadding2D((pad_beg, pad_end))(x)
depth_padding = 'valid'
if not depth_activation:
x = Activation('relu')(x)
x = DepthwiseConv2D((kernel_size, kernel_size),
strides=(stride, stride),
dilation_rate=(rate, rate),
padding=depth_padding,
use_bias=False,
name=prefix + '_depthwise')(x)
x = InstanceNormalization(name=prefix + '_depthwise_BN',
epsilon=epsilon)(x)
if depth_activation:
x = Activation('relu')(x)
x = Conv2D(filters, (1, 1),
padding='same',
use_bias=False,
name=prefix + '_pointwise')(x)
x = InstanceNormalization(name=prefix + '_pointwise_BN',
epsilon=epsilon)(x)
if depth_activation:
x = Activation('relu')(x)
return x
def __init__(self, ch, norm='instance', activation=F.relu):
super(ResBlock, self).__init__()
self.activation = activation
w = chainer.initializers.Normal(0.02)
with self.init_scope():
self.c0 = L.Convolution2D(ch, ch, 3, 1, 1, initialW=w)
self.c1 = L.Convolution2D(ch, ch, 3, 1, 1, initialW=w)
if norm == 'batch':
self.norm0 = L.BatchNormalization(ch)
self.norm1 = L.BatchNormalization(ch)
elif norm == 'instance':
self.norm0 = InstanceNormalization(ch)
self.norm1 = InstanceNormalization(ch)
def res_block_content(input_tensor, f):
x = input_tensor
x = ReflectPadding2D(x)
x = Conv2D(f, kernel_size=3, kernel_initializer=conv_init,
kernel_regularizer=regularizers.l2(w_l2),
use_bias=False, padding="valid")(x)
x = InstanceNormalization(epsilon=1e-5)(x)
x = Activation('relu')(x)
x = ReflectPadding2D(x)
x = Conv2D(f, kernel_size=3, kernel_initializer=conv_init,
kernel_regularizer=regularizers.l2(w_l2),
use_bias=False, padding="valid")(x)
x = InstanceNormalization(epsilon=1e-5)(x)
x = add([x, input_tensor])
return x
def __init__(self, base=32):
super(Discriminator, self).__init__()
w = initializers.Normal(0.02)
with self.init_scope():
self.c0 = L.Convolution2D(3, base, 3, 1, 1, initialW=w)
self.c1 = L.Convolution2D(base, base * 2, 4, 2, 1, initialW=w)
self.c2 = L.Convolution2D(base * 2, base * 4, 3, 1, 1, initialW=w)
self.c3 = L.Convolution2D(base * 4, base * 4, 4, 2, 1, initialW=w)
self.c4 = L.Convolution2D(base * 4, base * 8, 3, 1, 1, initialW=w)
self.c5 = L.Convolution2D(base * 8, base * 8, 3, 1, 1, initialW=w)
self.c6 = L.Convolution2D(base * 8, 1, 3, 1, 1, initialW=w)
self.bn0 = InstanceNormalization(base * 4)
self.bn1 = InstanceNormalization(base * 8)
self.bn2 = InstanceNormalization(base * 8)
def __init__(self, base=64):
w = initializers.Normal(0.02)
super(Discriminator, self).__init__()
with self.init_scope():
self.c0 = L.Convolution2D(6, base, 4, 2, 1, initialW=w)
self.c1 = L.Convolution2D(base, base * 2, 4, 2, 1, initialW=w)
self.c2 = L.Convolution2D(base * 2, base * 4, 4, 2, 1, initialW=w)
self.c3 = L.Convolution2D(base * 4, base * 8, 4, 2, 1, initialW=w)
self.c4 = L.Linear(None, 1, initialW=w)
self.in1 = InstanceNormalization(base * 2)
#self.in1=L.BatchNormalization(base*2)
self.in2 = InstanceNormalization(base * 4)
#self.in2=L.BatchNormalization(base*4)
self.in3 = InstanceNormalization(base * 8)
def Encoder_content_MUNIT(nc_in=3, input_size=IMAGE_SHAPE[0], n_downscale_content=n_downscale_content, nc_base=nc_base):
# Content encoder architecture
def res_block_content(input_tensor, f):
x = input_tensor
x = ReflectPadding2D(x)
x = Conv2D(f, kernel_size=3, kernel_initializer=conv_init,
kernel_regularizer=regularizers.l2(w_l2),
use_bias=False, padding="valid")(x)
x = InstanceNormalization(epsilon=1e-5)(x)
x = Activation('relu')(x)
x = ReflectPadding2D(x)
x = Conv2D(f, kernel_size=3, kernel_initializer=conv_init,
kernel_regularizer=regularizers.l2(w_l2),
use_bias=False, padding="valid")(x)
x = InstanceNormalization(epsilon=1e-5)(x)
x = add([x, input_tensor])
return x
inp = Input(shape=(input_size, input_size, nc_in))
x = ReflectPadding2D(inp, 3)
x = Conv2D(64, kernel_size=7, kernel_initializer=conv_init,
kernel_regularizer=regularizers.l2(w_l2),
use_bias=False, padding="valid")(x)
x = InstanceNormalization()(x) #
x = Activation('relu')(x) #
dim = 1
ds = 2**n_downscale_content
for i in range(n_downscale_content):
dim = 4 if dim >= 4 else dim*2
x = conv_block(x, dim*nc_base, use_norm=True)
for i in range(n_resblocks):
x = res_block_content(x, dim*nc_base)
content_code = x # Content code
return Model(inp, content_code)
def conv_block(input_tensor, f, k=3, strides=2, use_norm=False):
x = input_tensor
x = ReflectPadding2D(x)
x = Conv2D(f, kernel_size=k, strides=strides, kernel_initializer=conv_init,
kernel_regularizer=regularizers.l2(w_l2),
use_bias=(not use_norm), padding="valid")(x)
if use_norm:
x = InstanceNormalization(epsilon=1e-5)(x)
x = Activation("relu")(x)
return x
def __init__(self, in_ch, out_ch, up=False, down=False):
w = initializers.Normal(0.02)
self.up = up
self.down = down
super(CBR, self).__init__()
with self.init_scope():
self.cpara = L.Convolution2D(in_ch, out_ch, 3, 1, 1, initialW=w)
self.cdown = L.Convolution2D(in_ch, out_ch, 4, 2, 1, initialW=w)
self.bn0 = InstanceNormalization(out_ch)
def conv_block_d(input_tensor, f, use_norm=False):
x = input_tensor
x = ReflectPadding2D(x, 2)
x = Conv2D(f, kernel_size=4, strides=2, kernel_initializer=conv_init_dis,
kernel_regularizer=regularizers.l2(w_l2),
use_bias=(not use_norm), padding="valid")(x)
if use_norm:
x = InstanceNormalization(epsilon=1e-5)(x)
x = LeakyReLU(alpha=0.2)(x)
return x
def __init__(self,base=32):
super(Generator,self).__init__()
w=initializers.Normal(0.02)
with self.init_scope():
self.c0_img=L.Convolution2D(3,base,7,1,3,initialW=w)
self.cbr0_img=CBR(base,base*2,down=True)
self.cbr1_img=CBR(base*2,base*4,down=True)
self.res0_img=ResBlock(base*4,base*4)
self.res1_img=ResBlock(base*4,base*4)
self.res2_img=ResBlock(base*4,base*4)
self.res3_img=ResBlock(base*4,base*4)
self.res4_img=ResBlock(base*4,base*4)
self.res5_img=ResBlock(base*4,base*4)
self.res6_img=ResBlock(base*4,base*4)
self.res7_img=ResBlock(base*4,base*4)
self.res8_img=ResBlock(base*4,base*4)
self.cbr2_img=CBR(base*8,base*2,up=True)
self.cbr3_img=CBR(base*2,base,up=True)
self.c1_img=L.Convolution2D(base,3,7,1,3,initialW=w)
self.bn0_img=L.BatchNormalization(base)
self.in0_img=InstanceNormalization(base)
self.c0_mask=L.Convolution2D(1,base,7,1,3,initialW=w)
self.cbr0_mask=CBR(base,base*2,down=True)
self.cbr1_mask=CBR(base*2,base*4,down=True)
self.res0_mask=ResBlock(base*4,base*4)
self.res1_mask=ResBlock(base*4,base*4)
self.res2_mask=ResBlock(base*4,base*4)
self.res3_mask=ResBlock(base*4,base*4)
self.res4_mask=ResBlock(base*4,base*4)
self.res5_mask=ResBlock(base*4,base*4)
self.res6_mask=ResBlock(base*4,base*4)
self.res7_mask=ResBlock(base*4,base*4)
self.res8_mask=ResBlock(base*4,base*4)
self.cbr2_mask=CBR(base*12,base*2,up=True)
self.cbr3_mask=CBR(base*2,base,up=True)
self.c1_mask=L.Convolution2D(base,1,7,1,3,initialW=w)
self.bn0_mask=L.BatchNormalization(base)
self.in0_mask=InstanceNormalization(base)
def __init__(self, base=64):
w = initializers.Normal(0.02)
super(ContentEncoder, self).__init__()
with self.init_scope():
self.c0 = L.Convolution2D(3, base, 7, 1, 3, initialW=w)
self.bn0 = InstanceNormalization(base)
self.cbr1 = CBR(base, base*2, down=True)
self.cbr2 = CBR(base*2, base*4, down=True)
self.cbr3 = CBR(base*4, base*8, down=True)
self.res0 = ResBlock(base*8, base*8)
self.res1 = ResBlock(base*8, base*8)
def __init__(self,
ch0,
ch1,
ksize=3,
pad=1,
norm='instance',
sample='down',
activation=F.relu,
dropout=False,
noise=False):
super(CBR, self).__init__()
self.activation = activation
self.dropout = dropout
self.sample = sample
self.noise = noise
w = chainer.initializers.Normal(0.02)
with self.init_scope():
if sample == 'down':
self.c = L.Convolution2D(ch0, ch1, ksize, 2, pad, initialW=w)
elif sample == 'none-9':
self.c = L.Convolution2D(ch0, ch1, 9, 1, 4, initialW=w)
elif sample == 'none-7':
self.c = L.Convolution2D(ch0, ch1, 7, 1, 3, initialW=w)
elif sample == 'none-5':
self.c = L.Convolution2D(ch0, ch1, 5, 1, 2, initialW=w)
else:
self.c = L.Convolution2D(ch0, ch1, ksize, 1, pad, initialW=w)
if norm == 'batch':
if self.noise:
self.norm = L.BatchNormalization(ch1, use_gamma=False)
else:
self.norm = L.BatchNormalization(ch1)
elif norm == 'instance':
if self.noise:
self.norm = InstanceNormalization(ch1, use_gamma=False)
else:
self.norm = InstanceNormalization(ch1)
else:
raise ValueError('invalid norm parameter for CBR')
def __init__(self,in_ch,out_ch,up=False,down=False,predict=False,activation=F.relu):
super(CBR,self).__init__()
w=initializers.Normal(0.02)
self.up=up
self.down=down
self.activation=activation
self.predict=predict
with self.init_scope():
self.cpara=L.Convolution2D(in_ch,out_ch,3,1,1,initialW=w)
self.cdown=L.Convolution2D(in_ch,out_ch,4,2,1,initialW=w)
self.bn0=L.BatchNormalization(out_ch)
self.in0=InstanceNormalization(out_ch)
def decoder(self, x, a, b):
x = UpSampling2D(size=(2, 2))(x)
x = Conv2D(64, (3, 3), strides=1, padding='same')(x)
x = InstanceNormalization()(x)
x = Activation('relu')(x)
x1 = concatenate([x, b])
x = concatenate([x, x1])
x = UpSampling2D(size=(2, 2))(x)
x = Conv2D(64, (3, 3), strides=1, padding='same')(x)
x = InstanceNormalization()(x)
x = Activation('relu')(x)
x2 = concatenate([x, a])
x = concatenate([x, x2])
x = Conv2D(64, (3, 3), strides=1, padding='same')(x)
x = InstanceNormalization()(x)
x = Activation('relu')(x)
x = Conv2D(1, 1, padding='same', activation='sigmoid')(x)
return x
def add_conv(x,
channel,
ksize,
strides=(1, 1),
padding='valid',
dilation_rate=(1, 1)):
x = Conv2D(channel,
kernel_size=ksize,
strides=strides,
padding=padding,
dilation_rate=dilation_rate)(x)
x = InstanceNormalization()(x)
x = Activation('relu')(x)
return x
def __init__(self, base=32):
w = initializers.Normal(0.02)
super(Local_Enhancer, self).__init__()
with self.init_scope():
self.c0 = L.Convolution2D(3, base, 3, 1, 1, initialW=w)
self.down0 = Down(base, base * 2)
self.res0 = ResBlock(base * 2, base * 2)
self.res1 = ResBlock(base * 2, base * 2)
self.res2 = ResBlock(base * 2, base * 2)
self.res3 = ResBlock(base * 2, base * 2)
self.up0 = Up(base * 2, base)
self.c1 = L.Convolution2D(base, 3, 7, 1, 3, initialW=w)
self.in0 = InstanceNormalization(base)
def __init__(self, ch, norm="instance", activation=F.relu, noise=False):
self.use_norm = False if norm is None else True
self.activation = activation
layers = {}
w = chainer.initializers.Uniform(scale=math.sqrt(
1 / ch / 3 / 3)) #same to pytorch conv2d initializaiton
layers['c0'] = L.Convolution2D(ch,
ch,
3,
1,
1,
initialW=w,
nobias=True)
layers['c1'] = L.Convolution2D(ch,
ch,
3,
1,
1,
initialW=w,
nobias=True)
if norm == "batch":
layers['norm0'] = L.BatchNormalization(ch,
use_gamma=noise,
use_beta=noise)
layers['norm1'] = L.BatchNormalization(ch,
use_gamma=noise,
use_beta=noise)
elif norm == "instance":
layers['norm0'] = InstanceNormalization(ch,
use_gamma=noise,
use_beta=noise)
layers['norm1'] = InstanceNormalization(ch,
use_gamma=noise,
use_beta=noise)
super(ResBlock, self).__init__(**layers)
def __init__(self,base=64):
super(UNet,self).__init__()
w=initializers.Normal(0.02)
with self.init_scope():
self.c0=L.Convolution2D(6,base,3,1,1,initialW=w)
self.cbr0=CBR(base,base*2,down=True,predict=True)
self.cbr1=CBR(base*2,base*4,down=True,predict=True)
self.cbr2=CBR(base*4,base*8,down=True,predict=True)
self.cbr3=CBR(base*8,base*8,down=True,predict=True)
self.cbr4=CBR(base*16,base*8,up=True,predict=True)
self.cbr5=CBR(base*16,base*4,up=True,predict=True)
self.cbr6=CBR(base*8,base*2,up=True,predict=True)
self.cbr7=CBR(base*4,base*1,up=True,predict=True)
self.c1=L.Convolution2D(base*2,3,3,1,1,initialW=w)
self.bn0=InstanceNormalization(base)
def __init__(self,base=32):
super(Generator,self).__init__()
w=initializers.Normal(0.02)
with self.init_scope():
self.c0=L.Convolution2D(3,base,7,1,3,initialW=w)
self.cbr0=CBR(base,base*2,down=True)
self.cbr1=CBR(base*2,base*4,down=True)
self.res0=ResBlock(base*4,base*4)
self.res1=ResBlock(base*4,base*4)
self.res2=ResBlock(base*4,base*4)
self.res3=ResBlock(base*4,base*4)
self.res4=ResBlock(base*4,base*4)
self.res5=ResBlock(base*4,base*4)
self.cbr2=CBR(base*4,base*2,up=True)
self.cbr3=CBR(base*2,base,up=True)
self.c1=L.Convolution2D(base,3,7,1,3,initialW=w)
self.bn0=L.BatchNormalization(base)
self.in0=InstanceNormalization(base)
def __init__(self, base=64):
super(Generator, self).__init__()
w = initializers.Normal(0.02)
with self.init_scope():
self.c0 = L.Convolution2D(3, base, 7, 1, 3, initialW=w)
self.down0 = CCBR_down(base, base * 2)
self.down1 = CCBR_down(base * 2, base * 4)
self.res0 = Resblock(base * 4, base * 4)
self.res1 = Resblock(base * 4, base * 4)
self.res2 = Resblock(base * 4, base * 4)
self.res3 = Resblock(base * 4, base * 4)
self.res4 = Resblock(base * 4, base * 4)
self.res5 = Resblock(base * 4, base * 4)
self.res6 = Resblock(base * 4, base * 4)
self.res7 = Resblock(base * 4, base * 4)
self.up0 = CCBR_up(base * 4, base * 2)
self.up1 = CCBR_up(base * 2, base)
self.c1 = L.Convolution2D(base, 3, 7, 1, 3, initialW=w)
self.bn0 = InstanceNormalization(base)
def __init__(self, base=64):
w = initializers.Normal(0.02)
super(Global_Generator, self).__init__()
with self.init_scope():
self.c0 = L.Convolution2D(3, base, 7, 1, 3, initialW=w)
self.down0 = Down(base, base * 2)
self.down1 = Down(base * 2, base * 4)
self.down2 = Down(base * 4, base * 8)
self.down3 = Down(base * 8, base * 16)
self.res0 = ResBlock(base * 16, base * 16)
self.res1 = ResBlock(base * 16, base * 16)
self.res2 = ResBlock(base * 16, base * 16)
self.res3 = ResBlock(base * 16, base * 16)
self.res4 = ResBlock(base * 16, base * 16)
self.res5 = ResBlock(base * 16, base * 16)
self.up0 = Up(base * 16, base * 8)
self.up1 = Up(base * 8, base * 4)
self.up2 = Up(base * 4, base * 2)
self.up3 = Up(base * 2, base)
self.c1 = L.Convolution2D(base, 3, 7, 1, 3, initialW=w)
self.in0 = InstanceNormalization(base)