Python | Classify Handwritten Digits with Tensorflow

Classifying handwritten digits is the basic problem of the machine learning and can be solved in many ways here we will implement them by using TensorFlow
Using a Linear Classifier Algorithm with tf.contrib.learn 
linear classifier achieves the classification of handwritten digits by making a choice based on the value of a linear combination of the features also known as feature values and is typically presented to the machine in a vector called a feature vector. 
Modules required :
NumPy: 

$ pip install numpy 

Matplotlib: 

$ pip install matplotlib 

Tensorflow: 

$ pip install tensorflow 

Steps to follow

Step 1 : Importing all dependence 

Python3

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

learn = tf.contrib.learn

tf.logging.set_verbosity(tf.logging.ERROR)

Step 2 : Importing Dataset using MNIST Data 

Python3

mnist = learn.datasets.load_dataset('mnist')
data = mnist.train.images
labels = np.asarray(mnist.train.labels, dtype=np.int32)
test_data = mnist.test.images
test_labels = np.asarray(mnist.test.labels, dtype=np.int32)

after this step a dataset of mnist will be downloaded. 
output :

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

Step 3 : Making dataset

Python3

max_examples = 10000
data = data[:max_examples]
labels = labels[:max_examples]

Step 4 : Displaying dataset using MatplotLib 

Python3

def display(i):
    img = test_data[i]
    plt.title('label : {}'.format(test_labels[i]))
    plt.imshow(img.reshape((28, 28)))

# image in TensorFlow is 28 by 28 px
display(0)

To display data we can use this function – display(0)
output : 

Step 5 : Fitting data, using linear classifier 

Python3

feature_columns = learn.infer_real_valued_columns_from_input(data)
classifier = learn.LinearClassifier(n_classes=10,
                                    feature_columns=feature_columns)
classifier.fit(data, labels, batch_size=100, steps=1000)

Step 6 : Evaluate accuracy 

Python3

classifier.evaluate(test_data, test_labels)
print(classifier.evaluate(test_data, test_labels)["accuracy"])

Output :

0.9137

Step 7 : Predicting data 

Python3

prediction = classifier.predict(np.array([test_data[0]],
                                         dtype=float),
                                         as_iterable=False)
print("prediction : {}, label : {}".format(prediction,
      test_labels[0]) )

Output :

prediction : [7], label : 7

Full Code for classifying handwritten 

Python3

# importing libraries
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

learn = tf.contrib.learn
tf.logging.set_verbosity(tf.logging.ERROR)\

# importing dataset using MNIST
# this is how mnist is used mnist contain test and train dataset
mnist = learn.datasets.load_dataset('mnist')
data = mnist.train.images
labels = np.asarray(mnist.train.labels, dtype = np.int32)
test_data = mnist.test.images
test_labels = np.asarray(mnist.test.labels, dtype = np.int32)

max_examples = 10000
data = data[:max_examples]
labels = labels[:max_examples]

# displaying dataset using Matplotlib
def display(i):
    img = test_data[i]
    plt.title('label : {}'.format(test_labels[i]))
    plt.imshow(img.reshape((28, 28)))

# img in tf is 28 by 28 px
# fitting linear classifier
feature_columns = learn.infer_real_valued_columns_from_input(data)
classifier = learn.LinearClassifier(n_classes = 10,
                                    feature_columns = feature_columns)
classifier.fit(data, labels, batch_size = 100, steps = 1000)

# Evaluate accuracy
classifier.evaluate(test_data, test_labels)
print(classifier.evaluate(test_data, test_labels)["accuracy"])

prediction = classifier.predict(np.array([test_data[0]],
                                         dtype=float),
                                         as_iterable=False)
print("prediction : {}, label : {}".format(prediction,
      test_labels[0]) )

if prediction == test_labels[0]:
     display(0)

Using Deep learning with tf.keras
Deep learning is a subpart of machine learning and artificial intelligence which is also known as deep neural network this networks capable of learning unsupervised from provided data which is unorganized or unlabeled. today, we will implement a neural network in TensorFlow to classify handwritten digit.
Modules required :
NumPy: 

$ pip install numpy 

Matplotlib: 

$ pip install matplotlib 

Tensorflow: 

$ pip install tensorflow 

Steps to follow

Step 1 : Importing all dependence 

Python3

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

Step 2 : Import data and normalize it 

Python3

mnist = tf.keras.datasets.mnist
(x_train,y_train) , (x_test,y_test) = mnist.load_data()

x_train = tf.keras.utils.normalize(x_train,axis=1)
x_test = tf.keras.utils.normalize(x_test,axis=1)

Step 3 : view data 

Python3

def draw(n):
    plt.imshow(n,cmap=plt.cm.binary)
    plt.show()

draw(x_train[0])

Step 4 : make a neural network and train it 

Python3

#there are two types of models
#sequential is most common, why?

model = tf.keras.models.Sequential()

model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))
#reshape

model.add(tf.keras.layers.Dense(128,activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(128,activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy']
              )
model.fit(x_train,y_train,epochs=3)

Step 5 : check model accuracy and loss 

Python3

val_loss,val_acc = model.evaluate(x_test,y_test)
print("loss-> ",val_loss,"\nacc-> ",val_acc)

Step 6 : prediction using model 

Python3

predictions=model.predict([x_test])
print('label -> ',y_test[2])
print('prediction -> ',np.argmax(predictions[2]))

draw(x_test[2])

saving and testing model 

saving the model 

Python3

#saving the model
# .h5 or .model can be used

model.save('epic_num_reader.h5')

loading the saved model

Python3

new_model = tf.keras.models.load_model('epic_num_reader.h5')

prediction using new model

Python3

predictions=new_model.predict([x_test])


print('label -> ',y_test[2])
print('prediction -> ',np.argmax(predictions[2]))

draw(x_test[2])