Training the CNN Model

Welcome back! Now that you've built a Convolutional Neural Network (CNN) model for sketch recognition, it's time to bring it to life by training it. Training is a crucial step where the model learns to recognize patterns in the data. This lesson will guide you through the process of training your CNN model using a dataset of hand-drawn sketches. Whether you're familiar with the training process or this is your first time, this lesson will provide you with the knowledge and skills needed to train a CNN model effectively.

In this lesson, you will learn how to train your CNN model on a sketch dataset. We will cover the steps involved in preparing the data, setting up data augmentation, and training the model. You will also learn about the different parameters you can tune during training to improve the model's performance.

Let's break down the code you'll be working with, step by step.

import os
import urllib.request
import numpy as np
from sklearn.model_selection import train_test_split

# Define the categories of sketches to recognize
categories = ['cat', 'house', 'apple']
base_url = 'https://storage.googleapis.com/quickdraw_dataset/full/numpy_bitmap/'

# Download the .npy files for each category if not already present
os.makedirs('quickdraw_data', exist_ok=True)
for cat in categories:
    filepath = f'quickdraw_data/{cat}.npy'
    if not os.path.exists(filepath):
        print(f"Downloading {cat} sketches...")
        urllib.request.urlretrieve(base_url + cat + '.npy', filepath)

# Load and prepare data
data = []
labels = []
IMAGE_COUNT = 3000  # Number of images per category

for idx, cat in enumerate(categories):
    filepath = f'quickdraw_data/{cat}.npy'
    imgs = np.load(filepath)[:IMAGE_COUNT]  # Load images for this category
    data.append(imgs)
    labels.append(np.full(imgs.shape[0], idx))  # Assign a label for each image

# Combine all categories into a single dataset
data = np.concatenate(data, axis=0).reshape(-1, 28, 28, 1).astype('float32') / 255.0  # Normalize pixel values
labels = np.concatenate(labels, axis=0)

# Split the data into training and testing sets
x_train, x_test, y_train, y_test = train_test_split(
    data, labels, test_size=0.2, random_state=42
)

Explanation of Part 1:

• Downloading the data: The code checks if the .npy files for each category exist locally. If not, it downloads them from the QuickDraw dataset.
• Loading and labeling: Each category's images are loaded and assigned a numeric label.
• Combining and normalizing: All images are combined into a single array, reshaped for the CNN, and normalized to values between 0 and 1.
• Splitting: The dataset is split into training and testing sets to evaluate model performance.

from tensorflow.keras.preprocessing.image import ImageDataGenerator
import tensorflow as tf

# Set up data augmentation to improve model generalization
datagen = ImageDataGenerator(
    rotation_range=15,
    width_shift_range=0.1,
    height_shift_range=0.1,
    zoom_range=0.1,
    shear_range=0.1,
    fill_mode='nearest'
)
datagen.fit(x_train)

# Build and train the model
model = build_simple_cnn()  # Assume this function builds your CNN model
history = model.fit(
    datagen.flow(x_train, y_train, batch_size=32),  # Use augmented data
    epochs=1,
    validation_data=(x_test, y_test),
    steps_per_epoch=len(x_train) // 32
)

Explanation of Part 2:

• Data augmentation: The ImageDataGenerator is set up to randomly transform images during training, helping the model generalize better.
• Training: The model is trained using the augmented data, and its performance is validated on the test set.

You will understand each step and how it contributes to the model's learning process.

When you train your model using the model.fit() function, it returns a history object. This object contains valuable information about the training process, such as how the model's accuracy and loss changed over each epoch. Specifically, the history.history dictionary includes lists of metrics recorded at the end of each epoch, such as:

• loss: The training loss for each epoch.
• accuracy: The training accuracy for each epoch (if accuracy is being tracked).
• val_loss: The validation loss for each epoch.
• val_accuracy: The validation accuracy for each epoch.

You can use this information to monitor the model's learning progress, detect overfitting or underfitting, and compare different training runs. For example, you can print the training and validation accuracy after training:

print("Training Accuracy:", history.history['accuracy'])
print("Validation Accuracy:", history.history['val_accuracy'])

By analyzing the history attribute, you gain insights into how your model is learning and can make informed decisions about adjusting hyperparameters or training strategies.

Training a CNN model is a vital skill in machine learning, especially for image recognition tasks. It allows the model to learn from data and improve its accuracy over time. By mastering the training process, you will be able to create models that can recognize and classify images with high precision. This skill is essential for various applications, from developing intelligent systems to advancing research in AI.