Understanding Convolutional Neural Networks (CNN) using Python: A Step-by-Step Guide for Image Classification

Convolutional Neural Networks (CNNs) are one of the most powerful tools in deep learning, particularly for tasks related to computer vision. Whether it’s for image classification, object detection, or image segmentation, CNNs are designed to process visual data with great efficiency. In this blog, we will dive into the workings of CNNs, explore their architecture, and walk you through an example of image classification using Python and TensorFlow with the CIFAR-10 dataset.

What is a Convolutional Neural Network (CNN)?

CNNs are a type of artificial neural network that is specialized for processing structured grid data, such as images. They are designed to automatically and adaptively learn spatial hierarchies of features from images. Unlike traditional neural networks that use fully connected layers, CNNs use local receptive fields and layers like convolution, pooling, and fully connected layers to extract patterns at different levels.

Why CNNs?

• Automatic feature extraction: CNNs are excellent for learning features automatically, making them ideal for image classification tasks where human-engineered features would be difficult to define.
• Fewer parameters: CNNs use shared weights in the convolution layers, reducing the total number of parameters, and making the model computationally efficient.
• Invariance to translation and distortion: CNNs are less sensitive to the location of features in the image, making them robust to small distortions, rotations, or translations.

Core Components of a CNN

A typical CNN architecture consists of several layers designed to extract features, reduce dimensionality, and perform classification:

1. Convolutional Layer: This layer applies a filter or kernel to the image to extract local features like edges, textures, and shapes.
2. Activation Function (ReLU): After convolution, the output is passed through an activation function like ReLU (Rectified Linear Unit), which introduces non-linearity by setting all negative values to zero.
3. Pooling Layer: Pooling layers like MaxPooling reduce the spatial dimensions of the feature map and retain only the most important information.
4. Fully Connected Layer: After feature extraction, the network “flattens” the data into one dimension and passes it through one or more fully connected layers to perform the final classification.
5. Dropout Layer: Dropout is used to prevent overfitting by randomly “dropping” neurons during training.

How Does CNN Work?

Let’s break down how the CNN works at a high level:

1. Convolution: A filter (kernel) slides over the input image, performing matrix multiplication at each location to extract features. The result is a feature map.
2. Padding: Padding is added to prevent the feature map from shrinking during the convolution process, ensuring that important features on the borders are not lost.
3. Activation (ReLU): After convolution, the feature map is passed through a non-linear activation function, usually ReLU, to introduce non-linearity and allow the network to learn more complex patterns.
4. Pooling: MaxPooling or AveragePooling reduces the size of the feature map while retaining important features. Pooling helps in reducing computation and mitigating overfitting.
5. Fully Connected Layers: After flattening the pooled feature maps, the data is passed through fully connected layers to perform classification. The output layer typically uses softmax for multi-class classification.

Practical Example: Image Classification with CNN and CIFAR-10

In this section, we will implement a simple CNN for image classification using the CIFAR-10 dataset, which consists of 60,000 images in 10 classes such as Airplane, Dog, Cat, and more. We will build and train a CNN model using TensorFlow and Keras.

Step 1: Load the CIFAR-10 Dataset

We start by loading the CIFAR-10 dataset from TensorFlow‘s keras.datasets module.

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

# Load CIFAR-10 dataset
cifar10 = tf.keras.datasets.cifar10
(X_train, y_train), (X_test, y_test) = cifar10.load_data()

# Print the shapes of the dataset
print(X_train.shape, X_test.shape, y_train.shape, y_test.shape)

Step 2: View Sample Images

We can visualize a few sample images from the dataset to understand the data better.

labels = [‘Airplane’, ‘Automobile’, ‘Bird’, ‘Cat’, ‘Deer’, ‘Dog’, ‘Frog’, ‘Horse’, ‘Ship’, ‘Truck’]

fig, axes = plt.subplots(ncols=5, nrows=4, figsize=(12, 12))
index = 0
for i in range(4):
for j in range(5):
axes[i,j].set_title(labels[y_train[index][0]])
axes[i,j].imshow(X_train[index])
axes[i,j].get_xaxis().set_visible(False)
axes[i,j].get_yaxis().set_visible(False)
index += 1

Step 3: Data Preprocessing

Before feeding the images into the CNN, we need to normalize the image data (scale pixel values between 0 and 1) and perform one-hot encoding on the labels.

# Normalize pixel values to be between 0 and 1
X_train = X_train / 255.0
X_test = X_test / 255.0

# One-hot encode labels
from tensorflow.keras.utils import to_categorical
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

Step 4: Build the CNN Model

Now we will build a CNN model using Keras with multiple convolutional layers, max-pooling, dropout layers, and a fully connected output layer.

from keras.models import Sequential
from keras.layers import Conv2D, MaxPool2D, Flatten, Dense, Dropout, BatchNormalization

model = Sequential()

# Convolutional Layer 1
model.add(Conv2D(filters=32, kernel_size=(3, 3), input_shape=(32, 32, 3), activation=’relu’, padding=’same’))
model.add(BatchNormalization())
model.add(Conv2D(filters=32, kernel_size=(3, 3), activation=’relu’, padding=’same’))
model.add(BatchNormalization())

# Pooling Layer 1
model.add(MaxPool2D(pool_size=(2, 2)))

# Dropout Layer 1
model.add(Dropout(0.25))

# Convolutional Layer 2
model.add(Conv2D(filters=64, kernel_size=(3, 3), activation=’relu’, padding=’same’))
model.add(BatchNormalization())
model.add(Conv2D(filters=64, kernel_size=(3, 3), activation=’relu’, padding=’same’))
model.add(BatchNormalization())

# Pooling Layer 2
model.add(MaxPool2D(pool_size=(2, 2)))

# Dropout Layer 2
model.add(Dropout(0.25))

# Convolutional Layer 3
model.add(Conv2D(filters=128, kernel_size=(3, 3), activation=’relu’, padding=’same’))
model.add(BatchNormalization())
model.add(Conv2D(filters=128, kernel_size=(3, 3), activation=’relu’, padding=’same’))
model.add(BatchNormalization())

# Pooling Layer 3
model.add(MaxPool2D(pool_size=(2, 2)))

# Dropout Layer 3
model.add(Dropout(0.25))

# Flatten Layer
model.add(Flatten())

# Fully Connected Layer
model.add(Dense(128, activation=’relu’))
model.add(Dropout(0.25))

# Output Layer
model.add(Dense(10, activation=’softmax’))

Step 5: Compile and Train the Model

Now that the model is built, we will compile it with categorical cross-entropy loss, Adam optimizer, and accuracy metrics. Then, we train the model.

# Compile the model
model.compile(loss=’categorical_crossentropy’, optimizer=’adam’, metrics=[‘accuracy’])

# Train the model
model.fit(X_train, y_train, epochs=12)

Step 6: Evaluate the Model

Finally, we evaluate the performance of our CNN on the test set.

# Evaluate the model
test_loss, test_acc = model.evaluate(X_test, y_test)

# Print the test accuracy
print(f”Test Accuracy: {test_acc * 100:.2f

Output: