MNIST Tensorflow example

import tensorflow as tf

import matplotlib

matplotlib.use('agg')

import numpy as np

import pandas as pd

import matplotlib.pyplot as plt

import seaborn as sns

import random

import itertools

from sklearn.manifold import TSNE

from tensorflow.examples.tutorials.mnist import input_data

def next_batch(data_count, data_x, data_y):

    idx = np.arange(0, len(data_x))

    np.random.shuffle(idx)

    idx = idx[:data_count]

    

    data_shuffle = [data_x[i] for i in idx]

    labels_shuffle = [data_y[i] for i in idx]

    return np.asarray(data_shuffle), np.asarray(labels_shuffle)

learning_rate = 0.001

training_epochs = 10

batch_size = 32

# load MNIST data

mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

    

# Network Model.    

tf.set_random_seed(777)

keep_prob = tf.placeholder(tf.float32)

X = tf.placeholder(tf.float32, [None, 784])

X_img = tf.reshape(X, [-1, 28, 28, 1])  

Y = tf.placeholder(tf.float32, [None, 10])

W1 = tf.Variable(tf.random_normal([3, 3, 1, 32], stddev=0.01))

L1 = tf.nn.conv2d(X_img, W1, strides=[1, 1, 1, 1], padding='SAME')

L1 = tf.layers.batch_normalization(L1, center=True, scale=True, training=True)

L1 = tf.nn.relu(L1)

L1 = tf.nn.max_pool(L1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

L1 = tf.nn.dropout(L1, keep_prob=keep_prob)

W2 = tf.Variable(tf.random_normal([3, 3, 32, 64], stddev=0.01))

L2 = tf.nn.conv2d(L1, W2, strides=[1, 1, 1, 1], padding='SAME')

L2 = tf.layers.batch_normalization(L2, center=True, scale=True, training=True)

L2 = tf.nn.relu(L2)

L2 = tf.nn.max_pool(L2, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

L2 = tf.nn.dropout(L2, keep_prob=keep_prob)

W3 = tf.Variable(tf.random_normal([3, 3, 64, 128], stddev=0.01))

L3 = tf.nn.conv2d(L2, W3, strides=[1, 1, 1, 1], padding='SAME')

L3 = tf.layers.batch_normalization(L3, center=True, scale=True, training=True)

L3 = tf.nn.relu(L3)

L3 = tf.nn.max_pool(L3, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

L3 = tf.nn.dropout(L3, keep_prob=keep_prob)

L3_flat = tf.reshape(L3, [-1, 128 * 4 * 4])

W4 = tf.get_variable("W19", shape=[128 * 4 * 4, 100], initializer=tf.contrib.layers.xavier_initializer())

b4 = tf.Variable(tf.random_normal([100]))

L4 = tf.nn.relu(tf.matmul(L3_flat, W4) + b4)

L4 = tf.nn.dropout(L4, keep_prob=keep_prob)

W5 = tf.get_variable("W20", shape=[100, 10], initializer=tf.contrib.layers.xavier_initializer())

b5 = tf.Variable(tf.random_normal([10]))

logits = tf.matmul(L4, W5) + b5

y_pred = tf.nn.softmax(logits)

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=Y, logits=logits))

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)

correct_prediction = tf.equal(tf.argmax(y_pred, 1), tf.argmax(Y, 1))

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

sess = tf.Session()

sess.run(tf.global_variables_initializer())

print('Learning start')

for epoch in range(training_epochs):

    avg_cost = 0

    avg_acc = 0

    

    total_batch = int(len(mnist.train.images) / batch_size)

    

    for i in range(total_batch):

        batch = next_batch(32, mnist.train.images, mnist.train.labels)

        feed_dict = {X: batch[0], Y: batch[1], keep_prob: 0.7}

        c, _ , acc = sess.run([cost, optimizer, accuracy], feed_dict=feed_dict)

        

        avg_cost += c / total_batch

        avg_acc += acc / total_batch

    print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.9f}'.format(avg_cost), 'Accuracy =', '{:.9f}'.format(avg_acc))

print('Learning Finish')

print('----------TEST----------')

total_batch = int(len(mnist.test.images) / batch_size)

test_acc = 0

for i in range(total_batch):

    batch = next_batch(32, mnist.test.images, mnist.test.labels)

    feed_dict = {X: batch[0], Y: batch[1], keep_prob: 1.0}

    c, _ , acc = sess.run([cost, optimizer, accuracy], feed_dict=feed_dict)

    test_acc += acc / total_batch

    

print('Test Accuracy = {0}'.format(test_acc))

print('END ALL')

sess.close()