def model(self, latent, depth, scales, noise):
x = tf.placeholder(tf.float32,
[None, self.height, self.width, self.colors], 'x')
l = tf.placeholder(tf.float32, [None, self.nclass], 'label')
h = tf.placeholder(
tf.float32,
[None, self.height >> scales, self.width >> scales, latent], 'h')
xn = x + tf.random_normal(tf.shape(x), stddev=noise)
encode = layers.encoder(x, scales, depth, latent, 'ae_encoder')
decode = layers.decoder(h, scales, depth, self.colors, 'ae_decoder')
ae = layers.decoder(encode, scales, depth, self.colors, 'ae_decoder')
encode_noise = layers.encoder(xn, scales, depth, latent, 'ae_encoder')
ae_noise = layers.decoder(encode_noise, scales, depth, self.colors,
'ae_decoder')
loss = tf.losses.mean_squared_error(x, ae_noise)
utils.HookReport.log_tensor(loss, 'loss')
utils.HookReport.log_tensor(tf.sqrt(loss) * 127.5, 'rmse')
xops = classifiers.single_layer_classifier(tf.stop_gradient(encode), l,
self.nclass)
xloss = tf.reduce_mean(xops.loss)
utils.HookReport.log_tensor(xloss, 'classify_latent')
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_op = tf.train.AdamOptimizer(FLAGS.lr)
train_op = train_op.minimize(loss + xloss,
tf.train.get_global_step())
ops = train.AEOps(x,
h,
l,
encode,
decode,
ae,
train_op,
classify_latent=xops.output)
def gen_images():
return self.make_sample_grid_and_save(ops)
recon, inter, slerp, samples = tf.py_func(gen_images, [],
[tf.float32] * 4)
tf.summary.image('reconstruction', tf.expand_dims(recon, 0))
tf.summary.image('interpolation', tf.expand_dims(inter, 0))
tf.summary.image('slerp', tf.expand_dims(slerp, 0))
tf.summary.image('samples', tf.expand_dims(samples, 0))
return ops
def disc(x):
# similar shape to encoder
# last input is scalar(reduce mean of hidden layer) in order to map alpha
# FIXME: why dont sigmoid output
return tf.reduce_mean(layers.encoder(x, scales, advdepth, latent,
'disc'),
axis=[1, 2, 3])
def model(self, latent, depth, scales, noise):
x = tf.placeholder(tf.float32,
[None, self.height, self.width, self.colors], 'x')
l = tf.placeholder(tf.float32, [None, self.nclass], 'label')
h = tf.placeholder(
tf.float32,
[None, self.height >> scales, self.width >> scales, latent], 'h')
xn = x + tf.random_normal(tf.shape(x), stddev=noise)
encode = layers.encoder(x, scales, depth, latent, 'ae_encoder')
decode = layers.decoder(h, scales, depth, self.colors, 'ae_decoder')
ae = layers.decoder(encode, scales, depth, self.colors, 'ae_decoder')
encode_noise = layers.encoder(xn, scales, depth, latent, 'ae_encoder')
ae_noise = layers.decoder(encode_noise, scales, depth, self.colors,
'ae_decoder')
loss = tf.losses.mean_squared_error(x, ae_noise)
utils.HookReport.log_tensor(loss, 'loss')
utils.HookReport.log_tensor(tf.sqrt(loss) * 127.5, 'rmse')
xops = classifiers.single_layer_classifier(
tf.stop_gradient(encode), l, self.nclass)
xloss = tf.reduce_mean(xops.loss)
utils.HookReport.log_tensor(xloss, 'classify_latent')
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
train_op = tf.train.AdamOptimizer(FLAGS.lr)
train_op = train_op.minimize(loss + xloss,
tf.train.get_global_step())
ops = train.AEOps(x, h, l, encode, decode, ae, train_op,
classify_latent=xops.output)
def gen_images():
return self.make_sample_grid_and_save(ops)
recon, inter, slerp, samples = tf.py_func(
gen_images, [], [tf.float32]*4)
tf.summary.image('reconstruction', tf.expand_dims(recon, 0))
tf.summary.image('interpolation', tf.expand_dims(inter, 0))
tf.summary.image('slerp', tf.expand_dims(slerp, 0))
tf.summary.image('samples', tf.expand_dims(samples, 0))
return ops
def model(self, latent, depth, scales):
"""
:param latent:
:param depth:
:param scales:
:return:
"""
print('self.nclass:', self.nclass)
# [b, 32, 32, 1]
x = tf.placeholder(tf.float32, [None, self.height, self.width, self.colors], 'x')
# [b, 10]
l = tf.placeholder(tf.float32, [None, self.nclass], 'label')
# [?, 4, 4, 16]
h = tf.placeholder(tf.float32, [None, self.height >> scales, self.width >> scales, latent], 'h')
# [b, 32, 32, 1] => [b, 4, 4, 16]
encode = layers.encoder(x, scales, depth, latent, 'ae_encoder')
# [b, 4, 4, 16] => [b, 32, 32, 1]
decode = layers.decoder(h, scales, depth, self.colors, 'ae_decoder')
# [b, 4, 4, 16] => [b, 32, 32, 1], auto-reuse
ae = layers.decoder(encode, scales, depth, self.colors, 'ae_decoder')
#
loss = tf.losses.mean_squared_error(x, ae)
utils.HookReport.log_tensor(loss, 'loss')
# utils.HookReport.log_tensor(tf.sqrt(loss) * 127.5, 'rmse')
# we only use encode to acquire representation and wont use classification to backprop encoder
# hence we will stop_gradient(encoder)
xops = classifiers.single_layer_classifier(tf.stop_gradient(encode), l, self.nclass)
xloss = tf.reduce_mean(xops.loss)
# record classification loss on latent
utils.HookReport.log_tensor(xloss, 'classify_loss_on_h')
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops):
# since xloss is isolated from loss, here we simply write two optimizers as one optimizer
train_op = tf.train.AdamOptimizer(FLAGS.lr).minimize(loss + xloss, tf.train.get_global_step())
ops = train.AEOps(x, h, l, encode, decode, ae, train_op, classify_latent=xops.output)
n_interpolations = 16
n_images_per_interpolation = 16
def gen_images():
return self.make_sample_grid_and_save(ops, interpolation=n_interpolations, height=n_images_per_interpolation)
recon, inter, slerp, samples = tf.py_func(gen_images, [], [tf.float32]*4)
tf.summary.image('reconstruction', tf.expand_dims(recon, 0))
tf.summary.image('interpolation', tf.expand_dims(inter, 0))
tf.summary.image('slerp', tf.expand_dims(slerp, 0))
tf.summary.image('samples', tf.expand_dims(samples, 0))
return ops
def encoder(x):
return layers.encoder(x, scales, depth, latent, 'ae_enc')
def disc(x):
# return tf.reduce_mean(layers.encoder(x, scales, advdepth, latent, 'disc'), axis=[1, 2, 3])
y = layers.encoder(x, scales, depth, latent, 'disc')
return y
def model(self, latent, depth, scales, z_log_size, beta, num_latents):
tf.set_random_seed(123)
x = tf.placeholder(tf.float32,
[None, self.height, self.width, self.colors], 'x')
l = tf.placeholder(tf.float32, [None, self.nclass], 'label')
h = tf.placeholder(
tf.float32,
[None, self.height >> scales, self.width >> scales, latent], 'h')
def decode_fn(h):
with tf.variable_scope('vqvae', reuse=tf.AUTO_REUSE):
h2 = tf.expand_dims(tf.layers.flatten(h), axis=1)
h2 = tf.layers.dense(h2,
self.hparams.hidden_size * num_latents)
d = bneck.discrete_bottleneck(h2)
y = layers.decoder(tf.reshape(d['dense'], tf.shape(h)), scales,
depth, self.colors, 'ae_decoder')
return y, d
self.hparams.hidden_size = ((self.height >> scales) *
(self.width >> scales) * latent)
self.hparams.z_size = z_log_size
self.hparams.num_residuals = 1
self.hparams.num_blocks = 1
self.hparams.beta = beta
self.hparams.ema = True
bneck = DiscreteBottleneck(self.hparams)
encode = layers.encoder(x, scales, depth, latent, 'ae_encoder')
decode = decode_fn(h)[0]
ae, d = decode_fn(encode)
loss_ae = tf.losses.mean_squared_error(x, ae)
utils.HookReport.log_tensor(tf.sqrt(loss_ae) * 127.5, 'rmse')
utils.HookReport.log_tensor(loss_ae, 'loss_ae')
utils.HookReport.log_tensor(d['loss'], 'vqvae_loss')
xops = classifiers.single_layer_classifier(
tf.stop_gradient(d['dense']), l, self.nclass)
xloss = tf.reduce_mean(xops.loss)
utils.HookReport.log_tensor(xloss, 'classify_latent')
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops + [d['discrete']]):
train_op = tf.train.AdamOptimizer(FLAGS.lr).minimize(
loss_ae + xloss + d['loss'], tf.train.get_global_step())
ops = train.AEOps(x,
h,
l,
encode,
decode,
ae,
train_op,
classify_latent=xops.output)
n_interpolations = 16
n_images_per_interpolation = 16
def gen_images():
return self.make_sample_grid_and_save(
ops,
interpolation=n_interpolations,
height=n_images_per_interpolation)
recon, inter, slerp, samples = tf.py_func(gen_images, [],
[tf.float32] * 4)
tf.summary.image('reconstruction', tf.expand_dims(recon, 0))
tf.summary.image('interpolation', tf.expand_dims(inter, 0))
tf.summary.image('slerp', tf.expand_dims(slerp, 0))
tf.summary.image('samples', tf.expand_dims(samples, 0))
return ops
def disc(x):
""" Outputs predicted mixing coefficient alpha """
return tf.reduce_mean(layers.encoder(x, scales, advdepth, latent,
'disc'),
axis=[1, 2, 3])
def encoder(x):
""" Outputs latent codes (not mean vectors) """
return layers.encoder(x, scales, depth, latent, 'ae_enc')
def disc(x):
return tf.reduce_mean(layers.encoder(x, scales, depth, latent,
'disc_img'),
axis=[1, 2, 3])
def model(self, latent, depth, scales, z_log_size, beta, num_latents):
tf.set_random_seed(123)
x = tf.placeholder(tf.float32,
[None, self.height, self.width, self.colors], 'x')
l = tf.placeholder(tf.float32, [None, self.nclass], 'label')
h = tf.placeholder(
tf.float32,
[None, self.height >> scales, self.width >> scales, latent], 'h')
def decode_fn(h):
with tf.variable_scope('vqvae', reuse=tf.AUTO_REUSE):
h2 = tf.expand_dims(tf.layers.flatten(h), axis=1)
h2 = tf.layers.dense(h2, self.hparams.hidden_size * num_latents)
d = bneck.discrete_bottleneck(h2)
y = layers.decoder(tf.reshape(d['dense'], tf.shape(h)),
scales, depth, self.colors, 'ae_decoder')
return y, d
self.hparams.hidden_size = (
(self.height >> scales) * (self.width >> scales) * latent)
self.hparams.z_size = z_log_size
self.hparams.num_residuals = 1
self.hparams.num_blocks = 1
self.hparams.beta = beta
self.hparams.ema = True
bneck = DiscreteBottleneck(self.hparams)
encode = layers.encoder(x, scales, depth, latent, 'ae_encoder')
decode = decode_fn(h)[0]
ae, d = decode_fn(encode)
loss_ae = tf.losses.mean_squared_error(x, ae)
utils.HookReport.log_tensor(tf.sqrt(loss_ae) * 127.5, 'rmse')
utils.HookReport.log_tensor(loss_ae, 'loss_ae')
utils.HookReport.log_tensor(d['loss'], 'vqvae_loss')
xops = classifiers.single_layer_classifier(
tf.stop_gradient(d['dense']), l, self.nclass)
xloss = tf.reduce_mean(xops.loss)
utils.HookReport.log_tensor(xloss, 'classify_latent')
update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
with tf.control_dependencies(update_ops + [d['discrete']]):
train_op = tf.train.AdamOptimizer(FLAGS.lr).minimize(
loss_ae + xloss + d['loss'], tf.train.get_global_step())
ops = train.AEOps(x, h, l, encode, decode, ae, train_op,
classify_latent=xops.output)
n_interpolations = 16
n_images_per_interpolation = 16
def gen_images():
return self.make_sample_grid_and_save(
ops, interpolation=n_interpolations,
height=n_images_per_interpolation)
recon, inter, slerp, samples = tf.py_func(
gen_images, [], [tf.float32]*4)
tf.summary.image('reconstruction', tf.expand_dims(recon, 0))
tf.summary.image('interpolation', tf.expand_dims(inter, 0))
tf.summary.image('slerp', tf.expand_dims(slerp, 0))
tf.summary.image('samples', tf.expand_dims(samples, 0))
return ops
def disc(x):
# [b, 32 ,32, 1] => [b, 4, 4, adv_c] => [b]
return tf.reduce_mean(layers.encoder(x, scales, advdepth, latent, 'acai_disc'), axis=[1, 2, 3])
def encoder(x):
return layers.encoder(x, scales, depth, latent, 'ae_enc')
def disc(x):
# discriminator outputs interpolation vector, we use the same architecture as encoder.
y = layers.encoder(x, scales, depth, latent, 'disc')
return y
