What is a CNN? Convolutional Neural Networks Explained

TL;DR: A CNN (Convolutional Neural Network) is like a specialized visual brain for computers. Instead of looking at an entire image all at once, it uses small “magnifying glasses” to scan local regions $\rightarrow$ finds simple patterns like lines, corners, and edges $\rightarrow$ connects them into shapes $\rightarrow$ and finally predicts whether the image is a cat 🐱, a dog 🐶, or a car 🚗.

1. Imagine a CNN Learning to Recognize a Cat 🐱#

Suppose we want to teach a computer to identify cats. We show it thousands of labeled photos:

🐱  🐱  🐱  🐱  🐱  (Image 1 -> CAT, Image 2 -> CAT)
🐶  🐶  🐶  🐶      (Image 3 -> DOG)
🚗  🚗  🚗          (Image 4 -> CAR)

At first, the computer has zero prior knowledge of what a “cat” is. It does not know about whiskers, pointy ears, or fur. It must learn everything from scratch.

But how does a computer actually “see” an image?

2. How Computers “See” Images#

To human eyes, a photograph is rich and vibrant. To a computer, every image is merely a huge grid of numbers (a pixel matrix).

Example 5x5 Grayscale Image:

0    0    0    0    0
0  255  255    0    0
0  255  255    0    0
0    0    0    0    0
0    0    0    0    0

• 0 represents pure black.
• 255 represents bright white.
• Numbers in between (1 to 254) represent various shades of gray.

For a color image, every pixel contains 3 numbers corresponding to RGB (Red, Green, Blue) channels:

• (255, 0, 0) $\rightarrow$ Bright Red
• (0, 255, 0) $\rightarrow$ Bright Green
• (0, 0, 255) $\rightarrow$ Bright Blue

[!NOTE] To a computer, a standard $1920 \times 1080$ wallpaper isn’t visual art — it is over 6 million numbers organized into rows and columns.

3. The Magnifying Glass: Convolution & Filters#

If you feed millions of raw pixel numbers directly into a traditional neural network, the model quickly gets overwhelmed and loses spatial relationships between neighboring pixels.

CNNs solve this with Filters (or Kernels), which act like tiny magnifying glasses:

Original Image (5x5):         Filter / Magnifying Glass (3x3):
⬜  ⬜  ⬜  ⬜  ⬜              ┌───────────┐
⬜  ⬛  ⬛  ⬜  ⬜              │ ⬜  ⬜  ⬜ │
⬜  ⬜  ⬜  ⬜  ⬜              │ ⬜  ⬛  ⬛ │  (Slides step-by-step)
⬜  ⬜  ⬜  ⬜  ⬜              │ ⬜  ⬜  ⬜ │
⬜  ⬜  ⬜  ⬜  ⬜              └───────────┘

This filter slides systematically across the image from left to right, top to bottom:

$\rightarrow \rightarrow \rightarrow$ $\rightarrow \rightarrow \rightarrow$

This sliding and element-wise multiplication process is called Convolution — the foundational “C” in CNN.

4. Filters Act Like a Team of Detectives 🕵️#

Each filter is specialized to hunt for one specific visual cue:

• Detective A: “I look for vertical lines |”
• Detective B: “I look for horizontal lines -”
• Detective C: “I look for diagonal slashes / or \”
• Detective D: “I look for sharp corners L”

When a filter scans an area that matches its target feature, it outputs high activation numbers. Collecting these outputs across the whole image produces a Feature Map:

When detecting a vertical line:
0   0   1   0
0   0   1   0
0   0   1   0  --> "Aha! Column 3 has a clean vertical line!"

[!TIP] The magic of Deep Learning: Humans never hardcode these filter values. The CNN automatically discovers and refines optimal filter weights through training data!

5. Hierarchical Architecture (Deep Layers): From Edges to Cats#

Why is this called a Deep Neural Network? Because multiple layers are stacked sequentially, building abstractions from simple to complex:

flowchart TD
    A["Raw Input Image (Pixel Grid)"] --> B["Layer 1: Edges, lines, corners, colors"]
    B --> C["Layer 2: Shapes (Circles, squares, textures)"]
    C --> D["Layer 3: Parts (Eyes + Ears + Nose + Whiskers)"]
    D --> E["Layer 4: Full Face & Body contours"]
    E --> F["Final Prediction: CAT 🐱 (95%)"]

1. Early Layers: Detect basic building blocks (|, -, /, corners, solid colors).
2. Intermediate Layers: Combine basic edges into textures and geometric shapes (ear contours, eye circles).
3. Deeper Layers: Assemble parts into semantic facial structures (whiskers + eyes + snout).
4. Final Layer (Fully Connected): Integrates all discovered components to conclude: “This is a cat!”.

6. Downsampling with Pooling (Max Pooling)#

Raw images contain substantial redundant data. After detecting features, we compress the feature maps to reduce computational load while preserving the most prominent activations. This technique is known as Pooling.

The most popular approach is Max Pooling — slicing the matrix into small grids and keeping only the maximum value:

Original 4x4 Grid:                 Max Pooling (2x2 Window):
1   2  |  3   4                    ┌─────────┬─────────┐
5   9  |  2   1                    │    9    │    4    │
-------+-------      ======>       ├─────────┼─────────┤
4   3  |  8   2                    │    4    │    8    │
1   2  |  1   7                    └─────────┴─────────┘

Max Pooling works like summarizing a large, high-detail poster by taking quick notes of only the most striking landmarks.

7. How the Network Learns: Loss & Gradient Descent#

When a CNN is newly initialized, its filter numbers are completely random. When shown a picture of a cat 🐱, its initial guess might be:

• Cat: $10\%$
• Dog: $80\%$
• Car: $10\%$

Completely wrong! 😭 The model calculates how far off it was using a mathematical error function called Loss:

$\text{Loss} = \text{Distance}(\text{Prediction}, \text{Ground Truth})$

The learning loop is identical to practicing archery:

1. First Shot: The arrow lands far from the bullseye (High Loss).
2. Estimate Error: Check whether you aimed too far left, right, high, or low.
3. Adjust Stance (Backpropagation & Gradient Descent): Rotate your arm angle slightly.
4. Shoot Again: The arrow lands much closer to the target!

Standing on a mountain peak (Loss = 10)
    🧍
   /  \
  /    \      -> Step in the steepest downhill direction
 /      \
/        \___
             ↓
         Valley floor (Loss = 0.01 -> 99% accuracy)

8. Simple CNN Implementation in PyTorch#

Here is a clean and practical implementation of a convolutional neural network using PyTorch:

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

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # Layer 1: Takes 1 channel (grayscale), applies 16 filters (3x3)
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, padding=1)
        # Layer 2: Takes 16 channels, applies 32 filters (3x3)
        self.conv2 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=3, padding=1)
        # Max pooling downsamples spatial dimensions by 2x
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        # Fully connected layers for 10-class output
        self.fc1 = nn.Linear(32 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        # Input -> Conv1 -> ReLU -> Pool
        x = self.pool(F.relu(self.conv1(x)))
        # -> Conv2 -> ReLU -> Pool
        x = self.pool(F.relu(self.conv2(x)))
        # Flatten spatial tensors into 1D vectors
        x = x.view(-1, 32 * 7 * 7)
        # Fully Connected -> Classification logits
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# Initialize and inspect the model
model = SimpleCNN()
print(model)

9. Summary: 6 Key Steps to Remember CNNs#

If you need to explain how a CNN works to a colleague or a 10-year-old in under 30 seconds:

1. IMAGE         (Raw grid of numerical pixel intensities)
   ↓
2. CONVOLUTION   (Magnifying filters scanning local regions)
   ↓
3. FEATURE MAP   (Heatmaps marking detected patterns)
   ↓
4. POOLING       (Compressing size while keeping top signals)
   ↓
5. DEEP LAYERS   (Assembling edges -> textures -> objects)
   ↓
6. PREDICTION    (Final class confidence scores: Cat 95%, Dog 3%)

[!TIP] Key Takeaway: Instead of engineers manually crafting millions of fragile if/else rules, CNNs autonomously learn visual representations directly from data via gradient-based optimization!

References#

• CS231n: Deep Learning for Computer Vision - Stanford University ↗
• Deep Learning Book by Ian Goodfellow, Yoshua Bengio, and Aaron Courville ↗
• PyTorch Official Documentation - Convolution Layers ↗
• Neural Networks and Deep Learning by Michael Nielsen ↗