Building Your First Convolutional Neural Network for Image Classification with PyTorch

By AISourceNews Team May 7, 2026 6 min read
Hero image for: Building Your First Convolutional Neural Network for Image Classification with PyTorch

In the ever-evolving world of artificial intelligence, convolutional neural networks (CNNs) have become a cornerstone for image-related tasks. This tutorial will guide you through building a simple CNN to classify handwritten digits using the MNIST dataset and PyTorch, one of the most popular deep learning frameworks. By the end, you'll have a working model that demonstrates the power of neural networks in real-world applications. Whether you're a beginner in machine learning or looking to expand your skills, this step-by-step guide will make the process straightforward and engaging.

Why Focus on CNNs for Image Classification?

Convolutional neural networks are specifically designed to process grid-like data, such as images, by automatically detecting patterns and features. Unlike traditional neural networks, CNNs use convolutional layers to capture spatial hierarchies, making them ideal for tasks like handwritten digit recognition. In this tutorial, we'll use the MNIST dataset, which consists of 28x28 pixel images of digits from 0 to 9. This classic dataset is perfect for beginners because it's simple yet effective for illustrating key concepts in machine learning.

Before we dive in, $1 CNNs will enhance your appreciation for how they work. A typical CNN includes layers like convolution, pooling, and fully connected layers. Convolution helps extract features like edges and textures, while pooling reduces the spatial size to make the model more efficient. We'll break this down as we build our model.

Prerequisites for This Tutorial

To follow along, you'll need a basic understanding of Python programming. Familiarity with concepts like arrays, loops, and functions will be helpful. Additionally, ensure you have PyTorch installed on your machine. If not, you can install it via pip by running pip install torch torchvision torchaudio in your terminal. We're assuming you're using a CPU for this tutorial, but if you have a GPU, you can enable it for faster training.

  • Python 3.8 or higher
  • PyTorch library
  • Jupyter Notebook or any Python IDE for easy experimentation
  • Basic knowledge of NumPy for data handling

Once you have these set up, you're ready to start coding. Let's ensure your environment is prepared by importing the necessary libraries.

Setting Up Your Environment

Begin by importing the required modules in your Python script or notebook. PyTorch provides a high-level interface that simplifies building and training neural networks.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

Next, we'll load the MNIST dataset. PyTorch's torchvision library makes this easy with built-in datasets.

# Define a transform to normalize the data
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# Load the training and test datasets
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

This code downloads the MNIST dataset if it's not already in your './data' directory and prepares it for training. Normalization helps the model converge faster by scaling the pixel values.

Designing the CNN Architecture

Now, let's design our CNN model. We'll create a simple architecture with a few convolutional layers, followed by pooling and fully connected layers.

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.pool(self.relu(self.conv1(x)))
        x = self.pool(self.relu(self.conv2(x)))
        x = x.view(-1, 64 * 7 * 7)  # Flatten the tensor
        x = self.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Instantiate the model
model = SimpleCNN()

In this architecture, the first convolutional layer takes 1 input channel (grayscale images) and outputs 32 feature maps. The second layer takes 32 inputs and outputs 64. We use max pooling to downsample the features, and finally, fully connected layers classify the image into one of 10 classes.

Training the Model

With the model defined, it's time to train it. We'll use cross-entropy loss and the Adam optimizer, which are standard for classification tasks in machine learning.

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Training loop
epochs = 5  # Start with 5 epochs for quick results
for epoch in range(epochs):
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {running_loss / len(trainloader)}")

This loop iterates over the training data multiple times (epochs). For each batch, it computes the loss, performs backpropagation, and updates the weights. As the epochs progress, the loss should decrease, indicating the model is learning.

Evaluating the Model

After training, evaluate your model on the test set to see how well it generalizes.

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

$1 = 100 * correct / total
print(f"Accuracy on test set: {accuracy}%")

This code runs the model on unseen data and calculates the accuracy. A well-trained CNN on MNIST typically achieves over 95% accuracy, showcasing the effectiveness of neural networks for image classification.

Tips for Improvement and Next Steps

Once your model is working, experiment with modifications like adding more layers, changing the learning rate, or using dropout for regularization. This will deepen your understanding of machine learning concepts. Remember, building neural networks is iterative—monitor performance metrics and tweak as needed.

In conclusion, this tutorial has walked you through creating a CNN for handwritten digit recognition using PyTorch. By applying these machine learning techniques, you're now equipped to tackle more complex AI projects, such as object detection or $1 image processing.

Related Articles