Chapter 3
Methodology
To build a system that can recognize handwritten digits, we
follow a stepbystep approach. First, we collect and prepare
the dataset. Then we preprocess the images by normalizing
the pixel values and reshaping them to match the input
requirements of the CNN model. After that, we design a CNN
model using multiple layers, such as convolutional layers,
pooling layers, and fully connected layers.
The model is then compiled using an optimizer and a loss
function. We train the model using the training dataset and
validate its performance on the test dataset. The performance of
the model is evaluated based on its accuracy, confusion matrix,
and loss curves. Our goal is to minimize the error and maximize
the accuracy of the model. We use Python for implementation
and libraries such as TensorFlow and Keras to build and train
the model.
1. Data Acquisition and Preprocessing
A robust machine learning system begins with high-quality data. We use the
MNIST dataset, which contains 70,000 labeled grayscale images of
handwritten digits (60,000 for training and 10,000 for testing), each of size
28×28 pixels. This dataset is a gold standard in digit recognition tasks due to
its size, diversity, and ease of use.
• Normalization: Each image pixel (originally ranging from 0 to 255) is
scaled to the [0, 1] range. This normalization speeds up training,
ensures numerical stability, and improves convergence.
1
• Reshaping: Since the images are grayscale, we reshape them into
tensors of shape (28, 28, 1), where 1 represents the single color
channel.
• One-Hot Encoding: The digit labels (0 to 9) are transformed into one-
hot encoded vectors for categorical classification (e.g., digit ‘5’
becomes [0, 0, 0, 0, 0, 1, 0, 0, 0, 0]).
• Train-Validation-Test Split: The dataset is split into training,
validation, and test subsets. The validation set (typically 10% of the
training data) is used to tune hyperparameters, while the test set is
used only for final evaluation.
2. CNN Architecture Design
A CNN is designed to automatically learn spatial hierarchies of features
from input images. The architecture comprises the following components:
• Convolutional Layers (Conv2D): Extract local features (edges, lines,
textures) using multiple filters. These layers preserve spatial
relationships between pixels by learning image features using small
squares of input data.
• Activation Functions (ReLU): Apply non-linear transformations to the
feature maps. The Rectified Linear Unit (ReLU) speeds up training
and prevents the vanishing gradient problem.
• Pooling Layers (MaxPooling2D): Reduce the spatial dimensions of
feature maps while retaining the most important information. This
layer also adds spatial invariance.
• Dropout Layers: Randomly turn off neurons during training to prevent
overfitting and improve generalization.
• Fully Connected (Dense) Layers: After flattening the features, these
layers connect every input to every output neuron. They perform the
final reasoning based on the features extracted by previous layers.
2
• Output Layer (Softmax): The final dense layer with 10 neurons uses
the softmax function to output a probability distribution over the 10
digit classes (0–9).
3. Model Compilation
After building the CNN model, it is compiled using:
• Optimizer: We use Adam, an adaptive learning rate optimization
algorithm that combines RMSprop and momentum. It efficiently
updates model weights with minimal computational cost.
• Loss Function: Categorical Crossentropy measures the dissimilarity
between the predicted probability distribution and the actual label. It
is well-suited for multi-class classification.
• Metrics: Accuracy is the primary evaluation metric during training
and testing.
4. Model Training
Training involves teaching the CNN to recognize patterns through
backpropagation and weight updates:
• Epochs: The model passes through the entire training set multiple
times (e.g., 10–50 epochs), depending on convergence.
• Batch Size: The number of training samples processed at once (e.g.,
32 or 64).
• Callbacks:
o EarlyStopping: Stops training when validation accuracy stops
improving, preventing overfitting.
o ModelCheckpoint: Saves the best version of the model for
deployment.
5. Model Evaluation and Analysis
3
The final model is evaluated on the unseen test dataset:
• Accuracy Score: Shows the proportion of correctly predicted digits.
• Confusion Matrix: A 10×10 matrix showing actual vs. predicted
labels. It highlights which digits the model confuses, aiding further
tuning.
• Loss and Accuracy Curves: Plotted during training and validation to
visualize learning trends, overfitting, or underfitting.