How Convolutional Neural Networks Work Explained With Examples

When traditional fully connected neural networks try to process high-resolution digital images, they hit a severe architectural wall. A single $1080\text{p}$ color image contains over 6 million raw pixel values ($1920 \times 1080 \times 3$). Feeding this raw array directly into a standard dense neural network requires hundreds of millions of trainable weights in the very first layer alone—leading to catastrophic overfitting, massive memory consumption, and complete loss of spatial relationships between neighboring pixels.

To solve this spatial challenge, computer scientists drew inspiration from biological vision systems (specifically Hubel and Wiesel’s discovery of visual cortex receptive fields) to create Convolutional Neural Networks (CNNs). CNNs are specialized deep learning architectures designed to process data structured as multi-dimensional arrays, such as images, video frames, and audio spectrograms.

In this technical, step-by-step guide, we break down how Convolutional Neural Networks work under the hood—examining kernels, stride, padding, non-linear activations (ReLU), spatial pooling, and dense classification heads with clear worked examples.

1. The Four Core Layers of a Convolutional Neural Network

A typical CNN architecture processes input images through two distinct functional phases: Feature Extraction (Convolutions, Activations, and Pooling) and Classification (Flattening, Fully Connected Layers, and Softmax).

2. Layer 1: The Convolutional Layer (Kernels & Feature Maps)

The Convolutional Layer is the core building block of a CNN. Instead of connecting every single input pixel to every neuron, a convolutional layer applies a small matrix of weights—called a Filter or Kernel (typically $3 \times 3$ or $5 \times 5$)—that slides across the input image.

Worked Mathematical Example: 2D Convolution

Consider a simplified $5 \times 5$ single-channel grayscale image and a $3 \times 3$ edge-detection kernel:

$$\text{Input Image } (5 \times 5) = \begin{bmatrix} 1 & 1 & 1 & 0 & 0 \\ 0 & 1 & 1 & 1 & 0 \\ 0 & 0 & 1 & 1 & 1 \\ 0 & 0 & 1 & 1 & 0 \\ 0 & 1 & 1 & 0 & 0 \end{bmatrix}, \quad \text{Kernel } (3 \times 3) = \begin{bmatrix} 1 & 0 & -1 \\ 1 & 0 & -1 \\ 1 & 0 & -1 \end{bmatrix}$$

To calculate the top-left output value of the resulting **Feature Map**, align the $3 \times 3$ kernel over the top-left $3 \times 3$ sub-region of the image and perform element-wise multiplication followed by summation:

$$\text{Output}_{(0,0)} = (1 \times 1) + (1 \times 0) + (1 \times -1) + (0 \times 1) + (1 \times 0) + (1 \times -1) + (0 \times 1) + (0 \times 0) + (1 \times -1) = -3$$

The kernel slides across the image from left to right, top to bottom, repeating this dot product operation to generate a 2D **Feature Map** highlighting vertical edges.

Key Hyperparameters: Stride and Padding

• Stride ($S$): The number of pixels the kernel shifts at each step. A stride of $1$ moves the filter one pixel at a time; a stride of $2$ hops two pixels, downsampling the output feature map size.
• Padding ($P$): Adding border rows/columns of zeros around the input matrix. **Same Padding** ensures the output feature map retains the exact spatial height and width as the input image.

The spatial dimensions of the output feature map are calculated using the formula:

$$\text{Output Width} = \left\lfloor \frac{\text{Input Width} – \text{Kernel Size} + 2 \times \text{Padding}}{\text{Stride}} \right\rfloor + 1$$

3. Layer 2: Non-Linear Activation (ReLU)

Convolutions are linear mathematical operations. However, real-world visual patterns (such as complex shapes, object boundaries, and lighting gradients) are non-linear. To enable the network to learn complex patterns, the feature map passes through an activation function—most commonly the Rectified Linear Unit (ReLU).

The ReLU function replaces all negative pixel values in the feature map with zero, preserving positive activations:

$$f(x) = \max(0, x)$$

# ReLU Input Feature Map:
[ -3,   5,   0 ]
[  2,  -8,   7 ]

# Output Feature Map after ReLU:
[  0,   5,   0 ]
[  2,   0,   7 ]

4. Layer 3: Spatial Pooling (Max Pooling & Downsampling)

As networks grow deeper, feature maps retain massive spatial volume. The **Pooling Layer** subsamples feature maps to reduce spatial dimensions (height and width) while retaining the most critical visual signals.

How Max Pooling Works

The most common configuration is $2 \times 2$ **Max Pooling** with a stride of $2$. The filter slides over non-overlapping $2 \times 2$ regions and extracts strictly the maximum value:

$$\text{Input Sub-Region } \begin{bmatrix} 12 & 20 \\ 8 & 15 \end{bmatrix} \implies \text{Max Output} = 20$$

Max pooling provides three major technical benefits:

1. Dimensionality Reduction: Reduces parameters and computational load by 75%, preventing overfitting.
2. Translation Invariance: Ensures the model recognizes an object (e.g., a cat’s ear) even if it shifts slightly in position within the frame.
3. Feature Abstraction: Forces downstream layers to focus on high-level dominant features rather than precise pixel coordinates.

5. Layer 4: Flattening & Fully Connected Classification Head

After several stacked Convolution $\rightarrow$ ReLU $\rightarrow$ Pooling blocks, the spatial dimensions of the image have been compressed into high-level feature tensors. To perform final classification (e.g., categorizing an image as a Dog, Cat, or Car), the 3D feature tensor is unrolled into a 1D vector—a process called Flattening.

This 1D vector is fed into standard **Fully Connected (Dense) Layers**. The final layer uses a **Softmax Activation Function** to convert raw output logits into a normalized probability distribution summing to 1.0 (100%):

$$\sigma(z)_i = \frac{e^{z_i}}{\sum_{j=1}^{K} e^{z_j}}$$

6. Complete Hands-On Implementation in Python (PyTorch)

Let us build a complete, runnable CNN model in Python using **PyTorch**. This model accepts RGB input images ($3 \times 32 \times 32$), passes them through two convolutional blocks with Max Pooling, and outputs class probabilities across 10 categories:

import torch
import torch.nn as nn
import torch.nn.functional as F

class ConvolutionalNeuralNetwork(nn.Module):
    def __init__(self, num_classes=10):
        super(ConvolutionalNeuralNetwork, self).__init__()
        
        # Block 1: Conv -> ReLU -> MaxPool
        # Input: [Batch, 3, 32, 32] -> Output: [Batch, 16, 16, 16]
        self.conv_block1 = nn.Sequential(
            nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(16),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        
        # Block 2: Conv -> ReLU -> MaxPool
        # Input: [Batch, 16, 16, 16] -> Output: [Batch, 32, 8, 8]
        self.conv_block2 = nn.Sequential(
            nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, stride=1, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(kernel_size=2, stride=2)
        )
        
        # Fully Connected Classification Head
        # Flattened Input: 32 channels * 8 height * 8 width = 2048 elements
        self.classifier_head = nn.Sequential(
            nn.Linear(32 * 8 * 8, 128),
            nn.ReLU(),
            nn.Dropout(0.3), # Regularization to prevent overfitting
            nn.Linear(128, num_classes)
        )

    def forward(self, x):
        # Pass input tensor through feature extraction blocks
        x = self.conv_block1(x)
        x = self.conv_block2(x)
        
        # Flatten 3D feature maps into 1D vector for dense layers
        x = x.view(x.size(0), -1)
        
        # Compute final classification logits
        logits = self.classifier_head(x)
        return logits

# Verification Execution
if __name__ == "__main__":
    # Instantiate Model
    model = ConvolutionalNeuralNetwork(num_classes=10)
    model.eval()
    
    # Create a dummy batch of 4 RGB images (Batch Size: 4, Channels: 3, Height: 32, Width: 32)
    dummy_input = torch.randn(4, 3, 32, 32)
    
    # Execute forward pass
    output_logits = model(dummy_input)
    probabilities = F.softmax(output_logits, dim=1)
    
    print("=== CNN Architecture Model Verification ===")
    print(f"Input Batch Tensor Shape : {dummy_input.shape}")
    print(f"Output Logits Shape     : {output_logits.shape}")
    print(f"Sample Class Probabilities (Image 1): {probabilities[0].detach().numpy().round(4)}")

7. Summary & Key Takeaways

Convolutional Neural Networks revolutionize computer vision by using parameter sharing and spatial hierarchies to automatically learn visual feature representations directly from pixel tensors.

Manish Prakash Dubey

Manish Prakash Dubey is an AI educator and technology writer based in India. He founded WiseAIWorld to make artificial intelligence simple and practical for students, professionals, and beginners. His work focuses on AI basics, machine learning, deep learning, NLP, computer vision, and real-world AI tools.