theaicompendium.com

Building a Convolutional Neural Network in PyTorch

hasnainmehdi1172@gmail.com hasnainmehdi1172@gmail.com

Neural networks consist of interconnected layers, and for image-related applications, convolutional layers are crucial. These layers, while having comparatively few parameters, are applied over larger inputs and preserve the spatial structure of images, enabling state-of-the-art results in computer vision tasks. This article will guide you through the fundamentals of convolutional layers and the architecture of a convolutional neural network (CNN) using PyTorch.

In this tutorial, you will learn about:

Let’s get started!

Overview

This tutorial is divided into four sections:

  1. The Case for Convolutional Neural Networks
  2. Building Blocks of Convolutional Neural Networks
  3. An Example of a Convolutional Neural Network
  4. Understanding Feature Maps

The Case for Convolutional Neural Networks

To illustrate the capabilities of a neural network, let’s consider a task involving grayscale images—a common introductory example in computer vision. A grayscale image consists of an array of pixels, where each pixel holds a value between 0 and 255. An image sized 32×32 would have 1,024 pixels, resulting in a challenging input for traditional neural networks.

Simply analyzing pixel values does not yield significant insights into the image’s content, as crucial information lies in its spatial arrangement (e.g., the presence of lines or shapes). Hence, conventional neural networks may struggle to derive meaningful features from image data.

Convolutional neural networks (CNNs) utilize convolutional layers to maintain the spatial relationships of pixel data. These layers learn to recognize patterns among neighboring pixels, generating feature representations that can withstand minor distortions, such as shifts, rotations, or scalings in the image content.

Building Blocks of Convolutional Neural Networks

The simplest CNN typically comprises three essential layer types:

  1. Convolutional Layers: These apply filters to input images to extract features.
  2. Pooling Layers: These downsample feature maps to condense information and reduce dimensionality.
  3. Fully Connected Layers: These layers connect every neuron from the previous layer to the next, enabling classification based on learned features.

In an image classification scenario, a convolutional layer will apply filters (or kernels) to the image. Each filter computes convolution operations on the image, resulting in a feature map that highlights specific features detected by the filter.

Example of Convolutional Layer:
When working with an image, the convolutional layer uses a filter size of 3×3 pixels, capturing a small patch from the input to produce one output value. Multiple filters are applied to generate various feature maps, helping the model learn diverse aspects of the input image.

An Example of a Convolutional Neural Network

Let’s create a convolutional neural network model for classifying images from the CIFAR-10 dataset.

import torch
import torch.nn as nn
import torchvision

# Load CIFAR-10 dataset
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()])
train_set = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
test_set = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

Build the Model Architecture

Now, let’s define a simple CNN architecture. This model will contain multiple convolutional and pooling layers:

class CIFAR10Model(nn.Module):
    def __init__(self):
        super(CIFAR10Model, self).__init__()
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.fc1 = nn.Linear(32 * 16 * 16, 128)
        self.fc2 = nn.Linear(128, 10)  # Output layer for 10 classes

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # Apply first convolution and pooling
        x = x.view(-1, 32 * 16 * 16)  # Flatten the output for the fully connected layer
        x = F.relu(self.fc1(x))  # Apply ReLU activation
        x = self.fc2(x)  # Final output layer
        return x

Training the Model

To train your CNN model, create DataLoader instances for both training and test datasets. The following example uses a batch size of 64:

from torch.utils.data import DataLoader

train_loader = DataLoader(train_set, batch_size=64, shuffle=True)
test_loader = DataLoader(test_set, batch_size=64, shuffle=False)

# Define the model and loss function
model = CIFAR10Model()
criterion = nn.CrossEntropyLoss()  # Suitable for multi-class classification
optimizer = torch.optim.SGD(model.parameters(), lr=0.001)  # Stochastic Gradient Descent

# Training loop
for epoch in range(10):  # Training for 10 epochs
    model.train()
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)  # Forward pass
        loss = criterion(outputs, labels)  # Compute loss
        loss.backward()  # Backpropagation
        optimizer.step()  # Update weights

    # Calculate accuracy
    model.eval()
    correct = 0
    total = 0
    with torch.no_grad():
        for inputs, labels in test_loader:
            outputs = model(inputs)
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()

    accuracy = 100 * correct / total
    print(f'Epoch {epoch + 1}: Model accuracy: {accuracy:.2f}%')

Summary

In this tutorial, you learned how to build a convolutional neural network (CNN) using PyTorch for handwritten digit recognition. Specifically, you covered the following:

By following this guide, you are now equipped to develop and experiment with CNNs for various image classification tasks using PyTorch. With continued practice, you’ll be able to harness the full potential of deep learning applications in your projects.

Exit mobile version