Last active
July 2, 2019 16:03
-
-
Save prashant343/e7a8c12a484139c554c30c18f13963a8 to your computer and use it in GitHub Desktop.
Multi Layer Image Auto Encoder
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
""" Auto Encoder Example. | |
References: | |
Y. LeCun, L. Bottou, Y. Bengio, and P. Haffner. "Gradient-based | |
learning applied to document recognition." Proceedings of the IEEE, | |
86(11):2278-2324, November 1998. | |
Links: | |
[MNIST Dataset] http://yann.lecun.com/exdb/mnist/ | |
OriginalAuthor: Aymeric Damien | |
Project: https://github.com/aymericdamien/TensorFlow-Examples/ | |
""" | |
"" | |
Author : Prashant Kaushik | |
Build a Multi layers auto-encoder with TensorFlow to compress images to a | |
lower latent space and then reconstruct them. | |
COLAB Link ------- | |
https://colab.research.google.com/drive/1UgjkZqtPoSWEvxNi35yGdVDlXRGigFVo | |
"" | |
from __future__ import division, print_function, absolute_import | |
import tensorflow as tf | |
import numpy as np | |
import matplotlib.pyplot as plt | |
# Import MNIST data | |
from tensorflow.examples.tutorials.mnist import input_data | |
mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) | |
# Training Parameters | |
learning_rate = 0.005 | |
num_steps = 30000 | |
batch_size = 256 | |
display_step = 1000 | |
examples_to_show = 10 | |
# Network Parameters | |
num_hidden_1 = 256 # 1st layer num features | |
num_hidden_2 = 1280 # 2nd layer num features (the latent dim) | |
num_input = 784 # MNIST data input (img shape: 28*28) | |
# tf Graph input (only pictures) | |
X = tf.placeholder("float", [None, num_input]) | |
weights = { | |
'encoder_h1': tf.Variable(tf.random_normal([num_input, num_hidden_1])), | |
'encoder_h2': tf.Variable(tf.random_normal([num_hidden_1, num_hidden_2])), | |
'decoder_h1': tf.Variable(tf.random_normal([num_hidden_2, num_hidden_1])), | |
'decoder_h2': tf.Variable(tf.random_normal([num_hidden_1, num_input])), | |
} | |
biases = { | |
'encoder_b1': tf.Variable(tf.random_normal([num_hidden_1])), | |
'encoder_b2': tf.Variable(tf.random_normal([num_hidden_2])), | |
'decoder_b1': tf.Variable(tf.random_normal([num_hidden_1])), | |
'decoder_b2': tf.Variable(tf.random_normal([num_input])), | |
} | |
# Building the encoder | |
def encoder(x): | |
# Encoder Hidden layer with sigmoid activation #1 | |
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['encoder_h1']), | |
biases['encoder_b1'])) | |
# Encoder Hidden layer with sigmoid activation #2 | |
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['encoder_h2']), | |
biases['encoder_b2'])) | |
return layer_2 | |
# Building the decoder | |
def decoder(x): | |
# Decoder Hidden layer with sigmoid activation #1 | |
layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, weights['decoder_h1']), | |
biases['decoder_b1'])) | |
# Decoder Hidden layer with sigmoid activation #2 | |
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, weights['decoder_h2']), | |
biases['decoder_b2'])) | |
return layer_2 | |
# Construct model | |
encoder_op = encoder(X) | |
decoder_op = decoder(encoder_op) | |
# Prediction | |
y_pred = decoder_op | |
# Targets (Labels) are the input data. | |
y_true = X | |
# Define loss and optimizer, minimize the squared error | |
loss = tf.reduce_mean(tf.pow(y_true - y_pred, 2)) | |
optimizer = tf.train.RMSPropOptimizer(learning_rate).minimize(loss) | |
# Initialize the variables (i.e. assign their default value) | |
init = tf.global_variables_initializer() | |
# Start Training | |
# Start a new TF session | |
with tf.Session() as sess: | |
# Run the initializer | |
sess.run(init) | |
# Training | |
for i in range(1, num_steps+1): | |
# Prepare Data | |
# Get the next batch of MNIST data (only images are needed, not labels) | |
batch_x, _ = mnist.train.next_batch(batch_size) | |
# Run optimization op (backprop) and cost op (to get loss value) | |
_, l = sess.run([optimizer, loss], feed_dict={X: batch_x}) | |
# Display logs per step | |
if i % display_step == 0 or i == 1: | |
print('Step %i: Minibatch Loss: %f' % (i, l)) | |
# Testing | |
# Encode and decode images from test set and visualize their reconstruction. | |
n = 4 | |
canvas_orig = np.empty((28 * n, 28 * n)) | |
canvas_recon = np.empty((28 * n, 28 * n)) | |
for i in range(n): | |
# MNIST test set | |
batch_x, _ = mnist.test.next_batch(n) | |
# Encode and decode the digit image | |
g = sess.run(decoder_op, feed_dict={X: batch_x}) | |
# Display original images | |
for j in range(n): | |
# Draw the original digits | |
canvas_orig[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28] = \ | |
batch_x[j].reshape([28, 28]) | |
# Display reconstructed images | |
for j in range(n): | |
# Draw the reconstructed digits | |
canvas_recon[i * 28:(i + 1) * 28, j * 28:(j + 1) * 28] = \ | |
g[j].reshape([28, 28]) | |
print("Original Images") | |
plt.figure(figsize=(n, n)) | |
plt.imshow(canvas_orig, origin="upper", cmap="gray") | |
plt.show() | |
print("Reconstructed Images") | |
plt.figure(figsize=(n, n)) | |
plt.imshow(canvas_recon, origin="upper", cmap="gray") | |
plt.show() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment