def generate(self, z_var, pg=1, t=False, alpha_trans=0.0):
with tf.variable_scope('generator') as scope:
de = tf.reshape(Pixl_Norm(z_var), [self.batch_size, 1, 1, int(self.get_nf(1))])
de = conv2d(de, output_dim=self.get_nf(1), k_h=4, k_w=4, d_w=1, d_h=1, use_wscale=self.use_wscale, gain=np.sqrt(2)/4, padding='Other', name='gen_n_1_conv')
de = Pixl_Norm(lrelu(de))
de = tf.reshape(de, [self.batch_size, 4, 4, int(self.get_nf(1))])
de = conv2d(de, output_dim=self.get_nf(1), d_w=1, d_h=1, use_wscale=self.use_wscale, name='gen_n_2_conv')
de = Pixl_Norm(lrelu(de))
for i in range(pg - 1):
if i == pg - 2 and t:
#To RGB
de_iden = conv2d(de, output_dim=2, k_w=1, k_h=1, d_w=1, d_h=1, use_wscale=self.use_wscale,
name='gen_y_rgb_conv_{}'.format(de.shape[1]))
de_iden = upscale(de_iden, 2)
de = upscale(de, 2)
de = Pixl_Norm(lrelu(
conv2d(de, output_dim=self.get_nf(i + 1), d_w=1, d_h=1, use_wscale=self.use_wscale, name='gen_n_conv_1_{}'.format(de.shape[1]))))
de = Pixl_Norm(lrelu(
conv2d(de, output_dim=self.get_nf(i + 1), d_w=1, d_h=1, use_wscale=self.use_wscale, name='gen_n_conv_2_{}'.format(de.shape[1]))))
#To RGB
de = conv2d(de, output_dim=2, k_w=1, k_h=1, d_w=1, d_h=1, use_wscale=self.use_wscale, gain=1, name='gen_y_rgb_conv_{}'.format(de.shape[1]))
if pg == 1: return de
if t: de = (1 - alpha_trans) * de_iden + alpha_trans*de
else: de = de
return de
def _g_residual_block(self, x, y, n_ch, idx, is_training, resize=True):
update_collection = self._get_update_collection(is_training)
with tf.variable_scope("g_resblock_" + str(idx), reuse=tf.AUTO_REUSE):
h = self._cbn(x, y, is_training, scope='g_resblock_cbn_1')
h = tf.nn.relu(h)
if resize:
h = upscale(h, 2)
h = snconv2d(h,
n_ch,
name='g_resblock_conv_1',
update_collection=update_collection)
h = self._cbn(h, y, is_training, scope='g_resblock_cbn_2')
h = tf.nn.relu(h)
h = snconv2d(h,
n_ch,
name='g_resblock_conv_2',
update_collection=update_collection)
if resize:
sc = upscale(x, 2)
else:
sc = x
sc = snconv2d(sc,
n_ch,
k_h=1,
k_w=1,
name='g_resblock_conv_sc',
update_collection=update_collection)
return h + sc
def encode_decode2(self, x, img_mask, pg=1, is_trans=False, alpha_trans=0.01, reuse=False):
with tf.variable_scope("ed") as scope:
if reuse == True:
scope.reuse_variables()
x = tf.concat([x, img_mask], axis=3)
if is_trans:
x_trans = downscale2d(x)
#fromrgb
x_trans = tf.nn.relu(instance_norm(conv2d(x_trans, output_dim=self.get_nf(pg - 2), k_w=1, k_h=1, d_h=1, d_w=1,
name='gen_rgb_e_{}'.format(x_trans.shape[1])), scope='gen_rgb_e_in_{}'.format(x_trans.shape[1])))
#fromrgb
x = tf.nn.relu(instance_norm(conv2d(x, output_dim=self.get_nf(pg - 1), k_w=1, k_h=1, d_h=1, d_w=1,
name='gen_rgb_e_{}'.format(x.shape[1])), scope='gen_rgb_e_in_{}'.format(x.shape[1])))
for i in range(pg - 1):
print "encode", x.shape
x = tf.nn.relu(instance_norm(conv2d(x, output_dim=self.get_nf(pg - 2 - i), d_h=1, d_w=1,
name='gen_conv_e_{}'.format(x.shape[1])), scope='gen_conv_e_in_{}'.format(x.shape[1])))
x = downscale2d(x)
if i == 0 and is_trans:
x = alpha_trans * x + (1 - alpha_trans) * x_trans
up_x = tf.nn.relu(
instance_norm(dilated_conv2d(x, output_dim=512, k_w=3, k_h=3, rate=4, name='gen_conv_dilated'),
scope='gen_conv_in'))
up_x = tf.nn.relu(instance_norm(conv2d(up_x, output_dim=self.get_nf(1), d_w=1, d_h=1, name='gen_conv_d'),
scope='gen_conv_d_in_{}'.format(x.shape[1])))
for i in range(pg - 1):
print "decode", up_x.shape
if i == pg - 2 and is_trans:
#torgb
up_x_trans = conv2d(up_x, output_dim=self.channel, k_w=1, k_h=1, d_w=1, d_h=1,
name='gen_rgb_d_{}'.format(up_x.shape[1]))
up_x_trans = upscale(up_x_trans, 2)
up_x = upscale(up_x, 2)
up_x = tf.nn.relu(instance_norm(conv2d(up_x, output_dim=self.get_nf(i + 1), d_w=1, d_h=1,
name='gen_conv_d_{}'.format(up_x.shape[1])), scope='gen_conv_d_in_{}'.format(up_x.shape[1])))
#torgb
up_x = conv2d(up_x, output_dim=self.channel, k_w=1, k_h=1, d_w=1, d_h=1,
name='gen_rgb_d_{}'.format(up_x.shape[1]))
if pg == 1: up_x = up_x
else:
if is_trans: up_x = (1 - alpha_trans) * up_x_trans + alpha_trans * up_x
else:
up_x = up_x
return up_x
def generate(self, z_var, t_text_embedding, pg=1, t=False, alpha_trans=0.0):
with tf.variable_scope('generator') as scope:
reduced_text_embedding = lrelu( linear(t_text_embedding, self.tdim, 'g_embeddings') )
z_concat = tf.concat([z_var,reduced_text_embedding], 1)
de = tf.reshape(z_concat, [self.batch_size, 1, 1, tf.cast(self.get_nf(1),tf.int32)])
de = conv2d(de, output_dim= self.get_nf(1), k_h=4, k_w=4, d_w=1, d_h=1, padding='Other', name='gen_n_1_conv')
de = Pixl_Norm(lrelu(de))
de = tf.reshape(de, [self.batch_size, 4, 4, tf.cast(self.get_nf(1),tf.int32)])
de = conv2d(de, output_dim=self.get_nf(1), d_w=1, d_h=1, name='gen_n_2_conv')
de = Pixl_Norm(lrelu(de))
for i in range(pg - 1):
if i == pg - 2 and t:
#To RGB
de_iden = conv2d(de, output_dim=3, k_w=1, k_h=1, d_w=1, d_h=1,
name='gen_y_rgb_conv_{}'.format(de.shape[1]))
de_iden = upscale(de_iden, 2)
de = upscale(de, 2)
de = Pixl_Norm(lrelu(
conv2d(de, output_dim=self.get_nf(i + 1), d_w=1, d_h=1, name='gen_n_conv_1_{}'.format(de.shape[1]))))
de = Pixl_Norm(lrelu(
conv2d(de, output_dim=self.get_nf(i + 1), d_w=1, d_h=1, name='gen_n_conv_2_{}'.format(de.shape[1]))))
#To RGB
de = conv2d(de, output_dim=3, k_w=1, k_h=1, d_w=1, d_h=1, name='gen_y_rgb_conv_{}'.format(de.shape[1]))
if pg == 1:
return de
if t:
de = (1 - alpha_trans) * de_iden + alpha_trans*de
else:
de = de
return de #tanh given in text to image code. will this work?
def generate(self, z_var, pg=1, t=False, alpha_trans=0.0):
with tf.variable_scope('generator') as scope:
#
de = tf.reshape(Pixl_Norm(z_var), [self.batch_size, 1, 1, int(self.get_nf(1))])
de = conv2d(de, output_dim=self.get_nf(1), k_h=4, k_w=4, d_w=1, d_h=1, use_wscale=self.use_wscale, gain=np.sqrt(2)/4, padding='Other', name='gen_n_1_conv')
de = Pixl_Norm(lrelu(de))
de = tf.reshape(de, [self.batch_size, 4, 4, int(self.get_nf(1))])
de = conv2d(de, output_dim=self.get_nf(1), d_w=1, d_h=1, use_wscale=self.use_wscale, name='gen_n_2_conv')
de = Pixl_Norm(lrelu(de))
# pg 代表当前 pixel 上升至哪个档位
# pg=1，即第一层的training不需要进入，不需要提升pixel并进行一系列操作
for i in range(pg - 1):
# t 代表是否进行training，如果进行training则进行下述操作
# 最后一层循环，进入
if i == pg - 2 and t:
# To RGB
de_iden = conv2d(de, output_dim=3, k_w=1, k_h=1, d_w=1, d_h=1, use_wscale=self.use_wscale,
name='gen_y_rgb_conv_{}'.format(de.shape[1]))
de_iden = upscale(de_iden, 2)
de = upscale(de, 2)
de = Pixl_Norm(lrelu(
conv2d(de, output_dim=self.get_nf(i + 1), d_w=1, d_h=1, use_wscale=self.use_wscale, name='gen_n_conv_1_{}'.format(de.shape[1]))))
de = Pixl_Norm(lrelu(
conv2d(de, output_dim=self.get_nf(i + 1), d_w=1, d_h=1, use_wscale=self.use_wscale, name='gen_n_conv_2_{}'.format(de.shape[1]))))
# To RGB
de = conv2d(de, output_dim=3, k_w=1, k_h=1, d_w=1, d_h=1, use_wscale=self.use_wscale, gain=1, name='gen_y_rgb_conv_{}'.format(de.shape[1]))
if pg == 1: return de
# 如果是training，通过 alpha_trans 来调控和线性组合图片
if t:
de = (1 - alpha_trans) * de_iden + alpha_trans*de
else:
de = de
return de
def generator(hparams, z_var, train, reuse):
with tf.variable_scope("generator") as scope:
if reuse:
tf.get_variable_scope().reuse_variables()
use_wscale = True
de = tf.reshape(Pixl_Norm(z_var), [hparams.batch_size, 1, 1, 128])
de = conv2d(de, output_dim=128, k_h=4, k_w=4, d_w=1, d_h=1, use_wscale=use_wscale, gain=np.sqrt(2)/4, padding='Other', name='gen_n_1_conv')
de = Pixl_Norm(lrelu(de))
de = tf.reshape(de, [hparams.batch_size, 4, 4, 128])
de = conv2d(de, output_dim=128, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_2_conv')
de = Pixl_Norm(lrelu(de))
de = upscale(de, 2)
de = Pixl_Norm(lrelu(conv2d(de, output_dim=128, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_conv_1_8')))
de = Pixl_Norm(lrelu(conv2d(de, output_dim=128, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_conv_2_8')))
de = upscale(de, 2)
de = Pixl_Norm(lrelu(conv2d(de, output_dim=64, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_conv_1_16')))
de = Pixl_Norm(lrelu(conv2d(de, output_dim=64, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_conv_2_16')))
de = upscale(de, 2)
de = Pixl_Norm(lrelu(conv2d(de, output_dim=32, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_conv_1_32')))
de = Pixl_Norm(lrelu(conv2d(de, output_dim=32, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_conv_2_32')))
de_iden = conv2d(de, output_dim=2, k_w=1, k_h=1, d_w=1, d_h=1, use_wscale=use_wscale,name='gen_y_rgb_conv_32')
de_iden = upscale(de_iden, 2)
de = upscale(de, 2)
de = Pixl_Norm(lrelu(conv2d(de, output_dim=16, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_conv_1_64')))
de = Pixl_Norm(lrelu(conv2d(de, output_dim=16, d_w=1, d_h=1, use_wscale=use_wscale, name='gen_n_conv_2_64')))
de = conv2d(de, output_dim=2, k_w=1, k_h=1, d_w=1, d_h=1, use_wscale=use_wscale, gain=1, name='gen_y_rgb_conv_64')
return de
def generate(self, z_var, pg=1, t=False, alpha_trans=0.0):
with tf.variable_scope('generator') as scope:
# latent vector(batch_size, 512)를 (batch_size, 1, 1, 512)로 바꿈
de = tf.reshape(
z_var,
[self.batch_size, 1, 1,
tf.cast(self.get_nf(1), tf.int32)])
de = conv2d(de,
output_dim=self.get_nf(1),
k_h=4,
k_w=4,
d_w=1,
d_h=1,
padding='Other',
name='gen_n_1_conv')
de = Pixl_Norm(lrelu(de))
# [batch size, 4, 4, 512]로 바꿈
de = tf.reshape(
de, [self.batch_size, 4, 4,
tf.cast(self.get_nf(1), tf.int32)])
de = conv2d(de,
output_dim=self.get_nf(1),
d_w=1,
d_h=1,
name='gen_n_2_conv')
de = Pixl_Norm(lrelu(de))
#pg=2일때 i=0, for문 1번 실행
#pg=3일때 i=0,1 for문 2번 실행
for i in range(pg - 1):
#pg=2이고 i=0, t=True일때 실행
#pg=2이고 i=0, t=False일때 실행 x
#pg=3이고 i=0, t=True 실행x
#pg=3이고 i=1, t=True 실행
if i == pg - 2 and t:
#To RGB
# 논문에선 upscale을 먼저하고 conv2d(toRGB)를 하도록 되어 있는데 텐서플로우 변수 이름의 중복때문에 어쩔수 없이 conv를 먼저
de_iden = conv2d(de,
output_dim=3,
k_w=1,
k_h=1,
d_w=1,
d_h=1,
name='gen_y_rgb_conv_{}'.format(
de.shape[1]))
de_iden = upscale(de_iden, 2)
de = upscale(de, 2)
# i=0일때 get_nf(0+1) = 512
# i=1일때 get_ng(1+1) = 256
de = Pixl_Norm(
lrelu(
conv2d(de,
output_dim=self.get_nf(i + 1),
d_w=1,
d_h=1,
name='gen_n_conv_1_{}'.format(de.shape[1]))))
de = Pixl_Norm(
lrelu(
conv2d(de,
output_dim=self.get_nf(i + 1),
d_w=1,
d_h=1,
name='gen_n_conv_2_{}'.format(de.shape[1]))))
#To RGB
de = conv2d(de,
output_dim=3,
k_w=1,
k_h=1,
d_w=1,
d_h=1,
name='gen_y_rgb_conv_{}'.format(de.shape[1]))
if pg == 1:
return de
# transition이 True일때
if t:
de = (1 - alpha_trans) * de_iden + alpha_trans * de
else:
de = de
return de
def build_model(self):
# Output functions
self.fake_images = self.generate(
self.latent,
model_progressive_depth=self.model_progressive_depth,
transition=self.transition,
alpha_transition=self.alpha_transition)
_, self.D_pro_logits = self.discriminate(
self.images,
reuse=False,
model_progressive_depth=self.model_progressive_depth,
transition=self.transition,
alpha_transition=self.alpha_transition)
_, self.G_pro_logits = self.discriminate(
self.fake_images,
reuse=True,
model_progressive_depth=self.model_progressive_depth,
transition=self.transition,
alpha_transition=self.alpha_transition)
# Loss functions
self.D_loss = tf.reduce_mean(self.G_pro_logits) - tf.reduce_mean(
self.D_pro_logits)
self.G_loss = -tf.reduce_mean(self.G_pro_logits)
# Wasserstein Loss...
self.differences = self.fake_images - self.images
self.alpha = tf.random_uniform(shape=[self.batch_size, 1, 1, 1],
minval=0.,
maxval=1.)
interpolates = self.images + (self.alpha * self.differences)
_, discri_logits = self.discriminate(
interpolates,
reuse=True,
model_progressive_depth=self.model_progressive_depth,
transition=self.transition,
alpha_transition=self.alpha_transition)
gradients = tf.gradients(discri_logits, [interpolates])[0]
# ...with gradient penalty
slopes = tf.sqrt(
tf.reduce_sum(tf.square(gradients), reduction_indices=[1, 2, 3]))
self.gradient_penalty = tf.reduce_mean((slopes - 1.)**2)
self.D_origin_loss = self.D_loss
self.D_loss += 10 * self.gradient_penalty
self.D_loss += 0.001 * tf.reduce_mean(
tf.square(self.D_pro_logits - 0.0))
# Create resolution fade-in (transition) parameters.
self.alpha_transition_assign = self.alpha_transition.assign(
self.training_step / self.iterations_per_stage)
""" A slightly magical bit of code inherited from the previous repository. Creates
multiple variable loaders in Tensorflow. When going up a resolution, variables
from the previous resolution are preserved, while new variables are left untouched.
Tensorflow throws a fit if you try to load variables that aren't present in your
provided model file, so this system circumvents that without loading the full
model every run.
"""
t_vars = tf.trainable_variables()
self.d_vars = [var for var in t_vars if 'dis' in var.name]
self.g_vars = [var for var in t_vars if 'gen' in var.name]
# Save the variables, which remain unchanged
self.d_vars_n = [var for var in self.d_vars if 'dis_n' in var.name]
self.g_vars_n = [var for var in self.g_vars if 'gen_n' in var.name]
# Remove the new variables for the new model
self.d_vars_n_read = [
var for var in self.d_vars_n
if '{}'.format(self.model_output_size) not in var.name
]
self.g_vars_n_read = [
var for var in self.g_vars_n
if '{}'.format(self.model_output_size) not in var.name
]
# Save the rgb variables, which remain unchanged
self.d_vars_n_2 = [
var for var in self.d_vars if 'dis_y_rgb_conv' in var.name
]
self.g_vars_n_2 = [
var for var in self.g_vars if 'gen_y_rgb_conv' in var.name
]
self.d_vars_n_2_rgb = [
var for var in self.d_vars_n_2
if '{}'.format(self.model_output_size) not in var.name
]
self.g_vars_n_2_rgb = [
var for var in self.g_vars_n_2
if '{}'.format(self.model_output_size) not in var.name
]
self.saver = tf.train.Saver(self.d_vars + self.g_vars)
self.r_saver = tf.train.Saver(self.d_vars_n_read + self.g_vars_n_read)
if len(self.d_vars_n_2_rgb + self.g_vars_n_2_rgb):
self.rgb_saver = tf.train.Saver(self.d_vars_n_2_rgb +
self.g_vars_n_2_rgb)
# Create Optimizers
self.opti_D = tf.train.AdamOptimizer(learning_rate=self.learning_rate,
beta1=0.0,
beta2=0.99).minimize(
self.D_loss,
var_list=self.d_vars)
self.opti_G = tf.train.AdamOptimizer(learning_rate=self.learning_rate,
beta1=0.0,
beta2=0.99).minimize(
self.G_loss,
var_list=self.g_vars)
# Data Loading Tools
self.low_images = upscale(downscale(self.images, 2), 2)
self.real_images = self.alpha_transition * self.images + (
1 - self.alpha_transition) * self.low_images
# Tensorboard Logging Variables
tf.summary.scalar("gp_loss", self.gradient_penalty)
self.log_vars.append(("generator_loss", self.G_loss))
self.log_vars.append(("discriminator_loss", self.D_loss))
for k, v in self.log_vars:
tf.summary.scalar(k, v)
# if self.verbose:
# for layer in tf.trainable_variables():
# print(layer)
return
def generate(self,
latent_var,
model_progressive_depth=1,
transition=False,
alpha_transition=0.0,
reuse=False):
with tf.variable_scope('generator') as scope:
if reuse:
scope.reuse_variables()
convs = []
convs += [
tf.reshape(latent_var,
[self.batch_size, 1, 1, self.latent_size])
]
convs[-1] = pixel_norm(
lrelu(
conv2d(convs[-1],
output_dim=self.get_filter_num(1),
k_h=4,
k_w=4,
d_w=1,
d_h=1,
padding='Other',
name='gen_n_1_conv')))
convs += [
tf.reshape(convs[-1],
[self.batch_size, 4, 4,
self.get_filter_num(1)])
]
convs[-1] = pixel_norm(
lrelu(
conv2d(convs[-1],
output_dim=self.get_filter_num(1),
d_w=1,
d_h=1,
name='gen_n_2_conv')))
for i in range(model_progressive_depth - 1):
if i == model_progressive_depth - 2 and transition:
# To RGB, low resolution
transition_conv = conv2d(convs[-1],
output_dim=self.channels,
k_w=1,
k_h=1,
d_w=1,
d_h=1,
name='gen_y_rgb_conv_{}'.format(
convs[-1].shape[1]))
transition_conv = upscale(transition_conv, 2)
convs += [upscale(convs[-1], 2)]
convs[-1] = pixel_norm(
lrelu(
conv2d(convs[-1],
output_dim=self.get_filter_num(i + 1),
d_w=1,
d_h=1,
name='gen_n_conv_1_{}'.format(
convs[-1].shape[1]))))
convs += [
pixel_norm(
lrelu(
conv2d(convs[-1],
output_dim=self.get_filter_num(i + 1),
d_w=1,
d_h=1,
name='gen_n_conv_2_{}'.format(
convs[-1].shape[1]))))
]
# To RGB, high resolution
convs += [
conv2d(convs[-1],
output_dim=self.channels,
k_w=1,
k_h=1,
d_w=1,
d_h=1,
name='gen_y_rgb_conv_{}'.format(convs[-1].shape[1]))
]
if transition:
convs[-1] = (1 - alpha_transition
) * transition_conv + alpha_transition * convs[-1]
return convs[-1]