Image classification using convolution neural network with TensorFlow

import tensorflow as tf
import os
import numpy as np
import matplotlib.pyplot as plt
import tflearn
from tflearn import data_utils
import random
from keras.datasets import mnist
from keras.utils import to_categorical

img_size = 28
n_class = 10
batch_size = 32
train_steps = 30
learning_rate = 0.00001

# Load data
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# Reshape data
X_train = X_train.reshape((X_train.shape[0],img_size*img_size))
X_train = X_train.astype('float32') / 255
X_test = X_test.reshape((X_test.shape[0], img_size*img_size))
X_test = X_test.astype('float32') / 255

# Categorically encode labels
y_train = to_categorical(y_train, n_class)
y_test = to_categorical(y_test, n_class)

print(X_train.shape,X_test.shape)

X_train = X_train[:3000,:]
y_train = y_train[:3000]

X_test = X_test[:500,:]
y_test  = y_test[:500]

print(X_train.shape,X_test.shape)

def create_placeholders(n_h,n_w,n_c,n_class):
    n_inputs = n_h*n_w*n_c
    X = tf.placeholder(tf.float32, shape=[None, n_inputs], name="X")
    y = tf.placeholder(tf.float32, shape=[None,n_class], name="y")
    return X,y

def initialize_parameters():
    W_conv1 = tf.Variable(tf.random_uniform([5,5,1,32], -1,1),name ="W_conv1")
    W_conv2 = tf.Variable(tf.random_uniform([5,5,32,64], -1,1),name ="W_conv2")

    W_FC1 = tf.Variable(tf.random_uniform([7*7*64,1024], -1,1),name ="W_FC1")
    W_out = tf.Variable(tf.random_uniform([1024,n_class], -1,1),name ="W_out")

    b_conv1 = tf.Variable(tf.zeros([32]),name ="b_conv1")
    b_conv2 = tf.Variable(tf.zeros([64]),name ="b_conv2")

    b_FC1 = tf.Variable(tf.zeros([1024]),name ="b_FC1")
    b_out = tf.Variable(tf.zeros([n_class]),name ="b_out")

    parameters = {"W_conv1":W_conv1,
                 "W_conv2":W_conv2,
                 "W_FC1":W_FC1,
                 "W_out":W_out,
                 "b_conv1":b_conv1,
                 "b_conv2":b_conv2,
                 "b_FC1":b_FC1,
                 "b_out":b_out}
    return parameters

def forward_propogation(X,parameters):
    W_conv1 = parameters["W_conv1"]
    W_conv2 = parameters["W_conv2"]

    W_FC1 = parameters["W_FC1"]
    W_out = parameters["W_out"]

    b_conv1 = parameters["b_conv1"]
    b_conv2 = parameters["b_conv2"]

    b_FC1 = parameters["b_FC1"]
    b_out = parameters["b_out"]

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

    # Convolution Layer 1

    Z1 = tf.nn.conv2d(X,W_conv1,strides = [1,1,1,1], padding ='SAME')
    Z1 += b_conv1
    A1 = tf.nn.relu(Z1)
    P1 = tf.nn.max_pool(A1, ksize=[1,2,2,1], strides = [1,2,2,1], padding ="SAME")

    # Convolution Layer 2

    Z2 = tf.nn.conv2d(P1,W_conv2,strides = [1,1,1,1], padding ='SAME')
    Z2 += b_conv2
    A2 = tf.nn.relu(Z2)
    P2 = tf.nn.max_pool(A2, ksize=[1,2,2,1], strides = [1,2,2,1], padding ="SAME")

    # Flatten

    layer_flattened = tf.reshape(P2,[-1,7*7*64])

    # Fully Connected Layer

    FC1 = tf.matmul(layer_flattened,W_FC1) + b_FC1
    A3 = tf.nn.relu(FC1)

    output = tf.matmul(A3,W_out) + b_out

    return output

def compute_cost(output,y):
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits = output, labels = y))
    return cost

X,y = create_placeholders(img_size,img_size,1,n_class)

parameters = initialize_parameters()

output = forward_propogation(X,parameters)

cross_entropy = compute_cost(output,y)

optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)

prediction = tf.equal(tf.argmax(output,1),tf.argmax(y,1))

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

init = tf.global_variables_initializer()

print(X_train.shape,y_train.shape)

with tf.Session() as sess:
    sess.run(init)
    for epoch in range(train_steps+1):
        Error = 0
        for start,end in zip(range(0,X_train.shape[0],batch_size),range(batch_size,X_train.shape[0]+1,batch_size)):
            _,Loss = sess.run([optimizer,cross_entropy],feed_dict={X:X_train[start:end],y:y_train[start:end]})
            Error += Loss

        if epoch%1 == 0:
            print('Epoch: ' + str(epoch) + ',' + 'Cost: ' + str(Error))
            print('Training_Step: ' + str(epoch) + ',' + 'Training_Accuracy: ' + str(sess.run(accuracy, feed_dict={X:X_train,y:y_train})))



    print("Training_Completed")

    print('Testing_Step: ' + str(epoch) + ',' + 'Testing_Accuracy: ' + str(sess.run(accuracy, feed_dict={X:X_test,y:y_test})))
    print("Testing_Completed")

    y_activate = tf.nn.softmax(output)
    y_output = y_activate.eval(feed_dict={X:X_test})

    for example_index in range(10):
        y_output_temp = y_output[example_index]
        y_pred = np.argmax(y_output_temp)
        y_label_temp = y_test[example_index]
        y_label = np.argmax(y_label_temp)
        print("Actual: {}, Predicted : {}".format(y_label,y_pred))
        plt.imshow(X_test[example_index].reshape(img_size,img_size),cmap="binary",interpolation="nearest")
        plt.show()