def discriminator(self, mri, pet, reuse = False):
with tf.variable_scope('discriminator') as scope:
if reuse:
scope.reuse_variables()
inputs = tf.concat(
[mri, pet], self.channel_axis, name='/concat')
print('input',' ',inputs.shape)
conv1 = ops.conv(inputs, 16, (3, 3, 3), '/conv1', self.conf.data_type)
conv1 = ops.batch_norm(conv1, '/batch1',ac_fn = ops.leaky_relu)
print('conv1 ',conv1.shape)
conv1 = tf.nn.dropout(conv1, 0.5, name='drop1')
conv2 = ops.conv(conv1, 32, (3, 3, 3), '/conv2', self.conf.data_type,2)
conv2 = ops.batch_norm(conv2, '/batch2',ac_fn = ops.leaky_relu)
print('conv2 ',conv2.shape)
conv2 = tf.nn.dropout(conv2, 0.5, name = 'drop2')
conv3 = ops.conv(conv2, 64, (3, 3, 3), '/conv3', self.conf.data_type)
conv3 = ops.batch_norm(conv3, '/batch3',ac_fn = ops.leaky_relu)
print('conv3 ',conv3.shape)
conv3 = tf.nn.dropout(conv3, 0.5, name = 'drop3')
conv4 = ops.conv(conv3, 128, (3, 3, 3), '/conv4', self.conf.data_type,2)
conv4 = ops.batch_norm(conv4, '/batch4',ac_fn = ops.leaky_relu)
conv4 = tf.nn.dropout(conv4, 0.5, name = 'drop4')
print('conv4 ',conv4.shape)
flatten = tf.contrib.layers.flatten(conv4)
logits = tf.contrib.layers.fully_connected(flatten, 5, activation_fn=None, scope = '/fully')
print('flatten ',flatten.shape)
print('logits ',logits.shape)
d = tf.nn.sigmoid(logits)
return d[:,0], logits[:,0], d[:,1:5], logits[:,1:5]
def discriminator(self, image, is_training, reuse=False):
with tf.variable_scope("discriminator"):
if reuse:
tf.get_variable_scope().reuse_variables()
# [batch,256,256,1] -> [batch,128,128,64]
h0 = lrelu(conv2d(image, self.discriminator_dim,
scope="d_h0_conv"))
# [batch,128,128,64] -> [batch,64,64,64*2]
h1 = lrelu(
batch_norm(conv2d(h0,
self.discriminator_dim * 2,
scope="d_h1_conv"),
is_training,
scope="d_bn_1"))
# [batch,64,64,64*2] -> [batch,32,32,64*4]
h2 = lrelu(
batch_norm(conv2d(h1,
self.discriminator_dim * 4,
scope="d_h2_conv"),
is_training,
scope="d_bn_2"))
# [batch,32,32,64*4] -> [batch,31,31,64*8]
h3 = lrelu(
batch_norm(conv2d(h2,
self.discriminator_dim * 8,
sh=1,
sw=1,
scope="d_h3_conv"),
is_training,
scope="d_bn_3"))
# real or fake binary loss
fc1 = fc(tf.reshape(h3, [self.batch_size, -1]), 1, scope="d_fc1")
return tf.sigmoid(fc1), fc1
def discriminator(self, mri, pet, reuse = False, disc_type=1):
with tf.variable_scope('discriminator') as scope:
if reuse:
scope.reuse_variables()
inputs = tf.concat(
[mri, pet], self.channel_axis, name='/concat')
# print('input',' ',inputs.shape)
conv1 = ops.conv(inputs, 16, 3 , '/conv1', self.conf.data_type)
conv1 = ops.batch_norm(conv1, '/batch1',ac_fn = ops.leaky_relu)
# print('conv1 ',conv1.shape)
conv2 = ops.conv(conv1, 32, 3, '/conv2', self.conf.data_type,2)
conv2 = ops.batch_norm(conv2, '/batch2',ac_fn = ops.leaky_relu)
# print('conv2 ',conv2.shape)
conv3 = ops.conv(conv2, 64, 3, '/conv3', self.conf.data_type)
conv3 = ops.batch_norm(conv3, '/batch3',ac_fn = ops.leaky_relu)
# print('conv3 ',conv3.shape)
conv4 = ops.conv(conv3, 128, 3, '/conv4', self.conf.data_type,2)
conv4 = ops.batch_norm(conv4, '/batch4',ac_fn = ops.leaky_relu)
# print('conv4 ',conv4.shape)
flatten = tf.contrib.layers.flatten(conv4)
# print('flatten ',flatten.shape)
logits = tf.contrib.layers.fully_connected(flatten, 1, activation_fn=None, scope = '/fully1')
# print('logits ',logits.shape)
features = tf.contrib.layers.fully_connected(flatten, 20, activation_fn=None, scope = '/fully2')
if self.conf.model_option.endswith('metric'):
features = ops.batch_norm(features, '/batch5', ac_fn=None)
return logits, features
def generator(self, z, embed, is_training=True, reuse=False, cond_noise=True):
s = self.output_size
s2, s4, s8, s16 = int(s / 2), int(s / 4), int(s / 8), int(s / 16)
with tf.variable_scope("g_net", reuse=reuse):
# Sample from the multivariate normal distribution of the embeddings
mean, log_sigma = self.generate_conditionals(embed)
net_embed = self.sample_normal_conditional(mean, log_sigma, cond_noise)
# --------------------------------------------------------
# Concatenate the sampled embedding with the z vector
net_input = tf.concat([z, net_embed], 1)
net_h0 = tf.layers.dense(net_input, units=self.gf_dim*8*s16*s16, activation=None,
kernel_initializer=self.w_init)
net_h0 = batch_norm(net_h0, train=is_training, init=self.batch_norm_init, act=None)
net_h0 = tf.reshape(net_h0, [-1, s16, s16, self.gf_dim * 8])
# Residual layer
net = conv2d(net_h0, self.gf_dim * 2, ks=(1, 1), s=(1, 1), padding='valid', init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
net = conv2d(net, self.gf_dim * 2, ks=(3, 3), s=(1, 1), init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
net = conv2d(net, self.gf_dim * 8, ks=(3, 3), s=(1, 1), padding='same', init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init, act=None)
net_h1 = tf.add(net_h0, net)
net_h1 = tf.nn.relu(net_h1)
# --------------------------------------------------------
net_h2 = conv2d_transpose(net_h1, self.gf_dim*4, ks=(4, 4), s=(2, 2), init=self.w_init)
net_h2 = conv2d(net_h2, self.gf_dim*4, ks=(3, 3), s=(1, 1), init=self.w_init)
net_h2 = batch_norm(net_h2, train=is_training, init=self.batch_norm_init, act=None)
# --------------------------------------------------------
# Residual layer
net = conv2d(net_h2, self.gf_dim, ks=(1, 1), s=(1, 1), padding='valid', init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
net = conv2d(net, self.gf_dim, ks=(3, 3), s=(1, 1), init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
net = conv2d(net, self.gf_dim*4, ks=(3, 3), s=(1, 1), init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init, act=None)
net_h3 = tf.add(net_h2, net)
net_h3 = tf.nn.relu(net_h3)
# --------------------------------------------------------
net_h4 = conv2d_transpose(net_h3, self.gf_dim*2, ks=(4, 4), s=(2, 2), init=self.w_init)
net_h4 = conv2d(net_h4, self.gf_dim*2, ks=(3, 3), s=(1, 1), init=self.w_init)
net_h4 = batch_norm(net_h4, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
net_h5 = conv2d_transpose(net_h4, self.gf_dim, ks=(4, 4), s=(2, 2), init=self.w_init)
net_h5 = conv2d(net_h5, self.gf_dim, ks=(3, 3), s=(1, 1), init=self.w_init)
net_h5 = batch_norm(net_h5, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
net_logits = conv2d_transpose(net_h5, self.image_dims[-1], ks=(4, 4), s=(2, 2), init=self.w_init)
net_logits = conv2d(net_logits, self.image_dims[-1], ks=(3, 3), s=(1, 1), init=self.w_init)
net_output = tf.nn.tanh(net_logits)
return net_output, mean, log_sigma
def build_bottom_block(self, inputs, name):
out_num = inputs.shape[self.channel_axis].value
conv1 = ops.conv(inputs, 2 * out_num, self.conv_size, name + '/conv1',
self.conf.data_type)
conv1 = ops.batch_norm(conv1, name + '/batch1')
conv2 = ops.conv(conv1, out_num, self.conv_size, name + '/conv2',
self.conf.data_type)
conv2 = ops.batch_norm(conv2, name + '/batch2')
return conv2
def generator_residual_layer(self, input_layer, is_training=True):
net_h0 = input_layer
net_h1 = conv2d(net_h0, self.gf_dim * 4, ks=(4, 4), s=(1, 1))
net_h1 = batch_norm(net_h1, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
net_h2 = conv2d(net_h1, self.gf_dim * 4, ks=(4, 4), s=(1, 1))
net_h2 = batch_norm(net_h2, train=is_training, init=self.batch_norm_init)
return tf.nn.relu(tf.add(net_h0, net_h2))
def generator_encode_image(self, image, is_training=True):
net_h0 = conv2d(image, self.gf_dim, ks=(3, 3), s=(1, 1), act=tf.nn.relu)
net_h1 = conv2d(net_h0, self.gf_dim * 2, ks=(4, 4), s=(2, 2))
net_h1 = batch_norm(net_h1, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
output_tensor = conv2d(net_h1, self.gf_dim * 4, ks=(4, 4), s=(2, 2))
output_tensor = batch_norm(output_tensor, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
return output_tensor
def build_down_block(self, inputs, name, down_outputs, first=False):
out_num = self.conf.start_channel_num if first else 2 * \
inputs.shape[self.channel_axis].value
conv1 = ops.conv(inputs, out_num, self.conv_size,
name+'/conv1', self.conf.data_type)
conv1 = ops.batch_norm(conv1, name+'/batch1')
conv2 = ops.conv(conv1, out_num, self.conv_size,
name+'/conv2', self.conf.data_type,2)
conv2 = ops.batch_norm(conv2, name+'/batch2')
down_outputs.append(conv1)
return conv2
def _make_descriminator(self, input, phase_train):
conv1 = ops.batch_norm(ops.conv2d(input, self.df_dim,
name='d_h0_conv'),
name='d_bn0',
phase_train=phase_train)
h0 = ops.lrelu(conv1)
h1 = ops.lrelu(
ops.batch_norm(ops.conv2d(h0, self.df_dim * 2, name='d_h1_conv'),
name='d_bn1',
phase_train=phase_train))
#h2 = ops.lrelu(ops.batch_norm(ops.conv2d(h1, self.df_dim*4, name='d_h2_conv'), name='d_bn2'))
#h3 = ops.lrelu(ops.batch_norm(ops.conv2d(h2, self.df_dim*8, name='d_h3_conv'), name='d_bn3'))
h2 = ops.lrelu(tf.reshape(h1, [self.batch_size, -1]), 1, 'd_h1_lin')
return h2
def generator(self, image, embed, is_training=True, reuse=False, sampler=False):
s = 64
s2, s4, s8, s16 = int(s / 2), int(s / 4), int(s / 8), int(s / 16)
with tf.variable_scope("stageII_g_net", reuse=reuse):
encoded_img = self.generator_encode_image(image, is_training=is_training)
# Sample from the multivariate normal distribution of the embeddings
mean, log_sigma = self.generate_conditionals(embed)
net_embed = self.sample_normal_conditional(mean, log_sigma)
# --------------------------------------------------------
# Concatenate the encoded image and the embeddings
net_embed = tf.expand_dims(tf.expand_dims(net_embed, 1), 1)
net_embed = tf.tile(net_embed, [1, s4, s4, 1])
imgenc_embed = tf.concat([encoded_img, net_embed], 3)
pre_res = conv2d(imgenc_embed, self.gf_dim * 4, ks=(3, 3), s=(1, 1))
pre_res = batch_norm(pre_res, train=is_training, init=self.batch_norm_init, act=tf.nn.relu)
r_block1 = self.generator_residual_layer(pre_res, is_training=is_training)
r_block2 = self.generator_residual_layer(r_block1, is_training=is_training)
r_block3 = self.generator_residual_layer(r_block2, is_training=is_training)
r_block4 = self.generator_residual_layer(r_block3, is_training=is_training)
return self.generator_upsample(r_block4, is_training=is_training), mean, log_sigma
def _make_generator(self, input, phase_train):
s_h, s_w = self.img_size, self.img_size
s_h2, s_w2 = self._conv_out_size_same(s_h,
2), self._conv_out_size_same(
s_w, 2)
s_h4, s_w4 = self._conv_out_size_same(s_h2,
2), self._conv_out_size_same(
s_w2, 2)
#s_h8, s_w8 = self._conv_out_size_same(s_h4, 2), self._conv_out_size_same(s_w4, 2)
#s_h16, s_w16 = self._conv_out_size_same(s_h8, 2), self._conv_out_size_same(s_w8, 2)
# project `z` and reshape
self.z_, self.h0_w, self.h0_b = ops.linear(input,
self.gf_dim * 8 * s_h4 *
s_w4,
'g_h0_lin',
with_w=True)
normalized_value = ops.batch_norm(self.z_,
name='g_bn0',
axes=[0],
phase_train=phase_train)
self.h0 = tf.reshape(normalized_value,
[-1, s_h4, s_w4, self.gf_dim * 8])
h0 = ops.lrelu(self.h0)
self.h1, self.h1_w, self.h1_b = ops.deconv2d(
h0, [self.batch_size, s_h2, s_w2, self.gf_dim * 4],
name='g_h1',
with_w=True)
h1 = ops.lrelu(
ops.batch_norm(self.h1, name='g_bn1', phase_train=phase_train))
# h2, self.h2_w, self.h2_b = ops.deconv2d(
# h1, [self.batch_size, s_h4, s_w4, self.gf_dim*2], name='g_h2', with_w=True)
# h2 = tf.nn.relu(ops.batch_norm(h2, name='g_bn2'))
#
# h3, self.h3_w, self.h3_b = ops.deconv2d(
# h2, [self.batch_size, s_h2, s_w2, self.gf_dim*1], name='g_h3', with_w=True)
# h3 = tf.nn.relu(ops.batch_norm(h3, name='g_bn3'))
h2, self.h2_w, self.h2_b = ops.deconv2d(
h1, [self.batch_size, s_h, s_w, self.c_dim],
name='g_h4',
with_w=True)
h2_non_linear = ops.lrelu(h2, leak=0)
return h2_non_linear
def encode_layer(x, output_filters, layer):
act = lrelu(x)
conv = conv2d(act,
output_filters=output_filters,
scope="g_e%d_conv" % layer)
enc = batch_norm(conv, is_training, scope="g_e%d_bn" % layer)
encode_layers["e%d" % layer] = enc
return enc
def generator_upsample(self, input_layer, is_training=True):
net_h0 = conv2d_transpose(input_layer,
self.gf_dim * 2,
ks=(4, 4),
init=self.w_init)
net_h0 = conv2d(net_h0, self.gf_dim * 2, ks=(3, 3), s=(1, 1))
net_h0 = batch_norm(net_h0,
train=is_training,
init=self.batch_norm_init,
act=tf.nn.relu)
net_h1 = conv2d_transpose(net_h0,
self.gf_dim,
ks=(4, 4),
init=self.w_init)
net_h1 = conv2d(net_h1, self.gf_dim, ks=(3, 3), s=(1, 1))
net_h1 = batch_norm(net_h1,
train=is_training,
init=self.batch_norm_init,
act=tf.nn.relu)
net_h2 = conv2d_transpose(net_h1,
self.gf_dim // 2,
ks=(4, 4),
init=self.w_init)
net_h2 = conv2d(net_h2, self.gf_dim // 2, ks=(3, 3), s=(1, 1))
net_h2 = batch_norm(net_h2,
train=is_training,
init=self.batch_norm_init,
act=tf.nn.relu)
net_h3 = conv2d_transpose(net_h2,
self.gf_dim // 4,
ks=(4, 4),
init=self.w_init)
net_h3 = conv2d(net_h3, self.gf_dim // 4, ks=(3, 3), s=(1, 1))
net_h3 = batch_norm(net_h3,
train=is_training,
init=self.batch_norm_init,
act=tf.nn.relu)
return conv2d(net_h3,
self.image_dims[-1],
ks=(3, 3),
s=(1, 1),
act=tf.nn.tanh)
def build_up_block(self, inputs, down_inputs, name, final=False):
out_num = inputs.shape[self.channel_axis].value
conv1 = self.deconv_func()(
inputs, out_num, self.conv_size, name+'/conv1',
self.conf.data_type, action=self.conf.action)
conv1 = ops.batch_norm(conv1, name+'/batch1')
conv1 = tf.concat(
[conv1, down_inputs], self.channel_axis, name=name+'/concat')
conv2 = self.conv_func()(
conv1, out_num, self.conv_size, name+'/conv2', self.conf.data_type)
conv2 = ops.batch_norm(conv2, name+'/batch2')
out_num = self.conf.class_num if final else out_num/2
if final:
conv3 = ops.conv(conv2, out_num, self.conv_size, name+'/conv3', self.conf.data_type)
else:
conv3 = ops.conv(conv2, out_num, self.conv_size, name+'/conv3', self.conf.data_type)
conv3 = ops.batch_norm(conv3, name+'/batch3')
return conv3
def encode_layer(x, output_filters, layer, keep_rate=1.0):
# act = lrelu(x)
enc = tf.nn.relu(x)
enc = tf.nn.dropout(enc, keep_rate)
enc = conv2d(enc,
output_filters=output_filters,
scope="g_e%d_conv" % layer)
# batch norm is important for ae, or aw would output nothing!!!
enc = batch_norm(enc, is_training, scope="g_e%d_bn" % layer)
encode_layers["e%d" % layer] = enc
return enc
def discriminator(self, inputs, embed, is_training=True, reuse=False):
s16 = self.output_size / 16
with tf.variable_scope("d_net", reuse=reuse):
net_ho = tf.layers.conv2d(inputs=inputs, filters=self.df_dim, kernel_size=(4, 4), strides=(2, 2),
padding='same', activation=lambda l: tf.nn.leaky_relu(l, 0.2),
kernel_initializer=self.w_init)
net_h1 = tf.layers.conv2d(inputs=net_ho, filters=self.df_dim * 2, kernel_size=(4, 4), strides=(2, 2),
padding='same', activation=None, kernel_initializer=self.w_init)
net_h1 = batch_norm(net_h1, train=is_training, init=self.batch_norm_init,
act=lambda l: tf.nn.leaky_relu(l, 0.2))
net_h2 = tf.layers.conv2d(inputs=net_h1, filters=self.df_dim * 4, kernel_size=(4, 4), strides=(2, 2),
padding='same', activation=None, kernel_initializer=self.w_init)
net_h2 = batch_norm(net_h2, train=is_training, init=self.batch_norm_init,
act=lambda l: tf.nn.leaky_relu(l, 0.2))
net_h3 = tf.layers.conv2d(inputs=net_h2, filters=self.df_dim * 8, kernel_size=(4, 4), strides=(2, 2),
padding='same', activation=None, kernel_initializer=self.w_init)
net_h3 = batch_norm(net_h3, train=is_training, init=self.batch_norm_init,
act=None)
# --------------------------------------------------------
# Residual layer
net = tf.layers.conv2d(inputs=net_h3, filters=self.df_dim * 2, kernel_size=(1, 1), strides=(1, 1),
padding='valid', activation=None, kernel_initializer=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init,
act=lambda l: tf.nn.leaky_relu(l, 0.2))
net = tf.layers.conv2d(inputs=net, filters=self.df_dim * 2, kernel_size=(3, 3), strides=(1, 1),
padding='same', activation=None, kernel_initializer=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init,
act=lambda l: tf.nn.leaky_relu(l, 0.2))
net = tf.layers.conv2d(inputs=net, filters=self.df_dim * 8, kernel_size=(3, 3), strides=(1, 1),
padding='same', activation=None, kernel_initializer=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init,
act=None)
net_h4 = tf.add(net_h3, net)
net_h4 = tf.nn.leaky_relu(net_h4, 0.2)
# --------------------------------------------------------
# Compress embeddings
net_embed = tf.layers.dense(inputs=embed, units=self.compressed_embed_dim,
activation=lambda l: tf.nn.leaky_relu(l, 0.2))
# Append embeddings in depth
net_embed = tf.reshape(net_embed, [self.batch_size, 4, 4, -1])
net_h4_concat = tf.concat([net_h4, net_embed], 3)
net_h4 = tf.layers.conv2d(inputs=net_h4_concat, filters=self.df_dim * 8, kernel_size=(1, 1), strides=(1, 1),
padding='valid', activation=None, kernel_initializer=self.w_init)
net_h4 = batch_norm(net_h4, train=is_training, init=self.batch_norm_init,
act=lambda l: tf.nn.leaky_relu(l, 0.2))
net_logits = tf.layers.conv2d(inputs=net_h4, filters=1, kernel_size=(s16, s16), strides=(s16, s16),
padding='valid', kernel_initializer=self.w_init)
return tf.nn.sigmoid(net_logits), net_logits
def decode_layer(x,
output_width,
output_filters,
layer,
enc_layer,
keep_rate=1.0):
dec = deconv2d(tf.nn.relu(x), [
self.batch_size, output_width, output_width, output_filters
],
scope="g_d%d_deconv" % layer)
if layer != 8:
# normalization for last layer is very important, otherwise GAN is unstable
dec = batch_norm(dec,
is_training,
scope="g_d%d_bn" % layer)
dec = tf.nn.dropout(dec, keep_prob=keep_rate)
return dec
def decode_layer(x,
output_width,
output_filters,
layer,
enc_layer,
dropout=False,
do_concat=True):
dec = deconv2d(tf.nn.relu(x), [
self.batch_size, output_width, output_width, output_filters
],
scope="g_d%d_deconv" % layer)
if layer != 8:
# normalization for last layer is very important, otherwise GAN is unstable
dec = batch_norm(dec,
is_training,
scope="g_d%d_bn" % layer)
if dropout:
dec = tf.nn.dropout(dec, 0.5)
if do_concat:
dec = tf.concat([dec, enc_layer], 3)
return dec
def discriminator(self, inputs, embed, is_training=True, reuse=False):
s16 = self.output_size / 16
lrelu = lambda l: tf.nn.leaky_relu(l, 0.2)
with tf.variable_scope("d_net", reuse=reuse):
net_ho = conv2d(inputs, self.df_dim, ks=(4, 4), s=(2, 2), act=lrelu, init=self.w_init)
net_h1 = conv2d(net_ho, self.df_dim * 2, ks=(4, 4), s=(2, 2), init=self.w_init)
net_h1 = batch_norm(net_h1, train=is_training, init=self.batch_norm_init, act=lrelu)
net_h2 = conv2d(net_h1, self.df_dim * 4, ks=(4, 4), s=(2, 2), init=self.w_init)
net_h2 = batch_norm(net_h2, train=is_training, init=self.batch_norm_init, act=lrelu)
net_h3 = conv2d(net_h2, self.df_dim * 8, ks=(4, 4), s=(2, 2), init=self.w_init)
net_h3 = batch_norm(net_h3, train=is_training, init=self.batch_norm_init)
# --------------------------------------------------------
# Residual layer
net = conv2d(net_h3, self.df_dim * 2, ks=(1, 1), s=(1, 1), padding='valid', init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init, act=lrelu)
net = conv2d(net, self.df_dim * 2, ks=(3, 3), s=(1, 1), init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init, act=lrelu)
net = conv2d(net, self.df_dim * 8, ks=(3, 3), s=(1, 1), init=self.w_init)
net = batch_norm(net, train=is_training, init=self.batch_norm_init)
net_h4 = tf.add(net_h3, net)
net_h4 = tf.nn.leaky_relu(net_h4, 0.2)
# --------------------------------------------------------
# Compress embeddings
net_embed = tf.layers.dense(embed, units=self.compressed_embed_dim, activation=lrelu)
# Append embeddings in depth
net_embed = tf.expand_dims(tf.expand_dims(net_embed, 1), 1)
net_embed = tf.tile(net_embed, [1, 4, 4, 1])
net_h4_concat = tf.concat([net_h4, net_embed], 3)
net_h4 = conv2d(net_h4_concat, self.df_dim * 8, ks=(1, 1), s=(1, 1), padding='valid', init=self.w_init)
net_h4 = batch_norm(net_h4, train=is_training, init=self.batch_norm_init, act=lrelu)
net_logits = conv2d(net_h4, 1, ks=(s16, s16), s=(s16, s16), padding='valid', init=self.w_init)
return tf.nn.sigmoid(net_logits), net_logits
