Open In App

Python | Classify Handwritten Digits with Tensorflow

Last Updated : 08 May, 2024
Comments
Improve
Suggest changes
Like Article
Like
Report

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])

Next Article

Similar Reads