Handwriting recognition basics in Computer Vision - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main purpose of preprocessing in handwriting recognition?

In handwriting recognition, preprocessing is an important step before feeding data to the model. What is the main goal of preprocessing?

A To increase the size of the dataset by creating new handwritten samples

B To clean and normalize the input images so the model can learn better

C To train the model faster by reducing the number of layers

D To convert the handwritten text into audio signals

💡 Hint

Think about what helps the model understand different handwriting styles better.

Preprocessing cleans and normalizes images, such as resizing and noise removal, so the model can focus on the important features.

❓ Predict Output

intermediate

Output of a simple handwriting image normalization code

What is the shape of the image after normalization in the code below?

Computer Vision

import numpy as np
from PIL import Image

img = Image.open('handwritten_sample.png').convert('L')
img_resized = img.resize((28, 28))
img_array = np.array(img_resized) / 255.0
print(img_array.shape)

A (28, 28)

B (1, 28, 28)

C (28, 28, 1)

D (784,)

💡 Hint

Look at how the image is resized and converted to an array.

The image is resized to 28x28 pixels and converted to a 2D numpy array with shape (28, 28).

❓ Model Choice

advanced

Best model type for recognizing handwritten digits

Which model type is most suitable for recognizing handwritten digits from images?

A Linear Regression

B Recurrent Neural Network (RNN)

C Convolutional Neural Network (CNN)

D K-Means Clustering

💡 Hint

Think about which model handles images and spatial patterns well.

CNNs are designed to detect patterns in images, making them ideal for handwriting recognition.

❓ Metrics

advanced

Choosing the right metric for handwriting recognition accuracy

Which metric best measures how well a handwriting recognition model correctly identifies digits?

A Perplexity

B Mean Squared Error

C Silhouette Score

D Accuracy

💡 Hint

Consider a metric that counts correct predictions over total predictions.

Accuracy measures the percentage of correct predictions, which is suitable for classification tasks like digit recognition.

🔧 Debug

expert

Why does this handwriting recognition model fail to improve accuracy?

Consider this training loop for a handwriting recognition model. Why does the accuracy stay low after many epochs?

for epoch in range(10):
    for images, labels in train_loader:
        outputs = model(images)
        loss = criterion(outputs, labels)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    print(f'Epoch {epoch+1}, Loss: {loss.item()}')

A The model is not set to training mode, so dropout and batch norm behave incorrectly

B The optimizer.zero_grad() is called after loss.backward(), causing gradient accumulation

C The loss is not computed using the correct labels tensor shape

D The print statement is inside the inner loop, causing too many outputs

💡 Hint

Think about what happens if the model is not told it is training.

If the model is not in training mode, layers like dropout and batch normalization do not work properly, hurting learning.

Practice

1. What is the main goal of handwriting recognition in computer vision?

easy

A. To convert images of handwritten text into digital text

B. To create handwritten images from typed text

C. To detect faces in handwritten notes

D. To enhance the colors of handwritten images

Solution

1. Step 1: Understand handwriting recognition purpose

   Handwriting recognition aims to read and convert handwritten text images into machine-readable text.

2. Step 2: Compare options with this goal

   Only To convert images of handwritten text into digital text matches this goal; others describe unrelated tasks.

3. Final Answer:

   To convert images of handwritten text into digital text -> Option A

4. Quick Check:

   Handwriting recognition = convert handwriting to text [OK]

Hint: Think: handwriting recognition means reading handwriting [OK]

Common Mistakes:

• Confusing recognition with image enhancement
• Thinking it creates handwriting instead of reading it
• Mixing handwriting with face detection

2. Which Python library is commonly used to load the MNIST dataset for handwriting recognition?

easy

A. pandas

B. matplotlib

C. tensorflow.keras.datasets

D. scikit-learn.preprocessing

Solution

1. Step 1: Recall common MNIST loading methods

   The MNIST dataset is often loaded using tensorflow.keras.datasets for easy access.

2. Step 2: Check options for dataset loading

   Only tensorflow.keras.datasets provides direct MNIST loading; others do not.

3. Final Answer:

   tensorflow.keras.datasets -> Option C

4. Quick Check:

   MNIST load = tensorflow.keras.datasets [OK]

Hint: Remember: TensorFlow has built-in MNIST loader [OK]

Common Mistakes:

• Choosing matplotlib which is for plotting
• Selecting pandas which handles tables, not images
• Confusing preprocessing with dataset loading

3. What will be the output shape of the images array after loading MNIST dataset with (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()?

medium

A. (28, 28, 60000)

B. (60000, 28, 28)

C. (60000, 784)

D. (60000, 28, 28, 1)

Solution

1. Step 1: Understand MNIST image shape

   MNIST images are 28x28 pixels grayscale images, and training set has 60000 samples.

2. Step 2: Check output shape from load_data()

   Images are loaded as (60000, 28, 28) without channel dimension by default.

3. Final Answer:

   (60000, 28, 28) -> Option B

4. Quick Check:

   MNIST images shape = (60000, 28, 28) [OK]

Hint: MNIST images are 28x28 pixels, 60000 training samples [OK]

Common Mistakes:

• Assuming images are flattened to 784 by default
• Confusing channel dimension presence
• Mixing sample count with image dimensions

4. Identify the error in this simple neural network code for handwriting recognition:

model = tf.keras.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28, 1)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dense(10)
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

medium

A. Optimizer name is invalid

B. Missing activation function in the last Dense layer

C. Wrong loss function for classification

D. Incorrect input_shape in Flatten layer

Solution

1. Step 1: Review model architecture

   MNIST images from load_data() have shape (60000, 28, 28).

2. Step 2: Check input_shape in Flatten

   input_shape=(28, 28, 1) expects input of shape (None, 28, 28, 1), but MNIST data is (None, 28, 28), causing shape mismatch.

3. Final Answer:

   Incorrect input_shape in Flatten layer -> Option D

4. Quick Check:

   MNIST x_train.shape = (60000, 28, 28), input_shape=(28, 28) [OK]

Hint: MNIST default shape is (60000, 28, 28), no channel dim [OK]

Common Mistakes:

• Focusing on missing output activation (optional with this loss)
• Thinking loss is wrong (correct for integer labels)
• Assuming optimizer string is invalid (strings work)

5. You want to improve handwriting recognition accuracy by adding dropout to the model. Which code snippet correctly adds dropout after the first Dense layer?

hard

A. tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dropout(0.2)

B. tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(128, activation='relu')

C. tf.keras.layers.Dense(128, activation='relu', dropout=0.2)

D. tf.keras.layers.Dense(128, activation='relu', rate=0.2)

Solution

1. Step 1: Understand dropout usage in Keras

   Dropout is a separate layer added after a Dense layer to randomly ignore neurons during training.

2. Step 2: Check each option for correct syntax

   tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dropout(0.2) correctly places Dropout after Dense with correct parameter 0.2; options C and D incorrectly add dropout as Dense parameters; tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(128, activation='relu') reverses order, which is not standard.

3. Final Answer:

   tf.keras.layers.Dense(128, activation='relu'), tf.keras.layers.Dropout(0.2) -> Option A

4. Quick Check:

   Dropout is a separate layer after Dense [OK]

Hint: Dropout is its own layer placed after Dense layer [OK]

Common Mistakes:

• Trying to add dropout as Dense layer argument
• Placing Dropout before Dense layer
• Using wrong parameter names for dropout