Python | Classify Handwritten Digits with Tensorflow (original) (raw)
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
$ pip install matplotlib
$ 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
$ pip install matplotlib
$ 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])
`