def __init__(self):
super(Discriminator48, self).__init__(
dc1=L.Convolution2D(1,
32,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm1=L.BatchNormalization(32),
dc2=L.Convolution2D(32,
64,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(64),
dc3=L.Convolution2D(64,
128,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(128),
dc4=L.Linear(6 * 6 * 128, 2, initialW=Normal(0.02)),
)
def __init__(self, density=1, size=64, channel=3):
super(image2image_conv, self).__init__(
dc1=L.Convolution2D(channel,
int(16 * density),
3,
stride=2,
pad=1,
initialW=Normal(0.02)),
dc2=L.Convolution2D(int(16 * density),
int(32 * density),
3,
stride=2,
pad=1,
initialW=Normal(0.02)),
dc3=L.Convolution2D(int(32 * density),
int(32 * density),
3,
stride=1,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(32 * density)),
g4=L.Deconvolution2D(int(32 * density),
int(16 * density),
2,
stride=2,
pad=0,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(16 * density)),
g5=L.Deconvolution2D(int(16 * density),
channel,
2,
stride=2,
pad=0,
initialW=Normal(0.02)),
)
def __init__(self, density=1, size=64, channel=3):
assert (size % 16 == 0)
initial_size = size / 16
super(Discriminator, self).__init__(
dc1=L.Convolution2D(channel,
int(16 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
dc2=L.Convolution2D(int(16 * density),
int(32 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(32 * density)),
dc3=L.Convolution2D(int(32 * density),
int(64 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(64 * density)),
dc4=L.Convolution2D(int(64 * density),
int(128 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(128 * density)),
dc5=L.Linear(initial_size * initial_size * int(128 * density),
2,
initialW=Normal(0.02)),
)
def __init__(self):
latent_size = 100
super(Generator48, self).__init__(
g1=L.Linear(latent_size * 2, 6 * 6 * 128, initialW=Normal(0.02)),
norm1=L.BatchNormalization(6 * 6 * 128),
g2=L.Deconvolution2D(128,
64,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(64),
g3=L.Deconvolution2D(64,
32,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(32),
g4=L.Deconvolution2D(32,
1,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
)
self.latent_size = latent_size
def __init__(self):
super().__init__()
with self.init_scope():
self.first = Convolution2D(3,
64,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
self.res1 = SRGeneratorResBlock()
self.res2 = SRGeneratorResBlock()
self.res3 = SRGeneratorResBlock()
self.res4 = SRGeneratorResBlock()
self.res5 = SRGeneratorResBlock()
self.conv_mid = Convolution2D(64,
64,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
self.bn_mid = BatchNormalization(64)
self.upscale1 = SRGeneratorUpScaleBlock()
self.upscale2 = SRGeneratorUpScaleBlock()
self.conv_output = Convolution2D(64,
3,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
def __init__(self, density=1, size=5, channel=1):
super(Discriminator_simple, self).__init__(
dc1=L.Convolution2D(channel,
int(16 * density),
2,
stride=1,
pad=1,
initialW=Normal(0.02)),
dc2=L.Convolution2D(int(16 * density),
int(16 * density),
2,
stride=1,
pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(16 * density)),
dc3=L.Convolution2D(int(16 * density),
int(32 * density),
2,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(32 * density)),
dc4=L.Convolution2D(int(32 * density),
int(32 * density),
2,
stride=1,
pad=0,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(32 * density)),
dc5=L.Linear(3 * 3 * int(32 * density), 2, initialW=Normal(0.02)),
)
def __init__(self, density=1, size=64, channel=3):
assert (size % 16 == 0)
initial_size = size // 16
super(Discriminator, self).__init__(
dc1=L.Convolution2D(channel, int(16 * density), 4, stride=2, pad=1,
initialW=Normal(0.02)),
dc2=L.Convolution2D(int(16 * density), int(32 * density), 4, stride=2, pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(32 * density)),
# An extra layer to make the network deeper and not changing the feature sizes
dc2_=L.Convolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm2_=L.BatchNormalization(int(32 * density)),
# "plus layer" another extra layer added to make it deeper with stride = 1 but this one has
# a skip connection between input and output
dc2_p=L.Convolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm2_p=L.BatchNormalization(int(32 * density)),
dc3=L.Convolution2D(int(32 * density), int(64 * density), 4, stride=2, pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(64 * density)),
# An extra layer to make the network deeper and not changing the feature sizes
dc3_=L.Convolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm3_=L.BatchNormalization(int(64 * density)),
# "plus layer" another extra layer added to make it deeper with stride = 1 but this one has
# a skip connection between input and output
dc3_p=L.Convolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm3_p=L.BatchNormalization(int(64 * density)),
dc4=L.Convolution2D(int(64 * density), int(128 * density), 4, stride=2, pad=1,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(128 * density)),
dc5=L.Linear(initial_size * initial_size * int(128 * density), 2, initialW=Normal(0.02)),
)
def __init__(self,
density=1,
size=64,
latent_size=100,
channel=3,
num_objects=10,
num_describtions=10):
filter_size = 4
# intermediate_size = 256
assert (size % 16 == 0)
initial_size = size / 16
super(Generator_text, self).__init__(
# g0=L.Linear(latent_size + num_objects + num_describtions, intermediate_size, initialW=Normal(0.02)),
g1=L.Linear(latent_size + num_objects + num_describtions,
initial_size * initial_size * int(128 * density),
initialW=Normal(0.02)),
norm1=L.BatchNormalization(initial_size * initial_size *
int(128 * density)),
g2=L.Deconvolution2D(int(128 * density),
int(64 * density),
filter_size,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(64 * density)),
g3=L.Deconvolution2D(int(64 * density),
int(32 * density),
filter_size,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(32 * density)),
g4=L.Deconvolution2D(int(32 * density),
int(16 * density),
filter_size,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(16 * density)),
g5=L.Deconvolution2D(int(16 * density),
channel,
filter_size,
stride=2,
pad=1,
initialW=Normal(0.02)),
)
self.density = density
self.latent_size = latent_size
self.initial_size = initial_size
def __init__(self, opt):
super().__init__()
he_w = HeNormal()
xavier_w = Normal()
ndf = opt.ndf
with self.init_scope():
#[input] nclass x 256 x 256
self.c1 = define_conv(opt)(opt.class_num,
ndf,
ksize=3,
stride=2,
pad=1,
initialW=he_w)
#[input] ndf x 128 x 128
self.c2 = define_conv(opt)(ndf,
ndf * 2,
ksize=3,
stride=2,
pad=1,
initialW=he_w)
self.c2_norm = L.BatchNormalization(size=ndf * 2)
#[input] ndf*2 x 64 x 64
self.c3 = define_conv(opt)(ndf * 2,
ndf * 4,
ksize=3,
stride=2,
pad=1,
initialW=he_w)
self.c3_norm = L.BatchNormalization(size=ndf * 4)
#[input] ndf*4 x 32 x 32
self.c4 = define_conv(opt)(ndf * 4,
ndf * 8,
ksize=3,
stride=2,
pad=1,
initialW=he_w)
self.c4_norm = L.BatchNormalization(size=ndf * 8)
#[input] ndf*8 x 16 x 16
self.c5 = define_conv(opt)(ndf * 8,
1,
ksize=3,
stride=2,
pad=1,
initialW=he_w)
#[input] 1 x 8 x 8
self.upscale = define_deconv(opt)(1,
1,
ksize=32,
stride=32,
initialW=xavier_w)
#[output] 1 x 256 x 256
self.activation = F.leaky_relu
def __init__(self, opt):
super().__init__()
xavier_w = Normal()
he_w = HeNormal()
C, H, W = opt.img_shape
ngf = opt.ngf
label_ch = opt.class_num
self.opt = opt
layer_num = 6
init_shape = (ngf * 8, H // 2**layer_num, W // 2**layer_num)
with self.init_scope():
self.w1 = ConstantFCN(opt, opt.class_num)
self.w2 = ConstantFCN(opt, opt.c_shape[0])
self.head_reshape = lambda x: F.resize_images(x, init_shape[1:])
self.head = define_conv(opt)(label_ch,
init_shape[0],
ksize=3,
pad=1,
initialW=he_w)
#512 x 4 x 4
self.r1 = SPADEResBlock(opt, ngf * 8, ngf * 8)
self.up1 = define_upsampling(opt, ngf * 8)
#512 x 8 x 8
self.r2 = SPADEResBlock(opt, ngf * 8, ngf * 8)
self.up2 = define_upsampling(opt, ngf * 8)
#512 x 16 x 16
self.r3 = SPADEResBlock(opt, ngf * 8, ngf * 8)
self.up3 = define_upsampling(opt, ngf * 8)
#512 x 32 x 32
self.r4 = SPADEResBlock(opt, ngf * 8, ngf * 4)
self.up4 = define_upsampling(opt, ngf * 4)
#256 x 64 x 64
self.r5 = SPADEResBlock(opt, ngf * 4, ngf * 2)
self.up5 = define_upsampling(opt, ngf * 2)
#128 x 128 x 128
self.r6 = SPADEResBlock(opt, ngf * 2, ngf)
self.up6 = define_upsampling(opt, ngf)
#64 x 256 x 256
self.r7 = SPADEResBlock(opt, ngf, ngf // 2)
#32 x 256 x 256
self.to_img = L.Convolution2D(ngf // 2,
3,
ksize=3,
pad=1,
initialW=xavier_w)
def __init__(self):
super().__init__()
with self.init_scope():
self.c1 = Convolution2D(64,
64,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
self.bn1 = BatchNormalization(64)
self.c2 = Convolution2D(64,
64,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
self.bn2 = BatchNormalization(64)
def __init__(self, density=1, size=64, latent_size=100, channel=3, num_objects=10, num_descriptions=10):
filter_size = 2
intermediate_size = size / 8
assert (size % 16 == 0)
initial_size = size / 16
super(Generator_text, self).__init__(
g0=L.Linear(num_objects + num_descriptions, intermediate_size * intermediate_size * 7, initialW=Normal(0.02)),
g1=L.Linear(latent_size, initial_size * initial_size * int(128 * density),
initialW=Normal(0.02)),
norm1=L.BatchNormalization(initial_size * initial_size * int(128 * density)),
g2=L.Deconvolution2D(int(128 * density), int(64 * density), filter_size, stride=2, pad=0,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(64 * density)),
# An extra layer to make the network deeper and not changing the feature sizes
g2_=L.Deconvolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm2_=L.BatchNormalization(int(64 * density)),
# "plus layer" another extra layer added to make it deeper with stride = 1 but this one has
# a skip connection between input and output
g2_p=L.Convolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm2_p=L.BatchNormalization(int(64 * density)),
g3=L.Deconvolution2D(int(64 * density + 7), int(32 * density), filter_size, stride=2, pad=0,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(32 * density)),
g3_=L.Deconvolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm3_=L.BatchNormalization(int(32 * density)),
g3_p=L.Convolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm3_p=L.BatchNormalization(int(32 * density)),
g4=L.Deconvolution2D(int(32 * density), int(16 * density), filter_size, stride=2, pad=0,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(16 * density)),
g4_=L.Deconvolution2D(int(16 * density), int(16 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm4_=L.BatchNormalization(int(16 * density)),
g5=L.Deconvolution2D(int(16 * density), channel, filter_size, stride=2, pad=0,
initialW=Normal(0.02)),
)
self.density = density
self.latent_size = latent_size
self.initial_size = initial_size
def __init__(self):
super().__init__()
with self.init_scope():
self.conv = Convolution2D(in_channels=64,
out_channels=256,
ksize=3,
stride=1,
pad=1,
initialW=Normal(0.02))
def __init__(self, size, in_channels, out_channels):
super().__init__()
with self.init_scope():
self.c1 = Parameter(shape=(in_channels, 4, 4),
initializer=Normal(1.0))
self.s1 = StyleAffineTransformation(size, in_channels)
self.w1 = WeightModulatedConvolution(in_channels, out_channels)
self.n1 = NoiseAdder()
self.a1 = LeakyRelu()
self.s2 = StyleAffineTransformation(size, out_channels)
self.trgb = ToRGB(out_channels)
def __init__(self, density=1, latent_size=64, robot_latent_size=16, text_encoding_size=128, att_size=28, word_num=10, shape_size=10, color_size=10):
self.att_size = att_size
self.input_size = 224
self.density = density
self.word_num = word_num
super(Encoder_double_att, self).__init__(
# LSTM part
l1_ = L.LSTM(self.word_num, text_encoding_size),
# a pretrained VGG feature extractor, not trained in this network
dc1 = L.Convolution2D(3, int(16 * density), 5, stride=2, pad=2, initialW=Normal(0.02)),
dc2 = L.Convolution2D(int(16 * density), int(32 * density), 5, stride=2, pad=2, initialW=Normal(0.02)),
norm2 = L.BatchNormalization(int(32 * density)),
dc2_= L.Convolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1, initialW=Normal(0.02)),
norm2_= L.BatchNormalization(int(32 * density)),
dc2__ = L.Convolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1, initialW=Normal(0.02)),
norm2__ = L.BatchNormalization(int(32 * density)),
dc3 = L.Convolution2D(int(32 * density), int(64 * density), 3, stride=2, pad=1, initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(64 * density)),
dc3_=L.Convolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1, initialW=Normal(0.02)),
norm3_=L.BatchNormalization(int(64 * density)),
dc3__=L.Convolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1, initialW=Normal(0.02)),
norm3__=L.BatchNormalization(int(64 * density)),
dc4=L.Convolution2D(int(64 * density), int(128 * density), 3, stride=1, pad=1, initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(128 * density)),
dc5 = L.Linear(self.att_size * self.att_size * int(128 * density), 32, initialW=Normal(0.02)),
# dc6 = L.Linear(robot_latent_size, 3, initialW=Normal(0.02)),
fc_video0 = L.Convolution2D(int(128 * density), int(128 * density), 1, stride=1, pad=0, initialW=Normal(0.02), nobias=True),
norm0 = L.BatchNormalization(int(128 * density), use_gamma = False),
fc_video1 = L.Convolution2D(int(128 * density), int(16 * density), 1, stride=1, pad=0, initialW=Normal(0.02), nobias=True),
norm1 = L.BatchNormalization(int(16 * density), use_gamma = False),
fc_video2 = L.Convolution2D(int(16 * density), int(16 * density), 1, stride=1, pad=0, initialW=Normal(0.02)),
# Text Input Layers
fc_text0 = L.Linear(text_encoding_size, int(8 * density), initialW=Normal(0.02), nobias=True),
norm_text0 = L.BatchNormalization(int(8 * density)),
fc_text1 = L.Linear(int(8 * density), int(16 * density), initialW=Normal(0.02)),
# norm_text1 = L.BatchNormalization(128),
#Attention Extraction
norm_mix = L.BatchNormalization(int(16 * density), use_gamma = False),
fc_mix0 = L.Convolution2D(int(16 * density), 1, 1, stride=1, pad=0, initialW=Normal(0.02)),
# fc7 = L.Linear(64 * 7 * 7, 64 * self.att_size * self.att_size, initialW=Normal(0.02)),
#Classifier
fc_cls0 = L.Linear(int(16 * density), int(8 * density), initialW=Normal(0.02), nobias=True),
norm_cls0 = L.BatchNormalization(int(8 * density)),
fc5 = L.Linear(int(8 * density), shape_size, initialW=Normal(0.02)),
fc6 = L.Linear(int(8 * density), color_size, initialW=Normal(0.02)),
fc7 = L.Linear(int(8 * density), 7, initialW=Normal(0.02)),
#Latent extraction
# norm_D = L.BatchNormalization(int((128 + 1) * density)),
# fc_toz_mean = L.Linear(int((128 + 1) * density), latent_size, initialW=Normal(0.02)),
# fc_toz_var = L.Linear(int((128 + 1) * density), latent_size, initialW=Normal(0.02)),
)
def __init__(self,
in_size,
out_size=None,
initial_bias=None,
gain=sqrt(2)):
super().__init__()
self.c = gain * sqrt(1 / in_size)
with self.init_scope():
self.linear = Linear(in_size,
out_size,
initialW=Normal(1.0),
initial_bias=initial_bias)
def __init__(self, size=128, num_objects=10, num_descriptions=10):
super(classifier_simple, self).__init__(
dc0=L.Linear(size, 128, initialW=Normal(0.02)),
dc1=L.Linear(128, 64, initialW=Normal(0.02)),
dc2=L.Linear(64, 64, initialW=Normal(0.02)),
dc3=L.Linear(64, 32, initialW=Normal(0.02)),
dc4=L.Linear(32, 32, initialW=Normal(0.02)),
dc5=L.Linear(32, num_objects, initialW=Normal(0.02)),
dc55=L.Linear(32, num_descriptions, initialW=Normal(0.02)),
)
def __init__(self, density=1, size=64, channel=3, num_objects=10, num_descriptions=10):
assert (size % 16 == 0)
self.num_objects = num_objects
self.num_descriptions = num_descriptions
initial_size = size / 16
super(Discriminator_texual, self).__init__(
dc1=L.Convolution2D(channel, int(16 * density), 4, stride=2, pad=1,
initialW=Normal(0.02)),
dc2=L.Convolution2D(int(16 * density), int(32 * density), 4, stride=2, pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(32 * density)),
# "plus layer" another extra layer added to make it deeper with stride = 1 but this one has
# a skip connection between input and output
dc2_p=L.Convolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm2_p=L.BatchNormalization(int(32 * density)),
dc3=L.Convolution2D(int(32 * density), int(64 * density), 4, stride=2, pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(64 * density)),
# "plus layer" another extra layer added to make it deeper with stride = 1 but this one has
# a skip connection between input and output
dc3_p=L.Convolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm3_p=L.BatchNormalization(int(64 * density)),
dc4=L.Convolution2D(int(64 * density), int(128 * density), 4, stride=2, pad=1,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(128 * density)),
dc5=L.Linear(initial_size * initial_size * int(128 * density), num_objects, initialW=Normal(0.02)),
dc6=L.Linear(initial_size * initial_size * int(128 * density), num_descriptions, initialW=Normal(0.02)),
dc8=L.Linear(initial_size * initial_size * int(128 * density), num_objects, initialW=Normal(0.02)),
dc9=L.Linear(initial_size * initial_size * int(128 * density), num_descriptions, initialW=Normal(0.02)),
)
def __init__(self, density=1, size=64, latent_size=100, channel=3):
assert (size % 16 == 0)
initial_size = size / 16
super(Generator, self).__init__(
g1=L.Linear(latent_size,
initial_size * initial_size * int(128 * density),
initialW=Normal(0.02)),
norm1=L.BatchNormalization(initial_size * initial_size *
int(128 * density)),
g2=L.Deconvolution2D(int(128 * density),
int(64 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(64 * density)),
g3=L.Deconvolution2D(int(64 * density),
int(32 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(32 * density)),
g4=L.Deconvolution2D(int(32 * density),
int(16 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(16 * density)),
g5=L.Deconvolution2D(int(16 * density),
channel,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
)
self.density = density
self.latent_size = latent_size
self.initial_size = initial_size
def __init__(self,
in_channels,
out_channels,
pointwise=False,
demod=True,
gain=root(2)):
super().__init__()
self.demod = demod
self.ksize = 1 if pointwise else 3
self.pad = 0 if pointwise else 1
self.c = gain * root(1 / (in_channels * self.ksize**2))
with self.init_scope():
self.w = Parameter(shape=(out_channels, in_channels, self.ksize,
self.ksize),
initializer=Normal(1.0))
self.b = Parameter(shape=out_channels, initializer=Zero())
def __init__(self,
in_channels,
out_channels,
ksize=3,
stride=1,
pad=0,
nobias=False,
initial_bias=None,
gain=sqrt(2),
reflect=False):
super().__init__()
self.c = gain * sqrt(1 / (in_channels * ksize**2))
self.pad = pad
self.reflect = reflect
with self.init_scope():
self.conv = Convolution2D(in_channels,
out_channels,
ksize,
stride,
0 if reflect else pad,
nobias=nobias,
initialW=Normal(1.0),
initial_bias=initial_bias)
def __init__(self,
density=1,
size=64,
latent_size=100,
channel=3,
hidden_dim=100):
assert (size % 16 == 0)
initial_size = size / 16
super(Encoder_text, self).__init__(
dc1=L.Convolution2D(channel,
int(16 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
dc2=L.Convolution2D(int(16 * density),
int(32 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(32 * density)),
dc3=L.Convolution2D(int(32 * density),
int(64 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(64 * density)),
dc4=L.Convolution2D(int(64 * density),
int(128 * density),
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(128 * density)),
mean=L.Linear(initial_size * initial_size * int(128 * density),
latent_size,
initialW=Normal(0.02)),
var=L.Linear(initial_size * initial_size * int(128 * density),
latent_size,
initialW=Normal(0.02)),
)
def __call__(self, array):
if self.dtype is not None:
assert array.dtype == self.dtype
fan_in, fan_out = initializer.get_fans(array.shape)
s = self.scale * np.sqrt(1. / fan_in)
Normal(s)(array)
def __init__(self, opt):
super().__init__()
he_w = HeNormal()
xavier_w = Normal()
ndf = opt.ndf
with self.init_scope():
top_ch = opt.img_shape[0] + opt.class_num + opt.c_shape[0]
#top_ch x 256 x 256
self.c1 = define_conv(opt)(top_ch,
ndf,
ksize=4,
stride=2,
pad=1,
initialW=he_w)
#64 x 128 x 128
self.c2 = define_conv(opt)(ndf,
ndf * 2,
ksize=4,
stride=2,
pad=1,
initialW=he_w)
self.n2 = L.BatchNormalization(size=ndf * 2)
#128 x 64 x 64
self.c3 = define_conv(opt)(ndf * 2,
ndf * 4,
ksize=4,
stride=2,
pad=1,
initialW=he_w)
self.att = SelfAttention(opt, ndf * 4)
self.n3 = L.BatchNormalization(size=(ndf * 4))
#256 x 32 x 32
self.c4 = define_conv(opt)(ndf * 4,
ndf * 8,
ksize=4,
stride=1,
pad=1,
initialW=he_w)
self.n4 = L.BatchNormalization(size=ndf * 8)
#512 x 31 x 32
self.head = define_conv(opt)(ndf * 8,
ndf * 8,
ksize=4,
stride=1,
pad=1,
initialW=he_w)
#512 x 30 x 30
self.r1 = ResBlock(opt, ndf * 8, ndf * 4)
#256 x 30 x 30
self.r2 = ResBlock(opt, ndf * 4, ndf * 2)
#128 x 30 x 30
self.r3 = ResBlock(opt, ndf * 2, ndf)
#64 x 30 x 30
self.to_patch = define_conv(opt)(ndf,
1,
ksize=3,
stride=1,
pad=1,
initialW=xavier_w)
#out is 1 x 30 x 30
self.activation = F.leaky_relu
def __init__(self):
super().__init__()
with self.init_scope():
self.conv_input = Convolution2D(3,
64,
ksize=3,
stride=1,
pad=0,
initialW=Normal(0.02))
self.c1 = Convolution2D(64,
64,
ksize=3,
stride=2,
pad=0,
initialW=Normal(0.02))
self.bn1 = BatchNormalization(64)
self.c2 = Convolution2D(64,
128,
ksize=3,
stride=1,
pad=0,
initialW=Normal(0.02))
self.bn2 = BatchNormalization(128)
self.c3 = Convolution2D(128,
128,
ksize=3,
stride=2,
pad=0,
initialW=Normal(0.02))
self.bn3 = BatchNormalization(128)
self.c4 = Convolution2D(128,
256,
ksize=3,
stride=1,
pad=0,
initialW=Normal(0.02))
self.bn4 = BatchNormalization(256)
self.c5 = Convolution2D(256,
256,
ksize=3,
stride=2,
pad=0,
initialW=Normal(0.02))
self.bn5 = BatchNormalization(256)
self.c6 = Convolution2D(256,
512,
ksize=3,
stride=1,
pad=0,
initialW=Normal(0.02))
self.bn6 = BatchNormalization(512)
self.c7 = Convolution2D(512,
512,
ksize=3,
stride=2,
pad=0,
initialW=Normal(0.02))
self.bn7 = BatchNormalization(512)
self.linear1 = Linear(in_size=4608, out_size=1024)
self.linear2 = Linear(in_size=None, out_size=2)
def __init__(self, density=1, size=64, latent_size=100, channel=3, num_objects=10, num_descriptions=10):
"""
density - a scaling factor for the number of channels in the convolutional layers. It is multiplied by at least
16,32,64 and 128 as we go deeper.
Use: using density=8 when training the VAE separately. using density=4 when training end to end
Intent: increase the number of features in the convolutional layers.
"""
assert (size % 16 == 0)
second_size = size / 4
initial_size = size / 16
super(Encoder_text_tower, self).__init__(
#
dc1=L.Convolution2D(channel, int(16 * density), 3, stride=2, pad=1,
initialW=Normal(0.02)),
# can we write comments here
dc2=L.Convolution2D(int(16 * density), int(32 * density), 3, stride=2, pad=1,
initialW=Normal(0.02)),
# extra layers added to make it deeper with stride = 1
dc1_=L.Convolution2D(int(16 * density), int(16 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
dc2_=L.Convolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(int(32 * density)),
norm2_=L.BatchNormalization(int(32 * density)),
# "plus layer" another extra layer added to make it deeper with stride = 1 but this one has
# a skip connection between input and output
dc2_p=L.Convolution2D(int(32 * density), int(32 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm2_p=L.BatchNormalization(int(32 * density)),
dc3=L.Convolution2D(int(32 * density + 7), int(64 * density), 3, stride=2, pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(int(64 * density)),
dc3_=L.Convolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm3_=L.BatchNormalization(int(64 * density)),
dc3_p=L.Convolution2D(int(64 * density), int(64 * density), 3, stride=1, pad=1,
initialW=Normal(0.02)),
norm3_p=L.BatchNormalization(int(64 * density)),
dc4=L.Convolution2D(int(64 * density), int(128 * density), 3, stride=2, pad=1,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(int(128 * density)),
toConv=L.Linear(num_objects + num_descriptions, second_size * second_size * 7, initialW=Normal(0.02)),
mean=L.Linear(initial_size * initial_size * int(128 * density), latent_size,
initialW=Normal(0.02)),
var=L.Linear(initial_size * initial_size * int(128 * density), latent_size,
initialW=Normal(0.02)),
)
def __init__(self, density=1, size=64, latent_size=100, channel=3):
assert (size % 16 == 0)
initial_size = size / 16
super(EncoderDeep, self).__init__(
dc1=L.Convolution2D(channel,
16 * density,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
dc2=L.Convolution2D(16 * density,
32 * density,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm2=L.BatchNormalization(32 * density),
dc3=L.Convolution2D(32 * density,
64 * density,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm3=L.BatchNormalization(64 * density),
dc4=L.Convolution2D(64 * density,
128 * density,
4,
stride=2,
pad=1,
initialW=Normal(0.02)),
norm4=L.BatchNormalization(128 * density),
dc1_=L.Convolution2D(16 * density,
16 * density,
3,
stride=1,
pad=1,
initialW=Normal(0.02)),
dc2_=L.Convolution2D(32 * density,
32 * density,
3,
stride=1,
pad=1,
initialW=Normal(0.02)),
norm2_=L.BatchNormalization(32 * density),
dc3_=L.Convolution2D(64 * density,
64 * density,
3,
stride=1,
pad=1,
initialW=Normal(0.02)),
norm3_=L.BatchNormalization(64 * density),
dc4_=L.Convolution2D(128 * density,
128 * density,
3,
stride=1,
pad=1,
initialW=Normal(0.02)),
norm4_=L.BatchNormalization(128 * density),
mean=L.Linear(initial_size * initial_size * 128 * density,
latent_size,
initialW=Normal(0.02)),
var=L.Linear(initial_size * initial_size * 128 * density,
latent_size,
initialW=Normal(0.02)),
)
def __init__(self, size=64, channel=3):
super(image2image_fc,
self).__init__(convertor=L.Linear(size * size * channel,
size * size * channel,
initialW=Normal(0.02)), )
