def decoder(self, x, is_training=True, reuse=False):
with tf.variable_scope("decoder", reuse=reuse):
# Layer 1
net = layers.linear(x,
self.linear_dim >> 1,
scope='de_fc1',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
# Layer 2: Decoder Space
output_dim = self.input_shape[1] * self.input_shape[
2] * self.input_shape[3]
net = layers.linear(x,
output_dim,
scope='de_fc2',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.sigmoid(net)
if self.verbose: print(net.shape)
# Layer 3: Reshaping
net = tf.reshape(net, self.input_shape, name='main_out')
if self.verbose: print(net.shape)
return net
def latent_space(self, x, is_training=True, reuse=False):
with tf.variable_scope("latent_space", reuse=reuse):
# Layer 2.1: z_mean
self.z_mean = layers.linear(x,
self.latent_dim,
scope='en_z_mean',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
if self.verbose: print(self.z_mean.shape, end=" || ")
# Layer 2.2: z_std
self.z_std = layers.linear(x,
self.latent_dim,
scope='en_z_std',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
self.z_std = tf.nn.sigmoid(self.z_std)
self.z_std = tf.maximum(self.z_std, 0.001)
if self.verbose: print(self.z_std.shape)
# Sampler: Normal (gaussian) random distribution
shape = tf.shape(self.z_std)
eps = tf.random_normal(shape, mean=0.0, stddev=1.0, name='epsilon')
# The reparameterization trick
self.z = self.z_mean + self.z_std * eps
return self.z
def encoder(self, x, is_training=True, reuse=False):
with tf.variable_scope("encoder", reuse=reuse):
if self.verbose: print(x.shape)
# Layer 1
net = layers.conv2d(x, self.conv_dim >> 1, name='en_conv1')
net = tf.nn.leaky_relu(net)
if self.verbose: print(net.shape)
# Layer 2
net = layers.conv2d(net, self.conv_dim, name='en_conv2')
net = tf.nn.leaky_relu(net)
if self.verbose: print(net.shape)
# Layer 3
net = layers.flatten(net)
if self.verbose: print(net.shape)
# Layer 4
net = layers.linear(net, self.linear_dim, scope='en_fc1')
net = tf.nn.leaky_relu(net)
if self.verbose: print(net.shape)
# Layer 5
net = layers.linear(net, self.latent_dim, scope='en_fc2')
net = tf.identity(net)
if self.verbose: print(net.shape)
return net
def encoder_v2(self, x, is_training=True, reuse=False):
with tf.variable_scope("encoder_v2", reuse=reuse):
if self.verbose: print(x.shape)
# Layer 1
net = layers.conv2d(x, self.conv_dim >> 1, name='en_conv1')
net = tf.nn.leaky_relu(net)
if self.verbose: print(net.shape)
# Layer 2
net = layers.conv2d(net, self.conv_dim, name='en_conv2')
net = layers.batch_norm(net,
is_training=is_training,
scope='en_bn2')
net = tf.nn.leaky_relu(net)
if self.verbose: print(net.shape)
# Layer 3
net = layers.flatten(net)
if self.verbose: print(net.shape)
# Layer 4
net = layers.linear(net, self.linear_dim, scope='en_fc3')
net = layers.batch_norm(net,
is_training=is_training,
scope='en_bn3')
net = tf.nn.leaky_relu(net)
if self.verbose: print(net.shape)
# Layer 5
out_logit = layers.linear(net, self.latent_dim, scope='en_fc4')
out = tf.nn.sigmoid(out_logit, name="main_out")
if self.verbose: print(out.shape)
return out
def encoder(self, x, is_training=True, reuse=False):
with tf.variable_scope("encoder", reuse=reuse):
if self.verbose: print(x.shape)
# Layer 0: Flattening
net = layers.flatten(x)
if self.verbose: print(net.shape, ": Flatten")
# Layer 1
net = layers.linear(net,
self.linear_dim,
scope='en_fc1',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.tanh(net)
if self.verbose: print(net.shape)
# Layer 2
net = layers.linear(net,
self.linear_dim >> 1,
scope='en_fc2',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.identity(net, name="main_out")
if self.verbose: print(net.shape)
return net
def decoder_v2(self, x, is_training=True, reuse=False):
with tf.variable_scope("decoder", reuse=reuse):
if self.verbose: print(x.shape)
# Layer 1
net = layers.linear(x, self.linear_dim, scope='de_fc1')
net = layers.batch_norm(net,
is_training=is_training,
scope='de_bn1')
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
# Layer 2
shape = self.conv_dim * ((self.image_size >> 2)**2)
net = layers.linear(net, shape, scope='de_fc2')
net = layers.batch_norm(net,
is_training=is_training,
scope='de_bn2')
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
# Layer 3
shape = [
self.batch_size, self.image_size >> 2, self.image_size >> 2,
self.conv_dim
]
net = tf.reshape(net, shape)
if self.verbose: print(net.shape)
# Layer 4
shape = [
self.batch_size, self.image_size >> 1, self.image_size >> 1,
self.conv_dim >> 1
]
net = layers.deconv2d(net, shape, name='de_dc3')
net = layers.batch_norm(net,
is_training=is_training,
scope='de_bn3')
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
# Layer 5
shape = [
self.batch_size, self.image_size, self.image_size,
self.channels
]
net = layers.deconv2d(net, shape, name='de_dc4')
out = tf.nn.sigmoid(net, name="main_out")
if self.verbose: print(out.shape)
return out
def discriminatorVid(self, video, reuse=False):
with tf.variable_scope('disc_v', reuse=reuse) as vs:
initial_dim = 64
d_h0 = dis_block(video, 3, initial_dim, 'block1', reuse=reuse)
d_h1 = dis_block(d_h0,
initial_dim,
initial_dim * 2,
'block2',
reuse=reuse)
d_h2 = dis_block(d_h1,
initial_dim * 2,
initial_dim * 4,
'block3',
reuse=reuse)
d_h3 = dis_block(d_h2,
initial_dim * 4,
initial_dim * 8,
'block4',
reuse=reuse)
d_h4 = dis_block(d_h3,
initial_dim * 8,
1,
'block5',
reuse=reuse,
normalize=False)
d_h5 = linear(tf.reshape(d_h4, [self.batch_size, -1]), 1)
# variables = tf.contrib.framework.get_variables(vs)
# return d_h5, variables
return d_h5
def discriminator(self, video, reuse=False):
with tf.variable_scope('d_', reuse=reuse) as vs:
initial_dim = 64
""" CONV BLOCK 1 """
d_h0 = dis_block_2d(video, 3, initial_dim, 'block1', reuse=reuse)
""" CONV BLOCK 2 """
d_h1 = dis_block_2d(d_h0,
initial_dim,
initial_dim * 2,
'block2',
reuse=reuse)
""" CONV BLOCK 3 """
d_h2 = dis_block_2d(d_h1,
initial_dim * 2,
initial_dim * 4,
'block3',
reuse=reuse)
""" CONV BLOCK 4 """
d_h3 = dis_block_2d(d_h2,
initial_dim * 4,
initial_dim * 8,
'block4',
reuse=reuse)
""" CONV BLOCK 5 """
d_h4 = dis_block_2d(d_h3,
initial_dim * 8,
1,
'block5',
reuse=reuse,
normalize=False)
""" LINEAR BLOCK """
d_h5 = linear(tf.reshape(d_h4, [self.batch_size, -1]), 1)
variables = tf.contrib.framework.get_variables(vs)
return d_h5, variables
def discriminator(self, video, reuse=False):
with tf.variable_scope('d_', reuse=reuse) as vs:
initial_dim = self.crop_size
video = tf.reshape(video, [self.batch_size, self.frame_size, self.crop_size, self.crop_size, self.channels])
d_h0 = dis_block(video, self.channels, initial_dim, 'block1', reuse=reuse, ddd=True)
d_h1 = dis_block(d_h0, initial_dim, initial_dim * 2, 'block2', reuse=reuse, ddd=True)
d_h2 = dis_block(d_h1, initial_dim * 2, initial_dim * 4, 'block3', reuse=reuse, ddd=True)
d_h3 = dis_block(d_h2, initial_dim * 4, initial_dim * 8, 'block4', reuse=reuse, ddd=True)
d_h4 = dis_block(d_h3, initial_dim * 8, 1, 'block5', reuse=reuse, normalize=False, ddd=True)
d_h5 = linear(tf.reshape(d_h4, [self.batch_size, -1]), 1)
variables = tf.contrib.framework.get_variables(vs)
return d_h5, variables
def generator(self, z):
with tf.variable_scope('g_') as vs:
""" LINEAR BLOCK """
self.z_, _, _ = linear(z, 512 * 4 * 4, 'g_f_h0_lin',
with_w=True) #512 * 4 * 4 * 2
self.fg_h0 = tf.reshape(self.z_,
[-1, 4, 4, 512]) #[-1, 2, 4, 4, 512]
self.fg_h0 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h0, scope='g_f_bn0'),
name='g_f_relu0')
add_activation_summary(self.fg_h0)
""" CONV BLOCK 1 """
self.fg_h1 = conv2d_transpose(self.fg_h0,
512, [self.batch_size, 8, 8, 256],
name='g_f_h1') # 4 frames
self.fg_h1 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h1, scope='g_f_bn1'),
name='g_f_relu1')
add_activation_summary(self.fg_h1)
""" CONV BLOCK 2 """
self.fg_h2 = conv2d_transpose(self.fg_h1,
256, [self.batch_size, 16, 16, 128],
name='g_f_h2') # 8 frames
self.fg_h2 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h2, scope='g_f_bn2'),
name='g_f_relu2')
add_activation_summary(self.fg_h2)
""" CONV BLOCK 3 """
self.fg_h3 = conv2d_transpose(self.fg_h2,
128, [self.batch_size, 32, 32, 64],
name='g_f_h3') # 16 frames
self.fg_h3 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h3, scope='g_f_bn3'),
name='g_f_relu3')
add_activation_summary(self.fg_h3)
""" CONV BLOCK 4 """
self.fg_h4 = conv2d_transpose(self.fg_h3,
64, [self.batch_size, 64, 64, 32],
name='g_f_h4') # 32 frames
self.fg_h4 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h4, scope='g_f_bn4'),
name='g_f_relu4')
""" CONV BLOCK 5 """
self.fg_h5 = conv2d_transpose(self.fg_h4,
32, [self.batch_size, 128, 128, 3],
name='g_f_h5')
self.fg_fg = tf.nn.tanh(self.fg_h5, name='g_f_actvcation')
variables = tf.contrib.framework.get_variables(vs)
return self.fg_fg, variables
def encoder(self,x, is_training=True, reuse=False):
with tf.variable_scope("encoder", reuse=reuse):
if self.verbose: print(x.shape)
# Encoder Space
net = layers.flatten(x)
if self.verbose: print(net.shape,": Flatten")
# Latent Space
net = layers.linear(net, self.latent_dim, scope = 'en_fc1',
w_initializer = self.w_initializer,
b_initializer = self.b_initializer)
net = tf.nn.relu(net, name = "main_out")
if self.verbose: print(net.shape)
return net
def __call__(self, inputs, attrs, training=True, batch_size=100):
if training == False:
self.batch_size = 10
print('batchsize', batch_size)
with tf.variable_scope(self.name, reuse=self.reuse):
with tf.variable_scope('fc1'):
#w = self.input_shape[0] // (2 ** 3)
#x = tf.concat([inputs, attrs], axis=-1)
x = inputs
self.z_, _, _ = linear(x,
512 * 4 * 4,
'g_f_h0_lin',
with_w=True) # 4*4
self.fg_h0 = tf.reshape(self.z_, [-1, 4, 4, 512])
self.fg_h0 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h0, scope='g_f_bn0'),
name='g_f_relu0')
'''
x = tf.layers.dense(x, w * w * 256)
x = tf.layers.batch_normalization(x, training=training)
x = tf.nn.relu(x)
x = tf.reshape(x, [-1, w, w, 256])
'''
with tf.variable_scope('conv1'):
self.fg_h1 = conv2d_transpose(self.fg_h0,
512, [batch_size, 8, 8, 256],
name='g_f_h1')
self.fg_h1 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h1, scope='g_f_bn1'),
name='g_f_relu1')
'''
x = tf.layers.conv2d_transpose(x, 256, (5, 5), (2, 2), 'same')
x = tf.layers.batch_normalization(x, training=training)
x = lrelu(x)
'''
with tf.variable_scope('conv2'):
self.fg_h2 = conv2d_transpose(self.fg_h1,
256, [batch_size, 16, 16, 128],
name='g_f_h2')
self.fg_h2 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h2, scope='g_f_bn2'),
name='g_f_relu2')
'''
x = tf.layers.conv2d_transpose(x, 128, (5, 5), (2, 2), 'same')
x = tf.layers.batch_normalization(x, training=training)
x = lrelu(x)
'''
with tf.variable_scope('conv3'):
self.fg_h3 = conv2d_transpose(self.fg_h2,
128, [batch_size, 32, 32, 64],
name='g_f_h3')
self.fg_h3 = tf.nn.relu(tf.contrib.layers.batch_norm(
self.fg_h3, scope='g_f_bn3'),
name='g_f_relu3')
'''
x = tf.layers.conv2d_transpose(x, 64, (5, 5), (2, 2), 'same')
x = tf.layers.batch_normalization(x, training=training)
x = lrelu(x)
'''
with tf.variable_scope('conv4'):
self.fg_h4 = conv2d_transpose(self.fg_h3,
64, [batch_size, 64, 64, 3],
name='g_f_h4')
self.fg_fg = tf.nn.tanh(self.fg_h4, name='g_f_actvcation')
'''
d = self.input_shape[2]
x = tf.layers.conv2d_transpose(x, d, (5, 5), (1, 1), 'same')
x = tf.tanh(x)
'''
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
self.reuse = True
return self.fg_fg
def __call__(self, inputs, training=True, reuse=False, batchsize=100):
self.batch_size = batchsize
if training == False:
self.batch_size = 10
with tf.variable_scope(self.name, reuse=tf.AUTO_REUSE):
initial_dim = 64
""" CONV BLOCK 1 """
d_h0 = dis_block_2d(inputs, 3, initial_dim, 'block1', reuse=reuse)
""" CONV BLOCK 2 """
d_h1 = dis_block_2d(d_h0,
initial_dim,
initial_dim * 2,
'block2',
reuse=reuse)
""" CONV BLOCK 3 """
d_h2 = dis_block_2d(d_h1,
initial_dim * 2,
initial_dim * 4,
'block3',
reuse=reuse)
""" CONV BLOCK 4 """
d_h3 = dis_block_2d(d_h2,
initial_dim * 4,
initial_dim * 8,
'block4',
reuse=reuse)
""" CONV BLOCK 5 """
d_h4 = dis_block_2d(d_h3,
initial_dim * 8,
1,
'block5',
reuse=reuse,
normalize=False)
print(d_h4.shape) #(batch*2*2*1)
""" LINEAR BLOCK """
f = tf.reshape(d_h4, [self.batch_size, -1]) #similar to wgantest
#(batch,1) d_h5
print("f", f.shape)
d_h5 = linear(tf.reshape(d_h4, [self.batch_size, 4]),
1) #batch_size =100 assign shape=2*2=4
y = d_h5 # original y is useless in wgan, use d_h5 instead
'''
#print("conv4",x.shape)
with tf.variable_scope('global_avg'):
x = tf.reduce_mean(x, axis=[1, 2])
#print("avg",x.shape)
with tf.variable_scope('fc1'):
f = tf.contrib.layers.flatten(x)
y = tf.layers.dense(f, 1)
'''
#print("y",y.shape)
#print("f",f.shape)
self.variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,
scope=self.name)
self.reuse = True
return y, f, d_h5
def decoder(self, x, is_training=True, reuse=False):
with tf.variable_scope("decoder", reuse=reuse):
net = layers.linear(x,
self.latent_dim << 1,
scope='de_fc1',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
net = layers.linear(net,
self.latent_dim << 2,
scope='de_fc2',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
out_dim = self.main_shape[1] * self.main_shape[
2] * self.main_shape[3]
net = layers.linear(net,
out_dim,
scope='de_fc3',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
net = tf.reshape(net, self.main_shape)
if self.verbose: print(net.shape)
# net = tf.keras.layers.Conv2DTranspose(filters = 16,
# kernel_size = [5,5],
# strides=4,
# padding='same',
# kernel_initializer='glorot_uniform')(net)
# if self.verbose: print(net.shape)
# net = tf.keras.layers.UpSampling2D((2, 2))(net)
# if self.verbose: print(net.shape)
net = tf.keras.layers.Conv2DTranspose(
filters=32,
kernel_size=[5, 5],
strides=2,
padding='same',
kernel_initializer='glorot_uniform')(net)
if self.verbose: print(net.shape)
# net = tf.keras.layers.UpSampling2D((2, 2))(net)
# if self.verbose: print(net.shape)
net = tf.keras.layers.Conv2DTranspose(
filters=3,
kernel_size=[5, 5],
strides=2,
padding='same',
kernel_initializer='glorot_uniform')(net)
if self.verbose: print(net.shape)
## net = tf.keras.layers.UpSampling2D((2, 2))(net)
# if self.verbose: print(net.shape)
net = tf.sigmoid(net, name='main_out')
return net
def encoder(self, x, is_training=True, reuse=False):
with tf.variable_scope("encoder", reuse=reuse):
if self.verbose: print(x.shape)
net = tf.keras.layers.Conv2D(
filters=32,
kernel_size=[5, 5],
strides=2,
padding='same',
kernel_initializer='glorot_uniform')(x)
if self.verbose: print(net.shape)
# net = tf.keras.layers.MaxPooling2D((2, 2), padding='same')(net)
# if self.verbose: print(net.shape)
net = tf.keras.layers.Conv2D(
filters=16,
kernel_size=[5, 5],
strides=2,
padding='same',
kernel_initializer='glorot_uniform')(net)
if self.verbose: print(net.shape)
# net = tf.keras.layers.MaxPooling2D((2, 2), padding='same')(net)
# if self.verbose: print(net.shape)
# net = tf.keras.layers.Conv2D(filters = 8,
# kernel_size = [5,5],
# strides = 4,
# padding = 'same',
# kernel_initializer='glorot_uniform')(net)
# if self.verbose: print(net.shape)
self.main_shape = [
-1,
int(net.shape[1]),
int(net.shape[2]),
int(net.shape[3])
] # will be used by the decoder
# net = tf.keras.layers.MaxPooling2D((2, 2), padding='same')(net)
# if self.verbose: print(net.shape)
net = layers.flatten(net)
if self.verbose: print(net.shape)
net = layers.linear(net,
self.latent_dim << 2,
scope='en_fc1',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
net = layers.linear(net,
self.latent_dim << 1,
scope='en_fc2',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.relu(net)
if self.verbose: print(net.shape)
net = layers.linear(net,
self.latent_dim,
scope='en_fc3',
w_initializer=self.w_initializer,
b_initializer=self.b_initializer)
net = tf.nn.relu(net, name='main_out')
if self.verbose: print(net.shape)
return net
