def test_mnist():
"""Summary
Returns
-------
name : TYPE
Description
"""
# %%
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
import matplotlib.pyplot as plt
# %%
# load MNIST as before
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
ae = VAE()
# %%
learning_rate = 0.001
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(ae['cost'])
# %%
# We create a session to use the graph
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# %%
# Fit all training data
t_i = 0
batch_size = 100
n_epochs = 50
n_examples = 20
test_xs, _ = mnist.test.next_batch(n_examples)
xs, ys = mnist.test.images, mnist.test.labels
fig_manifold, ax_manifold = plt.subplots(1, 1)
fig_reconstruction, axs_reconstruction = plt.subplots(2, n_examples, figsize=(10, 2))
fig_image_manifold, ax_image_manifold = plt.subplots(1, 1)
for epoch_i in range(n_epochs):
print('--- Epoch', epoch_i)
train_cost = 0
for batch_i in range(mnist.train.num_examples // batch_size):
batch_xs, _ = mnist.train.next_batch(batch_size)
train_cost += sess.run([ae['cost'], optimizer],
feed_dict={ae['x']: batch_xs})[0]
if batch_i % 2 == 0:
# %%
# Plot example reconstructions from latent layer
imgs = []
for img_i in np.linspace(-3, 3, n_examples):
for img_j in np.linspace(-3, 3, n_examples):
z = np.array([[img_i, img_j]], dtype=np.float32)
recon = sess.run(ae['y'], feed_dict={ae['z']: z})
imgs.append(np.reshape(recon, (1, 28, 28, 1)))
imgs_cat = np.concatenate(imgs)
ax_manifold.imshow(montage_batch(imgs_cat))
fig_manifold.savefig('manifold_%08d.png' % t_i)
# %%
# Plot example reconstructions
recon = sess.run(ae['y'], feed_dict={ae['x']: test_xs})
print(recon.shape)
for example_i in range(n_examples):
axs_reconstruction[0][example_i].imshow(
np.reshape(test_xs[example_i, :], (28, 28)),
cmap='gray')
axs_reconstruction[1][example_i].imshow(
np.reshape(
np.reshape(recon[example_i, ...], (784,)),
(28, 28)),
cmap='gray')
axs_reconstruction[0][example_i].axis('off')
axs_reconstruction[1][example_i].axis('off')
fig_reconstruction.savefig('reconstruction_%08d.png' % t_i)
# %%
# Plot manifold of latent layer
zs = sess.run(ae['z'], feed_dict={ae['x']: xs})
ax_image_manifold.clear()
ax_image_manifold.scatter(zs[:, 0], zs[:, 1],
c=np.argmax(ys, 1), alpha=0.2)
ax_image_manifold.set_xlim([-6, 6])
ax_image_manifold.set_ylim([-6, 6])
ax_image_manifold.axis('off')
fig_image_manifold.savefig('image_manifold_%08d.png' % t_i)
t_i += 1
print('Train cost:', train_cost /
(mnist.train.num_examples // batch_size))
valid_cost = 0
for batch_i in range(mnist.validation.num_examples // batch_size):
batch_xs, _ = mnist.validation.next_batch(batch_size)
valid_cost += sess.run([ae['cost']],
feed_dict={ae['x']: batch_xs})[0]
print('Validation cost:', valid_cost /
(mnist.validation.num_examples // batch_size))
def test_mnist():
"""Summary
Returns
-------
name : TYPE
Description
"""
# %%
import tensorflow as tf
import tensorflow.examples.tutorials.mnist.input_data as input_data
import matplotlib.pyplot as plt
# %%
# load MNIST as before
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
ae = VAE()
# %%
learning_rate = 0.001
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(ae['cost'])
# %%
# We create a session to use the graph
sess = tf.Session()
sess.run(tf.global_variables_initializer())
# %%
# Fit all training data
t_i = 0
batch_size = 100
n_epochs = 50
n_examples = 20
test_xs, _ = mnist.test.next_batch(n_examples)
xs, ys = mnist.test.images, mnist.test.labels
fig_manifold, ax_manifold = plt.subplots(1, 1)
fig_reconstruction, axs_reconstruction = plt.subplots(2,
n_examples,
figsize=(10, 2))
fig_image_manifold, ax_image_manifold = plt.subplots(1, 1)
for epoch_i in range(n_epochs):
print('--- Epoch', epoch_i)
train_cost = 0
for batch_i in range(mnist.train.num_examples // batch_size):
batch_xs, _ = mnist.train.next_batch(batch_size)
train_cost += sess.run([ae['cost'], optimizer],
feed_dict={ae['x']: batch_xs})[0]
if batch_i % 2 == 0:
# %%
# Plot example reconstructions from latent layer
imgs = []
for img_i in np.linspace(-3, 3, n_examples):
for img_j in np.linspace(-3, 3, n_examples):
z = np.array([[img_i, img_j]], dtype=np.float32)
recon = sess.run(ae['y'], feed_dict={ae['z']: z})
imgs.append(np.reshape(recon, (1, 28, 28, 1)))
imgs_cat = np.concatenate(imgs)
ax_manifold.imshow(montage_batch(imgs_cat))
fig_manifold.savefig('manifold_%08d.png' % t_i)
# %%
# Plot example reconstructions
recon = sess.run(ae['y'], feed_dict={ae['x']: test_xs})
print(recon.shape)
for example_i in range(n_examples):
axs_reconstruction[0][example_i].imshow(np.reshape(
test_xs[example_i, :], (28, 28)),
cmap='gray')
axs_reconstruction[1][example_i].imshow(np.reshape(
np.reshape(recon[example_i, ...], (784, )), (28, 28)),
cmap='gray')
axs_reconstruction[0][example_i].axis('off')
axs_reconstruction[1][example_i].axis('off')
fig_reconstruction.savefig('reconstruction_%08d.png' % t_i)
# %%
# Plot manifold of latent layer
zs = sess.run(ae['z'], feed_dict={ae['x']: xs})
ax_image_manifold.clear()
ax_image_manifold.scatter(zs[:, 0],
zs[:, 1],
c=np.argmax(ys, 1),
alpha=0.2)
ax_image_manifold.set_xlim([-6, 6])
ax_image_manifold.set_ylim([-6, 6])
ax_image_manifold.axis('off')
fig_image_manifold.savefig('image_manifold_%08d.png' % t_i)
t_i += 1
print('Train cost:',
train_cost / (mnist.train.num_examples // batch_size))
valid_cost = 0
for batch_i in range(mnist.validation.num_examples // batch_size):
batch_xs, _ = mnist.validation.next_batch(batch_size)
valid_cost += sess.run([ae['cost']], feed_dict={ae['x']:
batch_xs})[0]
print('Validation cost:',
valid_cost / (mnist.validation.num_examples // batch_size))
def train(sess, mnist, x, loss, optimizer, y, z):
'''
data: mnist
graph: x, loss, optimizer, y, z
'''
# %%
# Fit all training data
t_i = 0
test_xs, _ = mnist.test.next_batch(n_examples)
xs, ys = mnist.test.images, mnist.test.labels
fig_manifold, ax_manifold = plt.subplots(1, 1)
fig_reconstruction, axs_reconstruction = plt.subplots(2, n_examples, figsize=(10, 2))
fig_image_manifold, ax_image_manifold = plt.subplots(1, 1)
for epoch_i in range(n_epochs):
print('--- Epoch', epoch_i)
train_cost = 0
for batch_i in range(mnist.train.num_examples // batch_size):
batch_xs, _ = mnist.train.next_batch(batch_size)
train_cost += sess.run([loss, optimizer],
feed_dict={x: batch_xs})[0]
if batch_i % 2 == 0:
# %%
# Plot example reconstructions from latent layer
imgs = []
for img_i in np.linspace(-3, 3, n_examples):
for img_j in np.linspace(-3, 3, n_examples):
z_grid = np.array([[img_i, img_j]], dtype=np.float32)
recon = sess.run(y, feed_dict={z: z_grid})
imgs.append(np.reshape(recon, (1, 28, 28, 1)))
imgs_cat = np.concatenate(imgs)
ax_manifold.imshow(montage_batch(imgs_cat))
fig_manifold.savefig('manifold_%08d.png' % t_i)
# %%
# Plot example reconstructions
recon = sess.run(y, feed_dict={x: test_xs})
print(recon.shape)
for example_i in range(n_examples):
axs_reconstruction[0][example_i].imshow(
np.reshape(test_xs[example_i, :], (28, 28)),
cmap='gray')
axs_reconstruction[1][example_i].imshow(
np.reshape(
np.reshape(recon[example_i, ...], (784,)),
(28, 28)),
cmap='gray')
axs_reconstruction[0][example_i].axis('off')
axs_reconstruction[1][example_i].axis('off')
fig_reconstruction.savefig('reconstruction_%08d.png' % t_i)
# %%
# Plot manifold of latent layer
zs = sess.run(z, feed_dict={x: xs})
ax_image_manifold.clear()
ax_image_manifold.scatter(zs[:, 0], zs[:, 1],
c=np.argmax(ys, 1), alpha=0.2)
ax_image_manifold.set_xlim([-6, 6])
ax_image_manifold.set_ylim([-6, 6])
ax_image_manifold.axis('off')
fig_image_manifold.savefig('image_manifold_%08d.png' % t_i)
t_i += 1
print('Train cost:', train_cost /
(mnist.train.num_examples // batch_size))
valid_cost = 0
for batch_i in range(mnist.validation.num_examples // batch_size):
batch_xs, _ = mnist.validation.next_batch(batch_size)
valid_cost += sess.run([loss],
feed_dict={x: batch_xs})[0]
print('Validation cost:', valid_cost /
(mnist.validation.num_examples // batch_size))