import tensorflow as tf

from tensorflow.examples.tutorials.mnist import input_data

tf.__version__

'1.7.0'

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

Extracting /tmp/data\train-images-idx3-ubyte.gz
Extracting /tmp/data\train-labels-idx1-ubyte.gz
Extracting /tmp/data\t10k-images-idx3-ubyte.gz
Extracting /tmp/data\t10k-labels-idx1-ubyte.gz

type(mnist)

tensorflow.contrib.learn.python.learn.datasets.base.Datasets

mnist.train.images.shape # (rows, columns)

(55000, 784)

sample = mnist.train.images[20].reshape(28,28) # (rows, columns) 28*28=784

import matplotlib.pyplot as plt

%matplotlib inline

plt.imshow(sample,cmap='Greys')

<matplotlib.image.AxesImage at 0x26385204860>

learning_rate = 0.001 # cost function
training_epochs = 15 # cycles
batch_size = 100 # the number of execution

n_classes = 10 # the number of labels
n_samples = mnist.train.num_examples

mnist.train.num_examples

55000

n_input = 784

# image info, columns
n_hidden_1 = 256
n_hidden_2 = 256 

def multilayer_perceptron(x,weights,biases):
    '''
    x: Placeholder for Data Input
    weights: Dict of weights
    biases: Dict of bias values
    '''
    
    # First Hidden Layer with RELU Activation
    # X * W + B
    layer_1 = tf.add(tf.matmul(x,weights['h1']),biases['b1'])
    # RELU(X * W + B) -> f(x) = max(0,x)
    layer_1 = tf.nn.relu(layer_1)
    
    # Second Hidden Layer
    layer_2 = tf.add(tf.matmul(layer_1,weights['h2']),biases['b2'])
    layer_2 = tf.nn.relu(layer_2)
    
    # Last Output Layer
    out_layer = tf.matmul(layer_2,weights['out']) + biases['out']
    
    return out_layer

weights = {
    'h1':tf.Variable(tf.random_normal([n_input,n_hidden_1])),
    'h2':tf.Variable(tf.random_normal([n_hidden_1,n_hidden_2])),
    'out':tf.Variable(tf.random_normal([n_hidden_2,n_classes]))
}

biases = {
    'b1':tf.Variable(tf.random_normal([n_hidden_1])),
    'b2':tf.Variable(tf.random_normal([n_hidden_2])),
    'out':tf.Variable(tf.random_normal([n_classes]))
}

x = tf.placeholder('float',[None,n_input]) # image
print(x)

Tensor("Placeholder_7:0", shape=(?, 784), dtype=float32)

y = tf.placeholder('float',[None,n_classes]) # label
print(y)
y

Tensor("Placeholder_8:0", shape=(?, 10), dtype=float32)

<tf.Tensor 'Placeholder_8:0' shape=(?, 10) dtype=float32>

pred = multilayer_perceptron(x,weights,biases)
print(pred)
pred

Tensor("add_4:0", shape=(?, 10), dtype=float32)

<tf.Tensor 'add_4:0' shape=(?, 10) dtype=float32>

cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y,logits=pred))
print(cost)

Tensor("Mean_5:0", shape=(), dtype=float32)

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

name: "Adam_3"
op: "NoOp"
input: "^Adam_3/update_Variable_18/ApplyAdam"
input: "^Adam_3/update_Variable_19/ApplyAdam"
input: "^Adam_3/update_Variable_20/ApplyAdam"
input: "^Adam_3/update_Variable_21/ApplyAdam"
input: "^Adam_3/update_Variable_22/ApplyAdam"
input: "^Adam_3/update_Variable_23/ApplyAdam"
input: "^Adam_3/Assign"
input: "^Adam_3/Assign_1"

# Training the Model

t = mnist.train.next_batch(1)

Xsamp,ysamp = t

plt.imshow(Xsamp.reshape(28,28),cmap='Greys') # Xsamp: image

<matplotlib.image.AxesImage at 0x26385496240>

ysamp # label

array([[0., 0., 0., 1., 0., 0., 0., 0., 0., 0.]])

## Run the Session

sess = tf.InteractiveSession()

init = tf.initialize_all_variables()

sess.run(init)

training_epochs

15

n_samples

55000

batch_size

100

#batch_x

#batch_y

# 15 loops
for epoch in range(training_epochs):
    
    # Cost
    avg_cost = 0.0
    
    total_batch = int(n_samples/batch_size)
    
    for i in range(total_batch):
        
        batch_x,batch_y = mnist.train.next_batch(batch_size)
        
        _,c = sess.run([optimizer,cost],feed_dict={x:batch_x,y:batch_y})
        
        avg_cost += c/total_batch
        
    print("Epoch: {} Cost: {:.4f}".format(epoch+1, avg_cost))
    
print("Model has completed {} Epochs of training".format(training_epochs))

Epoch: 1 cost: 216.8846
Epoch: 2 cost: 44.2692
Epoch: 3 cost: 27.6110
Epoch: 4 cost: 19.4590
Epoch: 5 cost: 14.2725
Epoch: 6 cost: 10.6621
Epoch: 7 cost: 8.0763
Epoch: 8 cost: 6.2156
Epoch: 9 cost: 4.6376
Epoch: 10 cost: 3.3673
Epoch: 11 cost: 2.5955
Epoch: 12 cost: 1.9618
Epoch: 13 cost: 1.5048
Epoch: 14 cost: 1.1057
Epoch: 15 cost: 0.9240
Model has completed 15 Epochs of training

## Model Evaluations

correct_predictions = tf.equal(tf.argmax(pred,1),tf.argmax(y,1))

print(correct_predictions[0])
correct_predictions[0]

Tensor("strided_slice_3:0", shape=(), dtype=float32)

<tf.Tensor 'strided_slice_4:0' shape=() dtype=float32>

correct_predictions = tf.cast(correct_predictions, 'float')

print(correct_predictions[0])
correct_predictions[0]

Tensor("strided_slice_10:0", shape=(), dtype=float32)

<tf.Tensor 'strided_slice_11:0' shape=() dtype=float32>

accuracy = tf.reduce_mean(correct_predictions)

type(accuracy)

tensorflow.python.framework.ops.Tensor

mnist.test.labels[0]

array([0., 0., 0., 0., 0., 0., 0., 1., 0., 0.])

#mnist.test.images[0]

accuracy.eval({x:mnist.test.images, y:mnist.test.labels})

0.9402