def testFunctionalConv2DTransposeNoReuse(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
conv_layers.conv2d_transpose(images, 32, [3, 3])
self.assertEqual(len(variables.trainable_variables()), 2)
conv_layers.conv2d_transpose(images, 32, [3, 3])
self.assertEqual(len(variables.trainable_variables()), 4)
def testFunctionalConv2DTransposeNoReuse(self): height, width = 7, 9 images = random_ops.random_uniform((5, height, width, 3), seed=1) conv_layers.conv2d_transpose(images, 32, [3, 3]) self.assertEqual(len(variables.trainable_variables()), 2) conv_layers.conv2d_transpose(images, 32, [3, 3]) self.assertEqual(len(variables.trainable_variables()), 4)
def testInvalidKernelSize(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
with self.assertRaisesRegexp(ValueError, 'kernel_size'):
conv_layers.conv2d_transpose(images, 32, (1, 2, 3))
with self.assertRaisesRegexp(ValueError, 'kernel_size'):
conv_layers.conv2d_transpose(images, 32, None)
def testInvalidStrides(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
with self.assertRaisesRegexp(ValueError, 'strides'):
conv_layers.conv2d_transpose(images, 32, 3, strides=(1, 2, 3))
with self.assertRaisesRegexp(ValueError, 'strides'):
conv_layers.conv2d_transpose(images, 32, 3, strides=None)
def testInvalidKernelSize(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
with self.assertRaisesRegexp(ValueError, 'kernel_size'):
conv_layers.conv2d_transpose(images, 32, (1, 2, 3))
with self.assertRaisesRegexp(ValueError, 'kernel_size'):
conv_layers.conv2d_transpose(images, 32, None)
def testInvalidStrides(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
with self.assertRaisesRegexp(ValueError, 'strides'):
conv_layers.conv2d_transpose(images, 32, 3, strides=(1, 2, 3))
with self.assertRaisesRegexp(ValueError, 'strides'):
conv_layers.conv2d_transpose(images, 32, 3, strides=None)
def testFunctionalConv2DTransposeReuseFromScope(self):
with variable_scope.variable_scope('scope'):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
conv_layers.conv2d_transpose(images, 32, [3, 3], name='deconv1')
self.assertEqual(len(variables.trainable_variables()), 2)
with variable_scope.variable_scope('scope', reuse=True):
conv_layers.conv2d_transpose(images, 32, [3, 3], name='deconv1')
self.assertEqual(len(variables.trainable_variables()), 2)
def testFunctionalConv2DTransposeNoReuse(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
conv_layers.conv2d_transpose(images, 32, [3, 3])
self.assertEqual(
len(ops.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES)), 2)
conv_layers.conv2d_transpose(images, 32, [3, 3])
self.assertEqual(
len(ops.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES)), 4)
def testFunctionalConv2DTransposeReuseFromScope(self):
with variable_scope.variable_scope('scope'):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
conv_layers.conv2d_transpose(images, 32, [3, 3], name='deconv1')
self.assertEqual(len(variables.trainable_variables()), 2)
with variable_scope.variable_scope('scope', reuse=True):
conv_layers.conv2d_transpose(images, 32, [3, 3], name='deconv1')
self.assertEqual(len(variables.trainable_variables()), 2)
def testConv2DTransposeFloat16(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 4), dtype='float16')
output = conv_layers.conv2d_transpose(images, 32, [3, 3],
activation=nn_ops.relu)
self.assertListEqual(output.get_shape().as_list(),
[5, height + 2, width + 2, 32])
def testConv2DTransposeFloat16(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 4), dtype='float16')
output = conv_layers.conv2d_transpose(images, 32, [3, 3],
activation=nn_ops.relu)
self.assertListEqual(output.get_shape().as_list(),
[5, height + 2, width + 2, 32])
def testFunctionalConv2DTransposeInitializerFromScope(self):
with self.test_session() as sess:
with variable_scope.variable_scope(
'scope', initializer=init_ops.ones_initializer()):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
conv_layers.conv2d_transpose(images, 32, [3, 3], name='deconv1')
weights = variables.trainable_variables()
# Check the names of weights in order.
self.assertTrue('kernel' in weights[0].name)
self.assertTrue('bias' in weights[1].name)
sess.run(variables.global_variables_initializer())
weights = sess.run(weights)
# Check that the kernel weights got initialized to ones (from scope)
self.assertAllClose(weights[0], np.ones((3, 3, 32, 3)))
# Check that the bias still got initialized to zeros.
self.assertAllClose(weights[1], np.zeros((32)))
def testFunctionalConv2DTransposeInitializerFromScope(self):
with self.test_session() as sess:
with variable_scope.variable_scope(
'scope', initializer=init_ops.ones_initializer()):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
conv_layers.conv2d_transpose(images, 32, [3, 3], name='deconv1')
weights = variables.trainable_variables()
# Check the names of weights in order.
self.assertTrue('kernel' in weights[0].name)
self.assertTrue('bias' in weights[1].name)
sess.run(variables.global_variables_initializer())
weights = sess.run(weights)
# Check that the kernel weights got initialized to ones (from scope)
self.assertAllClose(weights[0], np.ones((3, 3, 32, 3)))
# Check that the bias still got initialized to zeros.
self.assertAllClose(weights[1], np.zeros((32)))
def _upsample(self, inputs, k):
x = inputs
for i in reversed(range(0, k)):
x = conv2d_transpose(inputs=x, filters=self.num_classes * 2 ** i, kernel_size=4, strides=2, padding='same')
x = dropout(x, rate=self.dropout_prob)
x = self._add_common_layers(x)
return x
def build_generator(noise, caption, reuse=False):
with tf.variable_scope("generator") as scope:
if reuse:
tf.get_variable_scope().reuse_variables()
#
t_noise = noise
t_txt = caption
t_txt = dense(inputs=t_txt, units=128, activation=my_leaky_relu)
t_input = tf.concat(values=[t_noise, t_txt], axis=1)
t0 = dense(inputs=t_input, units=128 * 8 * 4 * 4)
t0 = batch_normalization(inputs=t0)
t0 = tf.reshape(tensor=t0, shape=[-1, 4, 4, 128 * 8])
t = conv2d(inputs=t0,
filters=256,
kernel_size=[1, 1],
strides=[1, 1],
padding="valid",
activation=my_leaky_relu)
t = batch_normalization(inputs=t)
t = conv2d(inputs=t,
filters=256,
kernel_size=[3, 3],
strides=[1, 1],
padding="same",
activation=my_leaky_relu)
t = batch_normalization(inputs=t)
t = conv2d(inputs=t,
filters=128 * 8,
kernel_size=[3, 3],
strides=[1, 1],
padding="same")
t = batch_normalization(inputs=t)
t1 = tf.add(t0, t)
t2 = conv2d_transpose(inputs=t1,
filters=128 * 4,
kernel_size=[3, 3],
strides=[2, 2],
padding="same")
t2 = batch_normalization(inputs=t2)
t = conv2d(inputs=t2,
filters=128,
kernel_size=[1, 1],
strides=[1, 1],
padding="valid",
activation=my_leaky_relu)
t = batch_normalization(inputs=t)
t = conv2d(inputs=t,
filters=128,
kernel_size=[3, 3],
strides=[1, 1],
padding="same",
activation=my_leaky_relu)
t = batch_normalization(inputs=t)
t = conv2d(inputs=t,
filters=128 * 4,
kernel_size=[3, 3],
strides=[1, 1],
padding="same")
t = batch_normalization(inputs=t)
t3 = tf.add(t2, t)
t4 = conv2d_transpose(inputs=t3,
filters=128 * 2,
kernel_size=[3, 3],
strides=[2, 2],
padding="same",
activation=my_leaky_relu)
t4 = batch_normalization(inputs=t4)
t5 = conv2d_transpose(inputs=t4,
filters=128,
kernel_size=[3, 3],
strides=[2, 2],
padding="same",
activation=my_leaky_relu)
t5 = batch_normalization(inputs=t5)
t_output = conv2d_transpose(inputs=t5,
filters=3,
kernel_size=[3, 3],
strides=[2, 2],
padding="same",
activation=tf.tanh)
print("\nGenerator Output Shape: {}".format(t_output.shape))
return t_output
def __init__(self,
in_shape,
lr=0.001,
embedding_dim=50,
num_projections=20):
'''
classes: List of class names or integers corrisponding to each class being classified
by the network. ie: ['left', 'straight', 'right'] or [0, 1, 2]
'''
# number of elements in the embedding vector
self.embedding_dim = embedding_dim
# number of test embeddings to project in tensorboard
self.num_projections = num_projections
# Define model
tf.reset_default_graph()
self.x = tf.placeholder(tf.float32,
shape=[
None,
] + in_shape,
name="x")
self.y = tf.placeholder(tf.float32,
shape=[
None,
] + in_shape,
name="y")
self._training = tf.placeholder(tf.bool)
self.training = tf.get_variable("training",
dtype=tf.bool,
initializer=True,
trainable=False)
self.set_training = self.training.assign(self._training)
self._beta = tf.placeholder(dtype=tf.float32)
self.beta = tf.get_variable("beta",
dtype=tf.float32,
initializer=0.,
trainable=False)
self.update_beta = self.beta.assign(self._beta)
self._embeddings = tf.placeholder(tf.float32,
shape=[None, self.embedding_dim])
self.embeddings = tf.get_variable(
"embeddings",
dtype=tf.float32,
shape=[self.num_projections, self.embedding_dim],
initializer=tf.zeros_initializer(),
trainable=False)
self.update_embeddings = self.embeddings.assign(self._embeddings)
paddings = tf.constant([[0, 0], [4, 4], [0, 0], [0, 0]])
relu = tf.nn.relu
sigmoid = tf.nn.sigmoid
with tf.name_scope("encoder"):
# Padding invector so reconstruction returns to the correct size.
#x_padded = tf.pad(self.x, paddings, "SYMMETRIC")
# Encoder in num shape stride pad
enc = conv2d(self.x,
32, (5, 5), (2, 2),
"valid",
activation=relu,
kernel_initializer=xavier()) # 59x79
print(f"enc1: {np.shape(enc)}")
enc = conv2d(enc,
62, (5, 5), (2, 2),
"valid",
activation=relu,
kernel_initializer=xavier()) # 28x38
print(f"enc2: {np.shape(enc)}")
enc = conv2d(enc,
128, (4, 4), (2, 2),
"valid",
activation=relu,
kernel_initializer=xavier()) # 13x18
print(f"enc3: {np.shape(enc)}")
enc = conv2d(enc,
256, (4, 4), (2, 2),
"valid",
activation=relu,
kernel_initializer=xavier()) # 5x8
print(f"enc4: {np.shape(enc)}")
enc = flatten(enc)
with tf.name_scope("sampling"):
# VAE sampling
'''
Note: exp(log(log_sigma / 2)) = sigma
'''
self.mu = dense(enc,
self.embedding_dim,
activation=None,
kernel_initializer=xavier(),
name="mu")
self.log_sigma = dense(enc,
self.embedding_dim,
activation=None,
kernel_initializer=xavier(),
name="log_sigma")
eps = tf.random_normal(shape=tf.shape(self.mu),
mean=0.0,
stddev=1.0,
dtype=tf.float32,
name="eps")
self.noisy_sigma = tf.exp(self.log_sigma) * eps
self.z = tf.add(self.mu, self.noisy_sigma, name="z")
#tf.summary.histogram("z", self.z)
#tf.summary.histogram("log_sigma", self.log_sigma)
#tf.summary.histogram("mu", self.mu)
#tf.summary.histogram("eps", eps)
with tf.name_scope("decoder"):
# Decoder in num
dec = dense(self.z, (256 * 5 * 7),
activation=relu,
kernel_initializer=xavier())
print(f"dec4: {np.shape(dec)}")
dec = tf.reshape(dec, (-1, 5, 7, 256))
print(f"dec3: {np.shape(dec)}")
# in num shape stride pad
dec = conv2d_transpose(dec,
128, (4, 4), (2, 2),
"valid",
activation=relu)
print(f"dec2: {np.shape(dec)}")
dec = conv2d_transpose(dec,
64, (4, 4), (2, 2),
"valid",
activation=relu)
print(f"dec1: {np.shape(dec)}")
dec = conv2d_transpose(dec,
32, (6, 6), (2, 2),
"valid",
activation=relu)
print(f"dec0: {np.shape(dec)}")
self.dec = conv2d_transpose(dec,
3, (10, 18), (2, 2),
"valid",
activation=sigmoid,
name="reconstruction")
print(f"out: {np.shape(self.dec)}")
# self.dec = relu(dec7, name="reconstruction")
with tf.name_scope("loss"):
# # VAE Loss
# 1. Reconstruction loss: How far did we get from the actual image?
#y_padded = tf.pad(self.y, paddings, "SYMMETRIC")
self.rec_loss = tf.reduce_sum(tf.square(self.y - self.dec),
axis=[1, 2, 3])
# Cross entropy loss from:
# https://stats.stackexchange.com/questions/332179/
# how-to-weight-kld-loss-vs-reconstruction-
# loss-in-variational-auto-encod
# Must have self.dec activation as sigmoid
# clipped = tf.clip_by_value(self.dec, 1e-8, 1-1e-8)
# self.rec_loss = -tf.reduce_sum(self.y * tf.log(clipped)
# + (1-self.y) * tf.log(1-clipped), axis=[1,2,3])
# 2. KL-Divergence: How far from the distribution 'z' is sampled
# from the desired zero mean unit variance?
self.kl_loss = 0.5 * tf.reduce_sum(
tf.square(self.mu) +
(tf.exp(2 * self.log_sigma)) - 2 * self.log_sigma - 1,
axis=1)
self.loss = tf.reduce_mean(self.rec_loss +
self.kl_loss * self.beta,
name='total_loss')
tf.summary.scalar("total_loss", self.loss)
tf.summary.scalar("kl_loss", tf.reduce_mean(self.kl_loss))
tf.summary.scalar("rec_loss", tf.reduce_mean(self.rec_loss))
tf.summary.scalar("beta", self.beta)
update_tensor_dict(INPUTS, IMAGE_INPUT, self.x)
update_tensor_dict(OUTPUTS, EMBEDDING, self.z)
update_tensor_dict(OUTPUTS, RECONSTRUCTION, self.dec)
optimizer = tf.train.AdamOptimizer(learning_rate=lr)
self.train_step = optimizer.minimize(self.loss, name="train_step")
self.init_vars = tf.global_variables_initializer()
self.saver = tf.train.Saver()
def testInvalidDataFormat(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
with self.assertRaisesRegexp(ValueError, 'data_format'):
conv_layers.conv2d_transpose(images, 32, 3, data_format='invalid')
def __init__(self,
in_shape,
lr=0.001,
embedding_dim=50,
num_projections=20):
'''
classes: List of class names or integers corrisponding to each class being classified
by the network. ie: ['left', 'straight', 'right'] or [0, 1, 2]
'''
# number of elements in the embedding vector
self.embedding_dim = embedding_dim
# number of test embeddings to project in tensorboard
self.num_projections = num_projections
# Define model
tf.reset_default_graph()
self.x = tf.placeholder(tf.float32,
shape=[
None,
] + in_shape,
name="x")
self.y = tf.placeholder(tf.float32,
shape=[
None,
] + in_shape,
name="y")
self._training = tf.placeholder(tf.bool)
self.training = tf.get_variable("training",
dtype=tf.bool,
initializer=True,
trainable=False)
self.set_training = self.training.assign(self._training)
self._embeddings = tf.placeholder(tf.float32,
shape=[None, self.embedding_dim])
self.embeddings = tf.get_variable(
"embeddings",
dtype=tf.float32,
shape=[self.num_projections, self.embedding_dim],
initializer=tf.zeros_initializer(),
trainable=False)
self.update_embeddings = self.embeddings.assign(self._embeddings)
paddings = tf.constant([[0, 0], [4, 4], [0, 0], [0, 0]])
relu = tf.nn.relu
sigmoid = tf.nn.sigmoid
with tf.name_scope("encoder"):
# Padding invector so reconstruction returns to the correct size.
x_padded = tf.pad(self.x, paddings, "SYMMETRIC")
# Encoder in num shape stride pad
enc1 = conv2d(x_padded,
24, (5, 5), (2, 2),
"same",
activation=relu,
kernel_initializer=xavier(),
name="enc1") # 64, 80,24
enc2 = conv2d(enc1,
32, (5, 5), (2, 2),
"same",
activation=relu,
kernel_initializer=xavier(),
name="enc2") # 32, 40,32
enc3 = conv2d(enc2,
64, (5, 5), (2, 2),
"same",
activation=relu,
kernel_initializer=xavier(),
name="enc3") # 16, 20,64
enc4 = conv2d(enc3,
64, (3, 3), (2, 2),
"same",
activation=relu,
kernel_initializer=xavier(),
name="enc4") # 8, 10,64
enc5 = conv2d(enc4,
64, (3, 3), (1, 1),
"same",
activation=relu,
kernel_initializer=xavier(),
name="enc5") # 8, 10,64
enc5f = flatten(enc5)
# in num
enc6 = dense(enc5f,
100,
activation=relu,
kernel_initializer=xavier(),
name="enc6")
enc6d = dropout(enc6,
rate=0.1,
training=self.training,
name="enc6d")
with tf.name_scope("embedding"):
# Autoencoder embedding
self.z = dense(enc6d,
self.embedding_dim,
activation=relu,
kernel_initializer=xavier(),
name="z")
tf.summary.histogram("z", self.z)
with tf.name_scope("decoder"):
# Decoder in num
dec1 = dense(self.z,
100,
activation=relu,
kernel_initializer=xavier(),
name="dec1")
dec2 = dense(dec1, (8 * 10 * 64),
activation=relu,
kernel_initializer=xavier(),
name="dec2")
dec2r = tf.reshape(dec2, (-1, 8, 10, 64))
# in num shape stride pad
dec3 = conv2d_transpose(dec2r,
64, (3, 3), (1, 1),
"same",
activation=relu,
name="dec3")
dec4 = conv2d_transpose(dec3,
64, (3, 3), (2, 2),
"same",
activation=relu,
name="dec4")
dec5 = conv2d_transpose(dec4,
32, (5, 5), (2, 2),
"same",
activation=relu,
name="dec5")
dec6 = conv2d_transpose(dec5,
24, (5, 5), (2, 2),
"same",
activation=relu,
name="dec6")
dec7 = conv2d_transpose(dec6,
3, (5, 5), (2, 2),
"same",
activation=None,
name="dec8")
self.dec = relu(dec7, name="reconstruction")
with tf.name_scope("loss"):
# # VAE Loss
# 1. Reconstruction loss: How far did we get from the actual image?
y_padded = tf.pad(self.y, paddings, "SYMMETRIC")
self.rec_loss = tf.reduce_sum(tf.square(y_padded - self.dec),
axis=[1, 2, 3])
self.loss = tf.reduce_mean(self.rec_loss, name='total_loss')
tf.summary.scalar("total_loss", self.loss)
update_tensor_dict(INPUTS, IMAGE_INPUT, self.x)
update_tensor_dict(OUTPUTS, EMBEDDING, self.z)
update_tensor_dict(OUTPUTS, RECONSTRUCTION, self.dec)
optimizer = tf.train.AdamOptimizer(learning_rate=lr)
self.train_step = optimizer.minimize(self.loss, name="train_step")
self.init_vars = tf.global_variables_initializer()
self.saver = tf.train.Saver()
def testInvalidDataFormat(self):
height, width = 7, 9
images = random_ops.random_uniform((5, height, width, 3), seed=1)
with self.assertRaisesRegexp(ValueError, 'data_format'):
conv_layers.conv2d_transpose(images, 32, 3, data_format='invalid')