HANDWRITTEN DIGIT RECOGNITION USING MACHINE

LEARNING
Mahaboob Basha.Sk1, Vineetha.J2, Sudheer.D3
1.
aruna@nriit.edu.in, Associate professor, Dept Of IT,NRI Institute of Technology, A.P,India-521212.
2
jonnakutivineetha0341@gmail.com, UG Scholar, NRI Institute of Technology, A.P-521212
3
baythapudisaikrishna@gmail.com, UG Scholar, NRI Institute of Technology, Andhra Pradesh,

---------------------------------------------------------------------------
***----------------------------------------------------------------------------
Abstract - In this Handwritten Digit Recognition project, purposes. Precisely, we can use it in banks for
we will recognize handwritten Digits, i.e. from 0-9.
Handwritten digit recognition is the ability of computers to
recognize human handwritten digits. Handwritten Digit
recognition is one of the practically important issues in
pattern recognition applications. The applications of digit
recognition include postal mail sorting, bank check
processing, form data entry, etc. The heart of the problem
lies within the ability to develop an efficient algorithm that
can recognize handwritten digits and which is submitted by
users by the way of a scanner, tablet, and other digital
devices.

Key Words: Digit recognition, Dataset, Convolutional Neural

Networks, Machine learning, Deep learning, Support Vector
Machine, K Nearest Neighbors, Euclidean distance,
Visualization, Accuracy, marginal hyperplane

1. INTRODUCTION
Humans can see and visually sense the world around
them by using their eyes and brains. Computer vision
works on enabling computers to see and process
images in the same way that human vision does.
Several algorithms developed in the area of computer
vision to recognize images. The goal of our work will
be to create a model that will be able to identify and
determine the handwritten digit from its image with
better accuracy. We aim to complete this by using the
concepts of Convolutional Neural Network and
MNIST dataset. Though the goal is to create a model
which can recognize the digits, we can extend it for
letters and then a person’s handwriting. Through this
work, we aim to learn and practically apply the
concepts of Convolutional Neural Networks. Recent
Convolutional Neural Networks (CNN) becomes one
of the most appealing approaches and has been an
ultimate factor in a variety of recent successes and
challenging machine learning applications such as
challenge ImageNet object detection image
segmentation and face recognition. Therefore, we
choose CNN for our challenging task of image
classification. We can use it for handwriting digits
recognition which is one of high academic and
business transactions. There are many applications of
handwriting digit recognition in our real-life
 reading checks, post offices for sorting letters, and
many other related works. The MNIST Dataset
(Modified National Institute of Standards and
Technology Dataset) is a handwritten digit dataset.
We can use it for training various image processing
systems. The Dataset is also widely used for training
and testing in the field of machine learning. It has
60,000 training and 10,000 testing examples. Each
image has a fixed size. The images are of size 28*28
pixels. It is a Dataset for people who want to try
learning techniques and pattern recognition
methods on real-world data while spending minimal
effort on preprocessing and formatting. We will use
this Dataset in our experiment. Convolutional neural
networks are deep artificial neural networks. We
can use it to classify images (e.g., name what they
see), cluster them by similarity (photo search), and
perform object recognition within scenes. It can be
used to identify faces, individuals, street signs,
tumors, platypuses, and many other aspects of
visual data. The convolutional layer is the core
building block of a CNN. The layer’s parameters
consist of a set of learnable filters (or kernels) that
have a small receptive field but extend through the
full depth of the input volume. During the forward
pass, each filter is convolved across the width and
height of the input volume, computing the dot
product, and producing a 2- dimensional activation
map of that filter. As a result, the network learns
when they see some specific type of feature at some
spatial position in the input. Then the activation
maps are fed into a down sampling layer, and like
convolutions, this method is applied one patch at a
time. CNN has also a fully connected layer that
classifies output with one label per node.
Handwriting digit recognition has an active
community of academics studying it. A lot of
important work on convolutional neural networks
happened for handwritten digit recognition
[1,6,8,10]. There are many active areas of research
such as Online Recognition, Offline recognition,
Real-Time Handwriting Recognition, Signature
Verification, Postal-Address, Interpretation, Bank-
Check Processing, Writer Recognition.
Deep Learning has emerged as a central tool for self-
perception problems like understanding images, a
voice from humans, robots exploring the world. We
aim to implement the concept of a Convolutional
Neural Network for digit recognition. Understanding
CNN and applying it to the handwritten digit
recognition system is the target of the proposed
model. Convolutional Neural Network extracts the
features maps from the 2D images. Deep Learning has
emerged as a central tool for self-perception
problems like understanding images, a voice from
humans, robots exploring the world. We aim to
implement the concept of a Convolutional Neural
Network for digit recognition. Understanding CNN and
applying it to the handwritten digit recognition system
is the target of the proposed model. Convolutional
Neural Network extracts the features maps from the
2D images. Convolutional Neural Networks (CNNs) is a
very well known deep learning algorithm that can be
used to process images. It assigns weights and biases
to various parts of the image and is very capable of
differentiating one image from another same kind of
image. Good accuracy has been achieved for
handwritten digits recognition by using Convolutional
Neural Networks. The mammalian system of
visualization is taken into consideration to create CNN
architecture. CNN is created by D. H. Hubel in 1962.
Two algorithms with the name gradient descent &
backpropagation are utilized to train the model.
Character images of handwritten digits are used as
input. Artificial neural network (ANN) consists of one
input layer, one output layer, and, some layers which
exist in between the input 3 layer and output layer,
these middle layers are hidden layers. CNN and ANN
are very similar to each other. CNN’s deep learning
algorithm worked on the analysis of visual images.
CNN can be used in applications like detection of an
object, identification of face, in the field of robotics,
video processing, segmentation, in the field of pattern
recognition, processing of natural language, detection
of spam, categorization, speech identification,
classification of the digital image, etc. It is a hard task
for the machines because handwritten digits are not
perfect and can be made with many different
handwritings. Handwritten digit recognition is the
solution to this problem which uses the image of a
digit and recognizes the digit present in the image.
2. Literature survey
A few state-of-the-art approaches that use
handwritten digit recognition for digit identification
have been summarized here.
2.1 Handwritten Digit Recognition for Banking
System
The aim of a handwriting digit recognition system is to
convert handwritten digits into machine-readable
formats. The main objective of this work is to ensure
effective and reliable approaches for the recognition of
handwritten digits and make banking operations
easier and error free The aim of a handwriting digit
recognition system is to convert handwritten digits
into machine-readable formats. The main objective of
this work is to ensure effective and reliable
approaches for the recognition of handwritten digits
and make banking operations easier and error free. A
Handwritten Digit Recognition system (HDR) is meant
for receiving and interpreting handwritten input in the
form of pictures or paper documents. Traditional
systems of handwriting recognition have relied on
handcrafted features and a large amount of prior
knowledge. Training an Optical character recognition
(OCR) system based on these prerequisites is a
challenging task. Convolutional neural networks
(CNNs) are very effective in perceiving the structure
of handwritten characters/words in ways that help in
the automatic extraction of distinct features and
make CNN the most suitable approach for solving
handwriting recognition problems. Our aim in the
proposed work is to recognize written characters on
cash deposit/ withdrawal/ and other transactions,
we are proposing to develop an automatic banking
deposit number recognition system that can
recognize the handwritten account number and
amount number on the cash deposit slip and thus
automate the cash deposit process at a bank counter.
2.2 Survey on Handwritten Digit Recognition
using Machine Learning
Machine learning and deep learning play an
important role in computer technology and artificial
intelligence. With the use of deep learning and
machine learning, human effort can be reduced in
recognizing, learning, predictions, and many more
areas. This paper presents
recognizing the handwritten digits (0 to 9) from the
famous MNIST dataset, comparing classifiers like
KNN, PSVM, NN, and convolution neural network on
basis of performance, accuracy, time, sensitivity,
positive productivity, and specificity with using
different parameters with the classifiers.
2.3 Recognition of Handwritten Digits using
Machine Learning Techniques
This paper illustrates the application of object
character recognition (OCR) using template matching
and machine learning techniques to solve the
problem of handwritten character recognition. In this
paper, we perform the recognition task using
Template Matching, Support Vector Machine (SVM),
and Feed Forward Neural Network. Template
matching is an image processing technique to break
the image into smaller parts and then match it to a
template image. Here we use a Multi-Class SVM
classifier and Neural Network to classify the image.
We use the dataset to train the classifier followed by
feature extraction and finally applying the classifiers
to recognize the digits.
2.4 EXISTING SYSTEM
In this section, we are going to discuss a few
algorithms which are used so far for handwritten
digit recognition. Mentioned below are the
algorithms:
a. KNN (K Nearest Neighbors)
b. SVM (Support Vector Machine)
2.4.1 KNN (K Nearest Neighbors)
KNN is the non-parametric method or classifier used
for classification as well as regression problems. This
is the lazy or late learning classification algorithm
where all of the computations are derived until the
last stage of classification, as well as this, is the
instance-based learning algorithm where the
approximation takes place locally. Being simplest and
easiest to implement there is no explicit training phase
earlier and the algorithm does not perform any
generalization of training data. KNN explains
categorical value using majority votes of K nearest
neighbors where the value for K can differ, so on
changing the value of K, the value of votes can also
vary. Take our handwriting training dataset as an
example, each digit has been prepared a variety of
samples. For example, for the digit 0, we got 188
samples with each sample to represent a variation of
the handwriting of 0. Each digit sample is saved as a
text file. We also need to label or class each sample. In
our case, the labels are digits from 0 to 9 and assign to
each digit sample in our handwriting training set.
When we’re given a new digit sample text file, we ask
our KNN algorithm to identify the digit in it and label it
as a digit in classes 0 to 9. The idea of k-NN is to take
the new sample and then convert it to a feature vector.
In our case, the digit is a 32x32 image formatted as a
0,1 text file. To convert it as a feature vector, we will
load the image file into a vector like [0, [1,0,0,1]], the
length of the inner vector is 1024 (32x32). We then
measure the distance of this new sample vector to
every sample vector in the training set. It is computing
intensive so k-NN isn’t quite efficient for large training
sets use case cases measurement is an extension of the
Pythagorean theorem. As I believe knowing how KNN
measurement work in mathematical isn’t matter for
understanding KNN, I will assume we all know how
KNN measurement works. We then take the most
similar, in the sense of distance, pieces of sample data
(the nearest neighbors) and look at their labels (0 to
9). We look at the top k most similar pieces of sample
data from our known dataset; this is where the k
comes from. (k is an integer and it’s usually less than
20.) Lastly, we take a majority vote from the k most
similar pieces of data, and the majority is the new
class in 0 to 9 we assign to the new data we were
asked to classify.
Implementation of KNN
1. Compute the Euclidean distance between the test
data point and all the training data.
2. Sort the calculated distances in ascending order.
3. Get the k nearest neighbors by taking top k rows
from sorted array
4. Find the majority class of these rows.
5. Return predicted class.
Finding accuracy score to make sure the prediction is
correct or not.
1)Calculation of Euclidean distance
Euclidean distance is the square root of the sum of
squared distance between two points.
 Fig 2.1 Euclidean Formula
Two points are passed (here row1 &row2) The
Euclidean _distance function calculates the difference
between the squares of the points and finally the
square root of the difference.
2)Get the k nearest neighbors after sorting
distance
To find the neighbors we need to first sort the distance
in ascending order, np. a resort () is used to find the
index of minimum distance. After that we will arrange
the according to the sorted index. Slicing the data
according to the number of neighbors.

Fig 2.2 K-Nearest Neighbors Classification

3)Predicting the class of the new data point

The test data will present in the class with a majority
of the votes. So, to find that we will use the max ()
function They key in the max function groups the
neighbors to their classes and count will count the
number of neighbors in each class. Finally max returns
the class with majority votes which will be the
predicted class of the test data.
4)Accuracy calculation
Accuracy shows how close the measured value is to the
true value. Accuracy is calculated by dividing the
correctly classified samples count by total samples.

Higher the accuracy, the more efficient the model.

3. SYSTEM REQUIREMENT ANALYSIS
3.1 Hardware and Software Requirements
Table 3.1 Hardware and Software Requirements
3.2 Functional Requirements
The System should process the input given by the
user only if it is an image file (JPG, PNG, etc.) System
shall show the error message to the user when the
input is given is not in the required format. System
should detect characters present in the image.
System should retrieve characters present in the
image and display them to the user.
3.3 Non-Functional Requirements
Performance: Handwritten digits in the input image
will be recognized with an accuracy of about 90%
and above.
 Functionality: This software will deliver on
the functional requirements mentioned in
this document.
 Availability: This system will retrieve the
handwritten test regions only if the image
contains written text in it.
 Flexibility: It provides the users to load the
image easily.
 Ability: The software is very easy to use and
reduces the learning work.
3.4 Feasibility Study
3.4.1Technical Feasibility
3.4.1.1 Pandas
Python Pandas is defined as an open-source library
that provides high-performance data manipulation
in Python. Pandas is built on top of the NumPy
package, which means NumPy is required for
operating the Pandas. Before Pandas, Python was
capable of data preparation, but it only provided
limited support for data analysis. So, Pandas came
into the picture and enhanced the capabilities of
data analysis. It can perform five significant steps
required for processing and analysis of data
irrespective of the origin of the data, i.e., load,
manipulate, prepare, model, and analyze.
3.4.1.2 Sklearn
Scikit-learn (Sklearn) is the most useful and robust
library for machine learning in Python. It provides a
selection of efficient tools for machine learning and
statistical modeling including classification,
regression, clustering, and dimensionality reduction
via a consistent interface in Python. This library,
which is largely written in Python, is built upon
NumPy, SciPy, and Matplotlib.
3.4.1.3 CNN
A Convolutional Neural Network (ConvNet/CNN) is a
Deep Learning algorithm that can take in an input
image, assign importance (learnable weights and
biases) to various aspects/objects in the image, and
be able to differentiate one from the other. The pre-
processing required in a ConvNet is much lower as
compared to other classification algorithms. While in
primitive methods filters are hand-engineered, with
enough training, ConvNets can learn these
filters/characteristics.
3.4.1.4 Matplotlib
Matplotlib is an amazing visualization library in
Python for 2D plots of arrays. Matplotlib is a multi-
platform data visualization library built on NumPy
arrays and designed to work with the broader SciPy
stack. One of the greatest benefits of visualization is
that it allows us visual access to huge amounts of
data in easily digestible visuals. Matplotlib consists of
several plots like line, bar, scatter, histogram, etc.
3.4.1.5 Tkinter
Tkinter is the most commonly used library for
developing GUI (Graphical User Interface) in Python.
It is a standard Python interface to the Tk GUI toolkit
shipped with Python. As Tk and Tkinter are available
on most of the Unix platforms as well as on the
Windows system, developing GUI applications with
Tkinter becomes the fastest and easiest.
3.4.1.6 Keras
Keras is an open-source high-level Neural Network
library, which is written in Python is capable enough
to run on Theano, TensorFlow, or CNTK. It was
developed by one of the Google engineers, Francois
Chollet. It is made user-friendly, extensible, and
modular for facilitating faster experimentation with
deep neural networks. It not only supports
Convolutional Networks and Recurrent Networks
individually but also their combination. It cannot
handle low-level computations, so it makes use of the
Backend library to resolve it.
3.4.2 Economic Feasibility:
• Datasets used for Analyzing are from online
platforms which are free of cost.
4. PROPOSED SYSTEM
 In this project, we will be using the TensorFlow
library to build, train and test our models and the
data which we will use is MNIST Dataset. The
algorithm used will be Convolutional Neural
Network (CNN).
4.1 TensorFlow
TensorFlow is a free and open-source library for
data flow and differentiable programming across a
range of tasks. It is a symbolic math library and is
also used in machine learning applications such as
neural networks. It is used for both research and
production at Google. TensorFlow was developed by
the Google Brain team for internal Google use. It was
released under the Apache License 2.0 on November
9, 2015. TensorFlow offers multiple levels of
abstraction so we can choose the right one for our
needs. We can build and train models by using the
high-level Keras API, which makes getting started
with TensorFlow and machine learning easy. If we
need more flexibility, eager execution allows for
immediate iteration and intuitive debugging. For
large ML training tasks, we can use the Distribution
Strategy API for distributed training on different
hardware configurations without changing the
model definition.
4.2 MNIST Dataset
The MNIST Dataset (Modified National Institute of
Standards and Technology Dataset) isa large Dataset
of handwritten digits that is commonly used for
training various image processing systems. The
Dataset is also widely used for training and testing
in the field of machine learning. The MNIST Dataset
contains 60,000 training images and 10,000 testing
images. Half of the training set and half of the test
set were taken from NIST's training dataset, while
the other half of the training set and the other half of
the test set were taken from NIST's testing dataset.
There have been several scientific papers on
attempts to achieve the lowest error rate.
Fig 4.1 Sample images from MNIST test dataset
4.3 The Algorithm:
CNN To recognize the handwritten digits, a seven-
layered convolutional neural network with one input
layer followed by five hidden layers and one output
layer is designed A Convolutional Neural Network
(ConvNet/CNN) is a Deep Learning algorithm that can
take in an input image, assign importance (learnable
weights and biases) to various aspects/objects in the
image, and be able to differentiate one from the other.
The pre-processing required in a ConvNet is much
lower as compared to other classification algorithms.
While in primitive methods filters are hand-engineered,
with enough training, ConvNets can learn these
filters/characteristics. The architecture of a ConvNet is
analogous to that of the connectivity pattern of Neurons
in the Human Brain and was inspired by the
organization of the Visual Cortex. Individual neurons
respond to stimuli only in a restricted region of the
visual field known as the Receptive Field. A collection of
such fields overlaps to cover the entire visual area.An
image is nothing but a matrix of pixel values, So why
not just flatten the image (e.g. 3x3 image matrix into a
9x1 vector) and feed it to a Multi-Level Perceptron for
classification purposes In cases of extremely basic
binary images, the method might show an average
precision score while performing prediction of classes
but would have little to no accuracy when it comes to
complex images having pixel dependencies throughout.
A ConvNet can successfully capture the Spatial and
Temporal dependencies in an image through the
application of relevant filters. The architecture
performs a better fitting to the image dataset due to the
reduction in the number of parameters involved and
the reusability of weights. In other words, the network
can be trained to understand the sophistication of the
image better.
Input Image
Fig 4.4 4x4x3 RGB Image
In the figure, we have an RGB image that has been
separated by its three-color planes — Red, Green, and
Blue. There are several such color spaces in which
images exist — Grayscale, RGB, HSV, CMYK, etc
Convolution Layer — The Kernel
Fig 4.5 Convoluting a 5x5x1 image with a 3x3x1
kernel to get a 3x3x1 convolved feature
Image Dimensions = 5 (Height) x 5 (Breadth) x 1
(Number of channels, e.g. RGB) In the above
demonstration, the green section resembles our 5x5x1
input image, I. The element involved in carrying out the
convolution operation in the first part of a
Convolutional Layer is called the Kernel/Filter, K,
represented in the color yellow. We have selected K as
a 3x3x1 matrix.
5. SOFTWARE DESIGN
5.1 Working Architectural Design
Fig 5.1 Working Architectural Design
A Convolutional Neural Network (ConvNet/CNN) is a
Deep Learning algorithm that can take in an input
image, assign importance (learnable weights and
biases) to various aspects/objects in the image, and be
able to differentiate one from the other. The pre-
processing required in a ConvNet is much lower as
compared to other classification algorithms. While in
primitive methods filters are hand-engineered, with
enough training, ConvNets can learn these
filters/characteristics. The architecture of a ConvNet is
analogous to that of the connectivity pattern of
Neurons in the Human Brain and was inspired by the
organization of the Visual Cortex. Individual neurons
respond to stimuli only in a restricted region of the
visual field known as the Receptive Field. A collection
of such fields overlaps to cover the entire visual area.
An image is nothing but a matrix of pixel values, So
why not just flatten the image (e.g. 3x3 image matrix
into a 9x1 vector) and feed it to a Multi-Level
Perceptron for classification purposes In cases of
extremely basic binary images, the method might show
an average precision score while performing
prediction of classes but would have little to no
accuracy when it comes to complex images having
pixel dependencies throughout.
5.2 Block Diagram
Fig 5.2 Block Diagram of the system
Pre-Processing: The role of the pre-processing step
is it performs various tasks on the input image. It
upgrades the image by making it reasonable for
segmentation. The fundamental motivation behind
pre-processing is to take off a fascinating example
from the background. For the most part, noise
filtering, smoothing, and standardization are to be
done in this stage. Segmentation: Once the pre-
processing of the input images is completed, sub-
images of individual digits are formed from the
sequence of images. Pre-processed digit images are
segmented into a sub-image of individual digits,
which are assigned a number to each digit. Each digit
is resized into pixels. In this step, an edge detection
technique is being used for the segmentation of
dataset images. Feature Extraction: After the
completion of pre-processing stage and segmentation
stage, the pre-processed images are represented in
the form of a matrix that contains pixels of the
images that are of very large size. In this way, it will
be valuable to represent the digits in the images
which contain the necessary information. This
activity is called feature extraction. In the feature
extraction stage redundancy from the data is
removed. Classification and Recognition: In the
classification and recognition step the extracted
feature vectors are taken as an individual input to
each of the following classifiers.
5.3 FLOW CHART
Fig 5.3 Flow chart representation
5.4 UML Diagrams
A UML diagram is a diagram based on the UML
(Unified Modeling Language) to visually represent a
system along with its main actors, roles, actions,
artifacts, or classes, to better understand, alter,
maintain, or document information about the system.
5.4.1 Class Diagram
Class UML diagram is the most common diagram
type for software documentation. Since most
software being created nowadays is still based on
the Object-Oriented Programming paradigm, using
class diagrams to document the software turns out
to be a common-sense solution. This happens
because OOP is based on classes and the relations
between them.