def discriminator_labeler(image, output_dim, config, reuse=None):
batch_size=tf.shape(image)[0]
with tf.variable_scope("disc_labeler",reuse=reuse) as vs:
dl_bn1 = batch_norm(name='dl_bn1')
dl_bn2 = batch_norm(name='dl_bn2')
dl_bn3 = batch_norm(name='dl_bn3')
h0 = lrelu(conv2d(image, config.df_dim, name='dl_h0_conv'))#16,32,32,64
h1 = lrelu(dl_bn1(conv2d(h0, config.df_dim*2, name='dl_h1_conv')))#16,16,16,128
h2 = lrelu(dl_bn2(conv2d(h1, config.df_dim*4, name='dl_h2_conv')))#16,16,16,248
h3 = lrelu(dl_bn3(conv2d(h2, config.df_dim*8, name='dl_h3_conv')))
dim3=np.prod(h3.get_shape().as_list()[1:])
h3_flat=tf.reshape(h3, [-1,dim3])
D_labels_logits = linear(h3_flat, output_dim, 'dl_h3_Label')
D_labels = tf.nn.sigmoid(D_labels_logits)
variables = tf.contrib.framework.get_variables(vs)
return D_labels, D_labels_logits, variables
python类batch_norm()的实例源码
def discriminator_gen_labeler(image, output_dim, config, reuse=None):
batch_size=tf.shape(image)[0]
with tf.variable_scope("disc_gen_labeler",reuse=reuse) as vs:
dl_bn1 = batch_norm(name='dl_bn1')
dl_bn2 = batch_norm(name='dl_bn2')
dl_bn3 = batch_norm(name='dl_bn3')
h0 = lrelu(conv2d(image, config.df_dim, name='dgl_h0_conv'))#16,32,32,64
h1 = lrelu(dl_bn1(conv2d(h0, config.df_dim*2, name='dgl_h1_conv')))#16,16,16,128
h2 = lrelu(dl_bn2(conv2d(h1, config.df_dim*4, name='dgl_h2_conv')))#16,16,16,248
h3 = lrelu(dl_bn3(conv2d(h2, config.df_dim*8, name='dgl_h3_conv')))
dim3=np.prod(h3.get_shape().as_list()[1:])
h3_flat=tf.reshape(h3, [-1,dim3])
D_labels_logits = linear(h3_flat, output_dim, 'dgl_h3_Label')
D_labels = tf.nn.sigmoid(D_labels_logits)
variables = tf.contrib.framework.get_variables(vs)
return D_labels, D_labels_logits,variables
def discriminator_on_z(image, config, reuse=None):
batch_size=tf.shape(image)[0]
with tf.variable_scope("disc_z_labeler",reuse=reuse) as vs:
dl_bn1 = batch_norm(name='dl_bn1')
dl_bn2 = batch_norm(name='dl_bn2')
dl_bn3 = batch_norm(name='dl_bn3')
h0 = lrelu(conv2d(image, config.df_dim, name='dzl_h0_conv'))#16,32,32,64
h1 = lrelu(dl_bn1(conv2d(h0, config.df_dim*2, name='dzl_h1_conv')))#16,16,16,128
h2 = lrelu(dl_bn2(conv2d(h1, config.df_dim*4, name='dzl_h2_conv')))#16,16,16,248
h3 = lrelu(dl_bn3(conv2d(h2, config.df_dim*8, name='dzl_h3_conv')))
dim3=np.prod(h3.get_shape().as_list()[1:])
h3_flat=tf.reshape(h3, [-1,dim3])
D_labels_logits = linear(h3_flat, config.z_dim, 'dzl_h3_Label')
D_labels = tf.nn.tanh(D_labels_logits)
variables = tf.contrib.framework.get_variables(vs)
return D_labels,variables
def discriminator(self, opts, input_, is_training,
prefix='DISCRIMINATOR', reuse=False):
"""Encoder function, suitable for simple toy experiments.
"""
num_filters = opts['d_num_filters']
with tf.variable_scope(prefix, reuse=reuse):
h0 = ops.conv2d(opts, input_, num_filters / 8, scope='h0_conv')
h0 = ops.batch_norm(opts, h0, is_training, reuse, scope='bn_layer1')
h0 = tf.nn.relu(h0)
h1 = ops.conv2d(opts, h0, num_filters / 4, scope='h1_conv')
h1 = ops.batch_norm(opts, h1, is_training, reuse, scope='bn_layer2')
h1 = tf.nn.relu(h1)
h2 = ops.conv2d(opts, h1, num_filters / 2, scope='h2_conv')
h2 = ops.batch_norm(opts, h2, is_training, reuse, scope='bn_layer3')
h2 = tf.nn.relu(h2)
h3 = ops.conv2d(opts, h2, num_filters, scope='h3_conv')
h3 = ops.batch_norm(opts, h3, is_training, reuse, scope='bn_layer4')
h3 = tf.nn.relu(h3)
# Already has NaNs!!
latent_mean = ops.linear(opts, h3, opts['latent_space_dim'], scope='h3_lin')
log_latent_sigmas = ops.linear(opts, h3, opts['latent_space_dim'], scope='h3_lin_sigma')
return latent_mean, log_latent_sigmas
def discriminator(self, opts, input_, is_training,
prefix='DISCRIMINATOR', reuse=False):
"""Discriminator function, suitable for simple toy experiments.
"""
num_filters = opts['d_num_filters']
with tf.variable_scope(prefix, reuse=reuse):
h0 = ops.conv2d(opts, input_, num_filters, scope='h0_conv')
h0 = ops.batch_norm(opts, h0, is_training, reuse, scope='bn_layer1')
h0 = ops.lrelu(h0)
h1 = ops.conv2d(opts, h0, num_filters * 2, scope='h1_conv')
h1 = ops.batch_norm(opts, h1, is_training, reuse, scope='bn_layer2')
h1 = ops.lrelu(h1)
h2 = ops.conv2d(opts, h1, num_filters * 4, scope='h2_conv')
h2 = ops.batch_norm(opts, h2, is_training, reuse, scope='bn_layer3')
h2 = ops.lrelu(h2)
h3 = ops.linear(opts, h2, 1, scope='h3_lin')
return h3
def generator(self, opts, noise, is_training, reuse=False):
with tf.variable_scope("GENERATOR", reuse=reuse):
h0 = ops.linear(opts, noise, 100, scope='h0_lin')
h0 = ops.batch_norm(opts, h0, is_training, reuse, scope='bn_layer1', scale=False)
h0 = tf.nn.softplus(h0)
h1 = ops.linear(opts, h0, 100, scope='h1_lin')
h1 = ops.batch_norm(opts, h1, is_training, reuse, scope='bn_layer2', scale=False)
h1 = tf.nn.softplus(h1)
h2 = ops.linear(opts, h1, 28 * 28, scope='h2_lin')
# h2 = ops.batch_norm(opts, h2, is_training, reuse, scope='bn_layer3')
h2 = tf.reshape(h2, [-1, 28, 28, 1])
if opts['input_normalize_sym']:
return tf.nn.tanh(h2)
else:
return tf.nn.sigmoid(h2)
def inception_v3_parameters(weight_decay=0.00004, stddev=0.1,
batch_norm_decay=0.9997, batch_norm_epsilon=0.001):
"""Yields the scope with the default parameters for inception_v3.
Args:
weight_decay: the weight decay for weights variables.
stddev: standard deviation of the truncated guassian weight distribution.
batch_norm_decay: decay for the moving average of batch_norm momentums.
batch_norm_epsilon: small float added to variance to avoid dividing by zero.
Yields:
a arg_scope with the parameters needed for inception_v3.
"""
# Set weight_decay for weights in Conv and FC layers.
with scopes.arg_scope([ops.conv2d, ops.fc],
weight_decay=weight_decay):
# Set stddev, activation and parameters for batch_norm.
with scopes.arg_scope([ops.conv2d],
stddev=stddev,
activation=tf.nn.relu,
batch_norm_params={
'decay': batch_norm_decay,
'epsilon': batch_norm_epsilon}) as arg_scope:
yield arg_scope
def discriminator(self, opts, input_, is_training,
prefix='DISCRIMINATOR', reuse=False):
shape = tf.shape(input_)
num = shape[0]
with tf.variable_scope(prefix, reuse=reuse):
h0 = input_
h0 = tf.add(h0, tf.random_normal(shape, stddev=0.3))
h0 = ops.linear(opts, h0, 1000, scope='h0_linear')
# h0 = ops.batch_norm(opts, h0, is_training, reuse, scope='bn_layer1')
h0 = tf.nn.relu(h0)
h1 = tf.add(h0, tf.random_normal([num, 1000], stddev=0.5))
h1 = ops.linear(opts, h1, 500, scope='h1_linear')
# h1 = ops.batch_norm(opts, h1, is_training, reuse, scope='bn_layer2')
h1 = tf.nn.relu(h1)
h2 = tf.add(h1, tf.random_normal([num, 500], stddev=0.5))
h2 = ops.linear(opts, h2, 250, scope='h2_linear')
# h2 = ops.batch_norm(opts, h2, is_training, reuse, scope='bn_layer3')
h2 = tf.nn.relu(h2)
h3 = tf.add(h2, tf.random_normal([num, 250], stddev=0.5))
h3 = ops.linear(opts, h3, 250, scope='h3_linear')
# h3 = ops.batch_norm(opts, h3, is_training, reuse, scope='bn_layer4')
h3 = tf.nn.relu(h3)
h4 = tf.add(h3, tf.random_normal([num, 250], stddev=0.5))
h4 = ops.linear(opts, h4, 250, scope='h4_linear')
# h4 = ops.batch_norm(opts, h4, is_training, reuse, scope='bn_layer5')
h4 = tf.nn.relu(h4)
h5 = ops.linear(opts, h4, 10, scope='h5_linear')
return h5, h3
def generator(self, opts, noise, is_training=False, reuse=False, keep_prob=1.):
""" Decoder actually.
"""
output_shape = self._data.data_shape
num_units = opts['g_num_filters']
with tf.variable_scope("GENERATOR", reuse=reuse):
# if not opts['convolutions']:
if opts['g_arch'] == 'mlp':
layer_x = noise
for i in range(opts['g_num_layers']):
layer_x = ops.linear(opts, layer_x, num_units, 'h%d_lin' % i)
layer_x = tf.nn.relu(layer_x)
if opts['batch_norm']:
layer_x = ops.batch_norm(
opts, layer_x, is_training, reuse, scope='bn%d' % i)
out = ops.linear(opts, layer_x, np.prod(output_shape), 'h%d_lin' % (i + 1))
out = tf.reshape(out, [-1] + list(output_shape))
if opts['input_normalize_sym']:
return tf.nn.tanh(out)
else:
return tf.nn.sigmoid(out)
elif opts['g_arch'] in ['dcgan', 'dcgan_mod']:
return self.dcgan_like_arch(opts, noise, is_training, reuse, keep_prob)
elif opts['g_arch'] == 'conv_up_res':
return self.conv_up_res(opts, noise, is_training, reuse, keep_prob)
elif opts['g_arch'] == 'ali':
return self.ali_deconv(opts, noise, is_training, reuse, keep_prob)
elif opts['g_arch'] == 'began':
return self.began_dec(opts, noise, is_training, reuse, keep_prob)
else:
raise ValueError('%s unknown' % opts['g_arch'])
def encoder(self, opts, input_, is_training=False, reuse=False, keep_prob=1.):
if opts['e_add_noise']:
def add_noise(x):
shape = tf.shape(x)
return x + tf.truncated_normal(shape, 0.0, 0.01)
def do_nothing(x):
return x
input_ = tf.cond(is_training, lambda: add_noise(input_), lambda: do_nothing(input_))
num_units = opts['e_num_filters']
num_layers = opts['e_num_layers']
with tf.variable_scope("ENCODER", reuse=reuse):
if not opts['convolutions']:
hi = input_
for i in range(num_layers):
hi = ops.linear(opts, hi, num_units, scope='h%d_lin' % i)
if opts['batch_norm']:
hi = ops.batch_norm(opts, hi, is_training, reuse, scope='bn%d' % i)
hi = tf.nn.relu(hi)
if opts['e_is_random']:
latent_mean = ops.linear(
opts, hi, opts['latent_space_dim'], 'h%d_lin' % (i + 1))
log_latent_sigmas = ops.linear(
opts, hi, opts['latent_space_dim'], 'h%d_lin_sigma' % (i + 1))
return latent_mean, log_latent_sigmas
else:
return ops.linear(opts, hi, opts['latent_space_dim'], 'h%d_lin' % (i + 1))
elif opts['e_arch'] == 'dcgan':
return self.dcgan_encoder(opts, input_, is_training, reuse, keep_prob)
elif opts['e_arch'] == 'ali':
return self.ali_encoder(opts, input_, is_training, reuse, keep_prob)
elif opts['e_arch'] == 'began':
return self.began_encoder(opts, input_, is_training, reuse, keep_prob)
else:
raise ValueError('%s Unknown' % opts['e_arch'])
def generator(hparams, z, scope_name, train, reuse):
with tf.variable_scope(scope_name) as scope:
if reuse:
scope.reuse_variables()
output_size = 64
s = output_size
s2, s4, s8, s16 = int(s/2), int(s/4), int(s/8), int(s/16)
g_bn0 = ops.batch_norm(name='g_bn0')
g_bn1 = ops.batch_norm(name='g_bn1')
g_bn2 = ops.batch_norm(name='g_bn2')
g_bn3 = ops.batch_norm(name='g_bn3')
# project `z` and reshape
h0 = tf.reshape(ops.linear(z, hparams.gf_dim*8*s16*s16, 'g_h0_lin'), [-1, s16, s16, hparams.gf_dim * 8])
h0 = tf.nn.relu(g_bn0(h0, train=train))
h1 = ops.deconv2d(h0, [hparams.batch_size, s8, s8, hparams.gf_dim*4], name='g_h1')
h1 = tf.nn.relu(g_bn1(h1, train=train))
h2 = ops.deconv2d(h1, [hparams.batch_size, s4, s4, hparams.gf_dim*2], name='g_h2')
h2 = tf.nn.relu(g_bn2(h2, train=train))
h3 = ops.deconv2d(h2, [hparams.batch_size, s2, s2, hparams.gf_dim*1], name='g_h3')
h3 = tf.nn.relu(g_bn3(h3, train=train))
h4 = ops.deconv2d(h3, [hparams.batch_size, s, s, hparams.c_dim], name='g_h4')
x_gen = tf.nn.tanh(h4)
return x_gen
def discriminator(hparams, x, scope_name, train, reuse):
with tf.variable_scope(scope_name) as scope:
if reuse:
scope.reuse_variables()
d_bn1 = ops.batch_norm(name='d_bn1')
d_bn2 = ops.batch_norm(name='d_bn2')
d_bn3 = ops.batch_norm(name='d_bn3')
h0 = ops.lrelu(ops.conv2d(x, hparams.df_dim, name='d_h0_conv'))
h1 = ops.conv2d(h0, hparams.df_dim*2, name='d_h1_conv')
h1 = ops.lrelu(d_bn1(h1, train=train))
h2 = ops.conv2d(h1, hparams.df_dim*4, name='d_h2_conv')
h2 = ops.lrelu(d_bn2(h2, train=train))
h3 = ops.conv2d(h2, hparams.df_dim*8, name='d_h3_conv')
h3 = ops.lrelu(d_bn3(h3, train=train))
h4 = ops.linear(tf.reshape(h3, [hparams.batch_size, -1]), 1, 'd_h3_lin')
d_logit = h4
d = tf.nn.sigmoid(d_logit)
return d, d_logit
def generator(hparams, z, train, reuse):
if reuse:
tf.get_variable_scope().reuse_variables()
output_size = 64
s = output_size
s2, s4, s8, s16 = int(s/2), int(s/4), int(s/8), int(s/16)
g_bn0 = ops.batch_norm(name='g_bn0')
g_bn1 = ops.batch_norm(name='g_bn1')
g_bn2 = ops.batch_norm(name='g_bn2')
g_bn3 = ops.batch_norm(name='g_bn3')
# project `z` and reshape
h0 = tf.reshape(ops.linear(z, hparams.gf_dim*8*s16*s16, 'g_h0_lin'), [-1, s16, s16, hparams.gf_dim * 8])
h0 = tf.nn.relu(g_bn0(h0, train=train))
h1 = ops.deconv2d(h0, [hparams.batch_size, s8, s8, hparams.gf_dim*4], name='g_h1')
h1 = tf.nn.relu(g_bn1(h1, train=train))
h2 = ops.deconv2d(h1, [hparams.batch_size, s4, s4, hparams.gf_dim*2], name='g_h2')
h2 = tf.nn.relu(g_bn2(h2, train=train))
h3 = ops.deconv2d(h2, [hparams.batch_size, s2, s2, hparams.gf_dim*1], name='g_h3')
h3 = tf.nn.relu(g_bn3(h3, train=train))
h4 = ops.deconv2d(h3, [hparams.batch_size, s, s, hparams.c_dim], name='g_h4')
x_gen = tf.nn.tanh(h4)
return x_gen
def discriminator(hparams, x, train, reuse):
if reuse:
tf.get_variable_scope().reuse_variables()
d_bn1 = ops.batch_norm(name='d_bn1')
d_bn2 = ops.batch_norm(name='d_bn2')
d_bn3 = ops.batch_norm(name='d_bn3')
h0 = ops.lrelu(ops.conv2d(x, hparams.df_dim, name='d_h0_conv'))
h1 = ops.conv2d(h0, hparams.df_dim*2, name='d_h1_conv')
h1 = ops.lrelu(d_bn1(h1, train=train))
h2 = ops.conv2d(h1, hparams.df_dim*4, name='d_h2_conv')
h2 = ops.lrelu(d_bn2(h2, train=train))
h3 = ops.conv2d(h2, hparams.df_dim*8, name='d_h3_conv')
h3 = ops.lrelu(d_bn3(h3, train=train))
h4 = ops.linear(tf.reshape(h3, [hparams.batch_size, -1]), 1, 'd_h3_lin')
d_logit = h4
d = tf.nn.sigmoid(d_logit)
return d, d_logit
def GeneratorCNN( z, config, reuse=None):
'''
maps z to a 64x64 images with values in [-1,1]
uses batch normalization internally
'''
#trying to get around batch_size like this:
batch_size=tf.shape(z)[0]
#batch_size=tf.placeholder_with_default(64,[],'bs')
with tf.variable_scope("generator",reuse=reuse) as vs:
g_bn0 = batch_norm(name='g_bn0')
g_bn1 = batch_norm(name='g_bn1')
g_bn2 = batch_norm(name='g_bn2')
g_bn3 = batch_norm(name='g_bn3')
s_h, s_w = config.gf_dim, config.gf_dim#64,64
s_h2, s_w2 = conv_out_size_same(s_h, 2), conv_out_size_same(s_w, 2)
s_h4, s_w4 = conv_out_size_same(s_h2, 2), conv_out_size_same(s_w2, 2)
s_h8, s_w8 = conv_out_size_same(s_h4, 2), conv_out_size_same(s_w4, 2)
s_h16, s_w16 = conv_out_size_same(s_h8, 2), conv_out_size_same(s_w8, 2)
# project `z` and reshape
z_, self_h0_w, self_h0_b = linear(
z, config.gf_dim*8*s_h16*s_w16, 'g_h0_lin', with_w=True)
self_h0 = tf.reshape(
z_, [-1, s_h16, s_w16, config.gf_dim * 8])
h0 = tf.nn.relu(g_bn0(self_h0))
h1, h1_w, h1_b = deconv2d(
h0, [batch_size, s_h8, s_w8, config.gf_dim*4], name='g_h1', with_w=True)
h1 = tf.nn.relu(g_bn1(h1))
h2, h2_w, h2_b = deconv2d(
h1, [batch_size, s_h4, s_w4, config.gf_dim*2], name='g_h2', with_w=True)
h2 = tf.nn.relu(g_bn2(h2))
h3, h3_w, h3_b = deconv2d(
h2, [batch_size, s_h2, s_w2, config.gf_dim*1], name='g_h3', with_w=True)
h3 = tf.nn.relu(g_bn3(h3))
h4, h4_w, h4_b = deconv2d(
h3, [batch_size, s_h, s_w, config.c_dim], name='g_h4', with_w=True)
out=tf.nn.tanh(h4)
variables = tf.contrib.framework.get_variables(vs)
return out, variables
def DiscriminatorCNN(image, config, reuse=None):
'''
Discriminator for GAN model.
image : batch_size x 64x64x3 image
config : see causal_dcgan/config.py
reuse : pass True if not calling for first time
returns: probabilities(real)
: logits(real)
: first layer activation used to estimate z from
: variables list
'''
with tf.variable_scope("discriminator",reuse=reuse) as vs:
d_bn1 = batch_norm(name='d_bn1')
d_bn2 = batch_norm(name='d_bn2')
d_bn3 = batch_norm(name='d_bn3')
if not config.stab_proj:
h0 = lrelu(conv2d(image, config.df_dim, name='d_h0_conv'))#16,32,32,64
else:#method to restrict disc from winning
#I think this is equivalent to just not letting disc optimize first layer
#and also removing nonlinearity
#k_h=5, k_w=5, d_h=2, d_w=2, stddev=0.02,
#paper used 8x8 kernel, but I'm using 5x5 because it is more similar to my achitecture
#n_projs=config.df_dim#64 instead of 32 in paper
n_projs=config.n_stab_proj#64 instead of 32 in paper
print("WARNING:STAB_PROJ active, using ",n_projs," projections")
w_proj = tf.get_variable('w_proj', [5, 5, image.get_shape()[-1],n_projs],
initializer=tf.truncated_normal_initializer(stddev=0.02),trainable=False)
conv = tf.nn.conv2d(image, w_proj, strides=[1, 2, 2, 1], padding='SAME')
b_proj = tf.get_variable('b_proj', [n_projs],#does nothing
initializer=tf.constant_initializer(0.0),trainable=False)
h0=tf.nn.bias_add(conv,b_proj)
h1_ = lrelu(d_bn1(conv2d(h0, config.df_dim*2, name='d_h1_conv')))#16,16,16,128
h1 = add_minibatch_features(h1_, config.df_dim)
h2 = lrelu(d_bn2(conv2d(h1, config.df_dim*4, name='d_h2_conv')))#16,16,16,248
h3 = lrelu(d_bn3(conv2d(h2, config.df_dim*8, name='d_h3_conv')))
#print('h3shape: ',h3.get_shape().as_list())
#print('8df_dim:',config.df_dim*8)
#dim3=tf.reduce_prod(tf.shape(h3)[1:])
dim3=np.prod(h3.get_shape().as_list()[1:])
h3_flat=tf.reshape(h3, [-1,dim3])
h4 = linear(h3_flat, 1, 'd_h3_lin')
prob=tf.nn.sigmoid(h4)
variables = tf.contrib.framework.get_variables(vs,collection=tf.GraphKeys.TRAINABLE_VARIABLES)
return prob, h4, h1_, variables
def __call__(self, z, y):
"""
:param z: 2D [batch_size, z_dim]
:param y: 2D [batch_size, y_dim]
:return:
"""
batch_size, y_dim = y.get_shape().as_list()
batch_size_, z_dim = z.get_shape().as_list()
assert batch_size == batch_size_
h1_size = int(self._output_size / 4)
h2_size = int(self._output_size / 2)
with tf.variable_scope(self._name):
yb = tf.reshape(y, shape=[-1, 1, 1, y_dim]) # (100, 1, 1, 10)
z = tf.concat([z, y], axis=1) # (batch_size=100, y_dim+z_dim=110)
h0 = tf.nn.relu(
ops.batch_norm(
ops.fc(z, self._fc_dim, reuse=self._reuse, name='g_fc0'),
is_training=self._is_training,
reuse=self._reuse,
name_scope='g_bn0'
)
)
h0 = tf.concat([h0, y], axis=1) # (batch_size=100, fc_dim+y_dim=794)
h1 = tf.nn.relu(
ops.batch_norm(
ops.fc(h0, self._ngf*h1_size*h1_size, reuse=self._reuse, name='g_fc1'),
is_training=self._is_training,
reuse=self._reuse,
name_scope='g_bn1'
)
)
h1 = tf.reshape(h1, shape=[-1, h1_size, h1_size, self._ngf])
h1 = tf.concat([h1, yb*tf.ones([batch_size, h1_size, h1_size, y_dim])], axis=3) # (100, 7, 7, 522)
h2 = tf.nn.relu(
ops.batch_norm(
ops.deconv2d(h1, self._ngf, reuse=self._reuse, name='g_conv2'),
is_training=self._is_training,
reuse=self._reuse,
name_scope='g_bn2'
)
)
h2 = tf.concat([h2, yb*tf.ones([batch_size, h2_size, h2_size, y_dim])], axis=3) # (100, 14, 14, 522)
h3 = tf.nn.sigmoid(
ops.deconv2d(h2, self._channel_dim, reuse=self._reuse, name='g_conv3')
) # TODO DIMENSION??? SHRINK
self._reuse = True
return h3 # (100, 28, 28, 1)
def __call__(self, input_, y):
batch_size, y_dim = y.get_shape().as_list()
batch_size_, height, width, c_dim = input_.get_shape().as_list()
assert batch_size == batch_size_
assert (self._input_size == width) and (self._input_size == height)
h0_size = int(self._input_size / 2)
h1_size = int(self._input_size / 4)
with tf.variable_scope(self._name):
yb = tf.reshape(y, shape=[-1, 1, 1, y_dim])
# dim(x) = (100, 28, 28, 11)
x = tf.concat([input_, yb*tf.ones([batch_size, self._input_size, self._input_size, y_dim])], axis=3)
h0 = ops.leaky_relu(
ops.conv2d(x, c_dim + y_dim, reuse=self._reuse, name='d_conv0'),
slope=0.2
)
h0 = tf.concat([h0, yb*tf.ones([batch_size, h0_size, h0_size, y_dim])], axis=3) # (100, 14, 14, 21)
h1 = ops.leaky_relu(
ops.batch_norm(
ops.conv2d(h0, c_dim + self._ndf, reuse=self._reuse, name='d_conv1'),
is_training=self._is_training,
reuse=self._reuse,
name_scope='d_bn1'
),
slope=0.2
)
h1 = tf.reshape(h1, [batch_size, h1_size*h1_size*(c_dim+self._ndf)])
h1 = tf.concat([h1, y], axis=1) # (100, 28*28*(1+64)+10)
h2 = ops.leaky_relu(
ops.batch_norm(
ops.fc(h1, self._fc_dim, reuse=self._reuse, name='d_fc2'),
is_training=self._is_training,
reuse=self._reuse,
name_scope='d_bn2'
),
slope=0.2
)
h2 = tf.concat([h2, y], axis=1) # (100, 794)
# h3 = tf.nn.sigmoid(
h3 = ops.fc(h2, 1, reuse=self._reuse, name='d_fc3')
# )
self._reuse = True
return h3 # (100, 1)
def generator(self, opts, noise, is_training, reuse=False):
"""Generator function, suitable for simple picture experiments.
Args:
noise: [num_points, dim] array, where dim is dimensionality of the
latent noise space.
is_training: bool, defines whether to use batch_norm in the train
or test mode.
Returns:
[num_points, dim1, dim2, dim3] array, where the first coordinate
indexes the points, which all are of the shape (dim1, dim2, dim3).
"""
output_shape = self._data.data_shape # (dim1, dim2, dim3)
# Computing the number of noise vectors on-the-go
dim1 = tf.shape(noise)[0]
num_filters = opts['g_num_filters']
with tf.variable_scope("GENERATOR", reuse=reuse):
height = output_shape[0] / 4
width = output_shape[1] / 4
h0 = ops.linear(opts, noise, num_filters * height * width,
scope='h0_lin')
h0 = tf.reshape(h0, [-1, height, width, num_filters])
h0 = ops.batch_norm(opts, h0, is_training, reuse, scope='bn_layer1')
# h0 = tf.nn.relu(h0)
h0 = ops.lrelu(h0)
_out_shape = [dim1, height * 2, width * 2, num_filters / 2]
# for 28 x 28 does 7 x 7 --> 14 x 14
h1 = ops.deconv2d(opts, h0, _out_shape, scope='h1_deconv')
h1 = ops.batch_norm(opts, h1, is_training, reuse, scope='bn_layer2')
# h1 = tf.nn.relu(h1)
h1 = ops.lrelu(h1)
_out_shape = [dim1, height * 4, width * 4, num_filters / 4]
# for 28 x 28 does 14 x 14 --> 28 x 28
h2 = ops.deconv2d(opts, h1, _out_shape, scope='h2_deconv')
h2 = ops.batch_norm(opts, h2, is_training, reuse, scope='bn_layer3')
# h2 = tf.nn.relu(h2)
h2 = ops.lrelu(h2)
_out_shape = [dim1] + list(output_shape)
# data_shape[0] x data_shape[1] x ? -> data_shape
h3 = ops.deconv2d(opts, h2, _out_shape,
d_h=1, d_w=1, scope='h3_deconv')
h3 = ops.batch_norm(opts, h3, is_training, reuse, scope='bn_layer4')
if opts['input_normalize_sym']:
return tf.nn.tanh(h3)
else:
return tf.nn.sigmoid(h3)
def dcgan_like_arch(self, opts, noise, is_training, reuse, keep_prob):
output_shape = self._data.data_shape
num_units = opts['g_num_filters']
batch_size = tf.shape(noise)[0]
num_layers = opts['g_num_layers']
if opts['g_arch'] == 'dcgan':
height = output_shape[0] / 2**num_layers
width = output_shape[1] / 2**num_layers
elif opts['g_arch'] == 'dcgan_mod':
height = output_shape[0] / 2**(num_layers-1)
width = output_shape[1] / 2**(num_layers-1)
else:
assert False
h0 = ops.linear(
opts, noise, num_units * height * width, scope='h0_lin')
h0 = tf.reshape(h0, [-1, height, width, num_units])
h0 = tf.nn.relu(h0)
layer_x = h0
for i in xrange(num_layers-1):
scale = 2**(i+1)
if opts['g_stride1_deconv']:
# Sylvain, I'm worried about this part!
_out_shape = [batch_size, height * scale / 2,
width * scale / 2, num_units / scale * 2]
layer_x = ops.deconv2d(
opts, layer_x, _out_shape, d_h=1, d_w=1,
scope='h%d_deconv_1x1' % i)
layer_x = tf.nn.relu(layer_x)
_out_shape = [batch_size, height * scale, width * scale, num_units / scale]
layer_x = ops.deconv2d(opts, layer_x, _out_shape, scope='h%d_deconv' % i)
if opts['batch_norm']:
layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bn%d' % i)
layer_x = tf.nn.relu(layer_x)
if opts['dropout']:
_keep_prob = tf.minimum(
1., 0.9 - (0.9 - keep_prob) * float(i + 1) / (num_layers - 1))
layer_x = tf.nn.dropout(layer_x, _keep_prob)
_out_shape = [batch_size] + list(output_shape)
if opts['g_arch'] == 'dcgan':
last_h = ops.deconv2d(
opts, layer_x, _out_shape, scope='hlast_deconv')
elif opts['g_arch'] == 'dcgan_mod':
last_h = ops.deconv2d(
opts, layer_x, _out_shape, d_h=1, d_w=1, scope='hlast_deconv')
else:
assert False
if opts['input_normalize_sym']:
return tf.nn.tanh(last_h)
else:
return tf.nn.sigmoid(last_h)
def conv_up_res(self, opts, noise, is_training, reuse, keep_prob):
output_shape = self._data.data_shape
num_units = opts['g_num_filters']
batch_size = tf.shape(noise)[0]
num_layers = opts['g_num_layers']
data_height = output_shape[0]
data_width = output_shape[1]
data_channels = output_shape[2]
height = data_height / 2**num_layers
width = data_width / 2**num_layers
h0 = ops.linear(
opts, noise, num_units * height * width, scope='h0_lin')
h0 = tf.reshape(h0, [-1, height, width, num_units])
h0 = tf.nn.relu(h0)
layer_x = h0
for i in xrange(num_layers-1):
layer_x = tf.image.resize_nearest_neighbor(layer_x, (2 * height, 2 * width))
layer_x = ops.conv2d(opts, layer_x, num_units / 2, d_h=1, d_w=1, scope='conv2d_%d' % i)
height *= 2
width *= 2
num_units /= 2
if opts['g_3x3_conv'] > 0:
before = layer_x
for j in range(opts['g_3x3_conv']):
layer_x = ops.conv2d(opts, layer_x, num_units, d_h=1, d_w=1,
scope='conv2d_3x3_%d_%d' % (i, j),
conv_filters_dim=3)
layer_x = tf.nn.relu(layer_x)
layer_x += before # Residual connection.
if opts['batch_norm']:
layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bn%d' % i)
layer_x = tf.nn.relu(layer_x)
if opts['dropout']:
_keep_prob = tf.minimum(
1., 0.9 - (0.9 - keep_prob) * float(i + 1) / (num_layers - 1))
layer_x = tf.nn.dropout(layer_x, _keep_prob)
layer_x = tf.image.resize_nearest_neighbor(layer_x, (2 * height, 2 * width))
layer_x = ops.conv2d(opts, layer_x, data_channels, d_h=1, d_w=1, scope='last_conv2d_%d' % i)
if opts['input_normalize_sym']:
return tf.nn.tanh(layer_x)
else:
return tf.nn.sigmoid(layer_x)
def ali_deconv(self, opts, noise, is_training, reuse, keep_prob):
output_shape = self._data.data_shape
batch_size = tf.shape(noise)[0]
noise_size = int(noise.get_shape()[1])
data_height = output_shape[0]
data_width = output_shape[1]
data_channels = output_shape[2]
noise = tf.reshape(noise, [-1, 1, 1, noise_size])
num_units = opts['g_num_filters']
layer_params = []
layer_params.append([4, 1, num_units])
layer_params.append([4, 2, num_units / 2])
layer_params.append([4, 1, num_units / 4])
layer_params.append([4, 2, num_units / 8])
layer_params.append([5, 1, num_units / 8])
# For convolution: (n - k) / stride + 1 = s
# For transposed: (s - 1) * stride + k = n
layer_x = noise
height = 1
width = 1
for i, (kernel, stride, channels) in enumerate(layer_params):
height = (height - 1) * stride + kernel
width = height
layer_x = ops.deconv2d(
opts, layer_x, [batch_size, height, width, channels], d_h=stride, d_w=stride,
scope='h%d_deconv' % i, conv_filters_dim=kernel, padding='VALID')
if opts['batch_norm']:
layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bn%d' % i)
layer_x = ops.lrelu(layer_x, 0.1)
assert height == data_height
assert width == data_width
# Then two 1x1 convolutions.
layer_x = ops.conv2d(opts, layer_x, num_units / 8, d_h=1, d_w=1, scope='conv2d_1x1', conv_filters_dim=1)
if opts['batch_norm']:
layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bnlast')
layer_x = ops.lrelu(layer_x, 0.1)
layer_x = ops.conv2d(opts, layer_x, data_channels, d_h=1, d_w=1, scope='conv2d_1x1_2', conv_filters_dim=1)
if opts['input_normalize_sym']:
return tf.nn.tanh(layer_x)
else:
return tf.nn.sigmoid(layer_x)
def ali_encoder(self, opts, input_, is_training=False, reuse=False, keep_prob=1.):
num_units = opts['e_num_filters']
layer_params = []
layer_params.append([5, 1, num_units / 8])
layer_params.append([4, 2, num_units / 4])
layer_params.append([4, 1, num_units / 2])
layer_params.append([4, 2, num_units])
layer_params.append([4, 1, num_units * 2])
# For convolution: (n - k) / stride + 1 = s
# For transposed: (s - 1) * stride + k = n
layer_x = input_
height = int(layer_x.get_shape()[1])
width = int(layer_x.get_shape()[2])
assert height == width
for i, (kernel, stride, channels) in enumerate(layer_params):
height = (height - kernel) / stride + 1
width = height
# print((height, width))
layer_x = ops.conv2d(
opts, layer_x, channels, d_h=stride, d_w=stride,
scope='h%d_conv' % i, conv_filters_dim=kernel, padding='VALID')
if opts['batch_norm']:
layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bn%d' % i)
layer_x = ops.lrelu(layer_x, 0.1)
assert height == 1
assert width == 1
# Then two 1x1 convolutions.
layer_x = ops.conv2d(opts, layer_x, num_units * 2, d_h=1, d_w=1, scope='conv2d_1x1', conv_filters_dim=1)
if opts['batch_norm']:
layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bnlast')
layer_x = ops.lrelu(layer_x, 0.1)
layer_x = ops.conv2d(opts, layer_x, num_units / 2, d_h=1, d_w=1, scope='conv2d_1x1_2', conv_filters_dim=1)
if opts['e_is_random']:
latent_mean = ops.linear(
opts, layer_x, opts['latent_space_dim'], scope='hlast_lin')
log_latent_sigmas = ops.linear(
opts, layer_x, opts['latent_space_dim'], scope='hlast_lin_sigma')
return latent_mean, log_latent_sigmas
else:
return ops.linear(opts, layer_x, opts['latent_space_dim'], scope='hlast_lin')
def _recon_loss_using_disc_conv_eb(self, opts, reconstructed_training, real_points, is_training, keep_prob):
"""Build an additional loss using a discriminator in X space, using Energy Based approach."""
def copy3D(height, width, channels):
m = np.zeros([height, width, channels, height, width, channels])
for i in xrange(height):
for j in xrange(width):
for c in xrange(channels):
m[i, j, c, i, j, c] = 1.0
return tf.constant(np.reshape(m, [height, width, channels, -1]), dtype=tf.float32)
def _architecture(inputs, reuse=None):
dim = opts['adv_c_patches_size']
height = int(inputs.get_shape()[1])
width = int(inputs.get_shape()[2])
channels = int(inputs.get_shape()[3])
with tf.variable_scope('DISC_X_LOSS', reuse=reuse):
num_units = opts['adv_c_num_units']
num_layers = 1
layer_x = inputs
for i in xrange(num_layers):
# scale = 2**(num_layers-i-1)
layer_x = ops.conv2d(opts, layer_x, num_units, d_h=1, d_w=1, scope='h%d_conv' % i,
conv_filters_dim=dim, padding='SAME')
# if opts['batch_norm']:
# layer_x = ops.batch_norm(opts, layer_x, is_training, reuse, scope='bn%d' % i)
layer_x = ops.lrelu(layer_x, 0.1) #tf.nn.relu(layer_x)
copy_w = copy3D(dim, dim, channels)
duplicated = tf.nn.conv2d(inputs, copy_w, strides=[1, 1, 1, 1], padding='SAME')
decoded = ops.conv2d(
opts, layer_x, channels * dim * dim, d_h=1, d_w=1, scope="decoder",
conv_filters_dim=1, padding='SAME')
reconstruction = tf.reduce_mean(tf.square(tf.stop_gradient(duplicated) - decoded), [1, 2, 3])
assert len(reconstruction.get_shape()) == 1
return flatten(layer_x), reconstruction
reconstructed_embed_sg, adv_fake_layer = _architecture(tf.stop_gradient(reconstructed_training), reuse=None)
reconstructed_embed, _ = _architecture(reconstructed_training, reuse=True)
# Below line enforces the forward to be reconstructed_embed and backwards to NOT change the discriminator....
crazy_hack = reconstructed_embed-reconstructed_embed_sg+tf.stop_gradient(reconstructed_embed_sg)
real_p_embed_sg, adv_true_layer = _architecture(tf.stop_gradient(real_points), reuse=True)
real_p_embed, _ = _architecture(real_points, reuse=True)
adv_fake = tf.reduce_mean(adv_fake_layer)
adv_true = tf.reduce_mean(adv_true_layer)
adv_c_loss = tf.log(adv_true) - tf.log(adv_fake)
emb_c = tf.reduce_sum(tf.square(crazy_hack - tf.stop_gradient(real_p_embed)), 1)
emb_c_loss = tf.reduce_mean(emb_c)
return adv_c_loss, emb_c_loss
def __init__(self, sess, config, is_crop=True,
batch_size=64, output_size=64,
z_dim=100, gf_dim=64, df_dim=64,
gfc_dim=1024, dfc_dim=1024, c_dim=3, dataset_name='default',
checkpoint_dir=None, sample_dir=None, log_dir=None):
"""
Args:
sess: TensorFlow session
batch_size: The size of batch. Should be specified before training.
output_size: (optional) The resolution in pixels of the images. [64]
z_dim: (optional) Dimension of dim for Z. [100]
gf_dim: (optional) Dimension of gen filters in first conv layer. [64]
df_dim: (optional) Dimension of discrim filters in first conv layer. [64]
gfc_dim: (optional) Dimension of gen units for for fully connected layer. [1024]
dfc_dim: (optional) Dimension of discrim units for fully connected layer. [1024]
c_dim: (optional) Dimension of image color. For grayscale input, set to 1. [3]
"""
self.sess = sess
self.config = config
self.is_crop = is_crop
self.is_grayscale = (c_dim == 1)
self.batch_size = batch_size
self.sample_size = batch_size
self.output_size = output_size
self.sample_dir = sample_dir
self.log_dir=log_dir
self.checkpoint_dir = checkpoint_dir
self.z_dim = z_dim
self.gf_dim = gf_dim
self.df_dim = df_dim
self.gfc_dim = gfc_dim
self.dfc_dim = dfc_dim
self.c_dim = c_dim
# batch normalization : deals with poor initialization helps gradient flow
self.d_bn1 = batch_norm(name='d_bn1')
self.d_bn2 = batch_norm(name='d_bn2')
self.d_bn3 = batch_norm(name='d_bn3')
self.g_bn0 = batch_norm(name='g_bn0')
self.g_bn1 = batch_norm(name='g_bn1')
self.g_bn2 = batch_norm(name='g_bn2')
self.g_bn3 = batch_norm(name='g_bn3')
self.dataset_name = dataset_name
self.build_model()
def __init__(self, sess, config, is_crop=True,
batch_size=64, output_size=64,
z_dim=100, gf_dim=64, df_dim=64,
gfc_dim=1024, dfc_dim=1024, c_dim=3, dataset_name='default',
checkpoint_dir=None, sample_dir=None, log_dir=None):
"""
Args:
sess: TensorFlow session
batch_size: The size of batch. Should be specified before training.
output_size: (optional) The resolution in pixels of the images. [64]
z_dim: (optional) Dimension of dim for Z. [100]
gf_dim: (optional) Dimension of gen filters in first conv layer. [64]
df_dim: (optional) Dimension of discrim filters in first conv layer. [64]
gfc_dim: (optional) Dimension of gen units for for fully connected layer. [1024]
dfc_dim: (optional) Dimension of discrim units for fully connected layer. [1024]
c_dim: (optional) Dimension of image color. For grayscale input, set to 1. [3]
"""
self.sess = sess
self.config = config
self.is_crop = is_crop
self.is_grayscale = (c_dim == 1)
self.batch_size = batch_size
self.sample_size = batch_size
self.output_size = output_size
self.sample_dir = sample_dir
self.log_dir=log_dir
self.checkpoint_dir = checkpoint_dir
self.z_dim = z_dim
self.gf_dim = gf_dim
self.df_dim = df_dim
self.gfc_dim = gfc_dim
self.dfc_dim = dfc_dim
self.c_dim = c_dim
# batch normalization : deals with poor initialization helps gradient flow
self.d_bn1 = batch_norm(name='d_bn1')
self.d_bn2 = batch_norm(name='d_bn2')
self.d_bn3 = batch_norm(name='d_bn3')
self.g_bn0 = batch_norm(name='g_bn0')
self.g_bn1 = batch_norm(name='g_bn1')
self.g_bn2 = batch_norm(name='g_bn2')
self.g_bn3 = batch_norm(name='g_bn3')
self.dataset_name = dataset_name
self.build_model()
def __init__(self, sess, config, is_crop=True,
batch_size=64, output_size=64,
z_dim=100, gf_dim=64, df_dim=64,
gfc_dim=1024, dfc_dim=1024, c_dim=3, dataset_name='default',
checkpoint_dir=None, sample_dir=None, log_dir=None):
"""
Args:
sess: TensorFlow session
batch_size: The size of batch. Should be specified before training.
output_size: (optional) The resolution in pixels of the images. [64]
z_dim: (optional) Dimension of dim for Z. [100]
gf_dim: (optional) Dimension of gen filters in first conv layer. [64]
df_dim: (optional) Dimension of discrim filters in first conv layer. [64]
gfc_dim: (optional) Dimension of gen units for for fully connected layer. [1024]
dfc_dim: (optional) Dimension of discrim units for fully connected layer. [1024]
c_dim: (optional) Dimension of image color. For grayscale input, set to 1. [3]
"""
self.sess = sess
self.config = config
self.is_crop = is_crop
self.is_grayscale = (c_dim == 1)
self.batch_size = batch_size
self.sample_size = batch_size
self.output_size = output_size
self.sample_dir = sample_dir
self.log_dir=log_dir
self.checkpoint_dir = checkpoint_dir
self.z_dim = z_dim
self.gf_dim = gf_dim
self.df_dim = df_dim
self.gfc_dim = gfc_dim
self.dfc_dim = dfc_dim
self.c_dim = c_dim
# batch normalization : deals with poor initialization helps gradient flow
self.d_bn1 = batch_norm(name='d_bn1')
self.d_bn2 = batch_norm(name='d_bn2')
self.d_bn3 = batch_norm(name='d_bn3')
self.g_bn0 = batch_norm(name='g_bn0')
self.g_bn1 = batch_norm(name='g_bn1')
self.g_bn2 = batch_norm(name='g_bn2')
self.g_bn3 = batch_norm(name='g_bn3')
self.dataset_name = dataset_name
self.build_model()
def discriminator(images, labels, reuse=False):
with tf.variable_scope("discriminator") as scope:
if reuse:
scope.reuse_variables()
# conv1
conv1 = ops.conv_2d(images, 64, scope="conv1")
# leakly ReLu
h1 = ops.leaky_relu(conv1)
# conv2
conv2 = ops.conv_2d(h1, 128, scope="conv2")
# batch norm
norm2 = ops.batch_norm(conv2, scope="batch_norm2", is_training=True)
# leaky ReLU
h2 = ops.leaky_relu(norm2)
# conv3
conv3 = ops.conv_2d(h2, 256, scope="conv3")
# batch norm
norm3 = ops.batch_norm(conv3, scope="batch_norm3", is_training=True)
# leaky ReLU
h3 = ops.leaky_relu(norm3)
# conv4
conv4 = ops.conv_2d(h3, 512, scope="conv4")
# batch norm
norm4 = ops.batch_norm(conv4, scope="batch_norm4", is_training=True)
# leaky ReLU
h4 = ops.leaky_relu(norm4)
# reshape
h4_reshape = tf.reshape(h4, [FLAGS.batch_size, -1])
# source logits
source_logits = ops.fc(h4_reshape, 1, scope="source_logits")
# class logits
class_logits = ops.fc(
h4_reshape, FLAGS.n_classes, scope="class_logits")
return source_logits, class_logits
def _initialize_params(self):
all_weights = {}
batch_norms = {}
gen_vars = []
disc_vars = []
# init generator weights
prev_layer_dim = self.z_dim
for layer_i in xrange(len(self.generator_params['dim'])):
name = 'gen_w' + str(layer_i)
all_weights[name] = ops.variable(name,
[self.generator_params['ksize'][layer_i],
self.generator_params['ksize'][layer_i],
self.generator_params['dim'][layer_i],
prev_layer_dim],
self.initializer)
gen_vars.append(all_weights[name])
if layer_i+1==len(self.generator_params['dim']):
name = 'gen_b' + str(layer_i)
all_weights[name] = ops.variable(name,
[self.generator_params['dim'][layer_i]],
)
gen_vars.append(all_weights[name])
else:
name = 'gen_bn' + str(layer_i)
batch_norms[name] = ops.batch_norm(self.generator_params['dim'][layer_i], name=name)
prev_layer_dim = self.generator_params['dim'][layer_i]
# init discriminator weights
prev_layer_dim = self.image_dim
for layer_i in xrange(len(self.discriminator_params['dim'])):
name = 'disc_w' + str(layer_i)
all_weights[name] = ops.variable(name,
[self.discriminator_params['ksize'][layer_i],
self.discriminator_params['ksize'][layer_i],
prev_layer_dim,
self.discriminator_params['dim'][layer_i]],
self.initializer)
disc_vars.append(all_weights[name])
if layer_i+1==len(self.discriminator_params['dim']):
name = 'disc_b' + str(layer_i)
all_weights[name] = ops.variable(name,
[self.discriminator_params['dim'][layer_i]],
tf.constant_initializer(0.0))
disc_vars.append(all_weights[name])
else:
name = 'disc_bn' + str(layer_i)
batch_norms[name] = ops.batch_norm(self.discriminator_params['dim'][layer_i], name=name)
prev_layer_dim = self.discriminator_params['dim'][layer_i]
return all_weights, batch_norms, gen_vars, disc_vars
def _initialize_params(self):
all_weights = {}
batch_norms = {}
gen_vars = []
disc_vars = []
# init generator weights
prev_layer_dim = self.z_dim
for layer_i in xrange(len(self.generator_params['dim'])):
name = 'gen_w' + str(layer_i)
all_weights[name] = ops.variable(name,
[self.generator_params['ksize'][layer_i],
self.generator_params['ksize'][layer_i],
self.generator_params['dim'][layer_i],
prev_layer_dim],
self.initializer)
gen_vars.append(all_weights[name])
if layer_i+1==len(self.generator_params['dim']):
name = 'gen_b' + str(layer_i)
all_weights[name] = ops.variable(name,
[self.generator_params['dim'][layer_i]],
)
gen_vars.append(all_weights[name])
else:
name = 'gen_bn' + str(layer_i)
batch_norms[name] = ops.batch_norm(self.generator_params['dim'][layer_i], name=name)
prev_layer_dim = self.generator_params['dim'][layer_i]
# init discriminator weights
for disc_i in xrange(len(self.discriminators_params)):
prev_layer_dim = self.image_dim
cur_params = self.discriminators_params[disc_i]
for layer_i in xrange(len(cur_params['dim'])):
name = 'disc' + str(disc_i) + '_w' + str(layer_i)
all_weights[name] = ops.variable(name,
[cur_params['ksize'][layer_i],
cur_params['ksize'][layer_i],
prev_layer_dim,
cur_params['dim'][layer_i]],
self.initializer)
disc_vars.append(all_weights[name])
if layer_i+1==len(cur_params['dim']):
name = 'disc' + str(disc_i) + '_b' + str(layer_i)
all_weights[name] = ops.variable(name,
[cur_params['dim'][layer_i]],
tf.constant_initializer(0.0))
disc_vars.append(all_weights[name])
else:
name = 'disc_' + str(disc_i) + '_bn' + str(layer_i)
batch_norms[name] = ops.batch_norm(cur_params['dim'][layer_i], name=name)
prev_layer_dim = cur_params['dim'][layer_i]
return all_weights, batch_norms, gen_vars, disc_vars
