Convolutional Neural Networks

Before 2012, teaching a computer to recognise a cat in a photo required hand-crafted rules — thousands of lines of code describing whiskers, fur, ears. Engineers spent years building these brittle systems.

Then, in 2012, a Convolutional Neural Network called AlexNet slashed the error rate on the ImageNet competition by nearly half — from 26% to 15.3% — in a single year. No hand-crafted rules. The network learned what features mattered, directly from raw pixels.

💡

Beginner Analogy

Think of a CNN as a toddler learning to recognise animals. At first they see blurry blobs (low-level features), then shapes (mid-level), then full animals (high-level). CNNs learn in exactly the same layered way.

Real-World Applications of CNNs

We use Python because it has the richest deep learning ecosystem on the planet. The two libraries you'll live in are NumPy (fast maths) and Matplotlib (visualisation).

# Creating a 3×3 matrix (a grayscale image patch)
import numpy as np

patch = np.array([
    [10, 20, 30],
    [40, 50, 60],
    [70, 80, 90]
])

print(patch.shape)   # → (3, 3)
print(patch.mean())  # → 50.0  (average pixel brightness)

• Python Refresher
• NumPy Basics
• Matrices & Arrays
• Data Visualisation

The Three Pillars

Matrix Multiplication

Every layer in a neural network is a matrix multiplication. Understanding this unlocks the entire architecture.

Derivatives & Partial Derivatives

The derivative of the loss tells the network which direction to adjust its weights. Partial derivatives extend this to millions of parameters simultaneously.

Gradient Descent

The learning algorithm. Like rolling a ball down a hill to find the lowest point (minimum loss).

• Vectors & Matrices
• Matrix Multiplication
• Derivatives
• Partial Derivatives
• Chain Rule
• Gradient Descent Basics

A biological neuron receives signals through dendrites, processes them in the cell body, and fires an output signal down the axon if the input is strong enough. Artificial neurons work identically — mathematically.

Each artificial neuron: (1) receives inputs, (2) multiplies each by a weight, (3) sums everything up, (4) passes the sum through an activation function, (5) outputs the result.

⚙ Neuron Output

output = activation( Σ(xᵢ · wᵢ) + b )

x = inputs  |  w = weights  |  b = bias

Activation Functions — Introducing Non-Linearity

Grayscale Images

A grayscale image is a 2D matrix where each value (pixel) is between 0 (black) and 255 (white). A 28×28 grayscale image has 784 numbers — that's all a computer ever sees.

RGB Colour Images

A colour image has three channels — Red, Green, Blue — stacked on top of each other. A 224×224 colour image is actually a 3D tensor of shape (224, 224, 3) containing 150,528 values.

📝

Colour Mixing

Red (255, 0, 0) + Green (0, 255, 0) = Yellow (255, 255, 0). Every colour on your screen is a combination of RGB intensity values.

Image Preprocessing — Why It Matters

A kernel (also called a filter) is a tiny matrix — typically 3×3 or 5×5 — of learnable numbers. During convolution, this kernel slides across the input image, and at each position, we compute an element-wise product and sum the result.

The result of sliding a kernel across the entire image is called a feature map. It shows where in the image the kernel's pattern was found.

💡

Real Analogy

Imagine holding a magnifying glass (kernel) over a document and sliding it across. At each spot, you check if a particular pattern (e.g. the letter "e") matches. The feature map records the match strength at every location.

Stride and Padding Explained

Visual Labs — What Different Kernels Detect

# Applying a convolution in Python (from scratch)
import numpy as np

def convolve2d(image, kernel):
    kH, kW = kernel.shape
    iH, iW = image.shape
    # Output dimensions (no padding)
    out = np.zeros((iH - kH + 1, iW - kW + 1))
    for y in range(out.shape[0]):
        for x in range(out.shape[1]):
            region = image[y:y+kH, x:x+kW]
            out[y, x] = np.sum(region * kernel)
    return out

# Vertical edge detector kernel
kernel = np.array([[-1, 0, 1],
                   [-2, 0, 2],
                   [-1, 0, 1]])

result = convolve2d(my_image, kernel)

A typical CNN processes an image through a repeating pattern of Convolution → Activation → Pooling blocks, followed by fully-connected layers for final classification.

from tensorflow import keras

model = keras.Sequential([
    # Block 1: Convolution + ReLU + Pooling
    keras.layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
    keras.layers.MaxPooling2D((2,2)),

    # Block 2: Deeper features
    keras.layers.Conv2D(64, (3,3), activation='relu'),
    keras.layers.MaxPooling2D((2,2)),

    # Classifier head
    keras.layers.Flatten(),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')  # 10 digit classes
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5, validation_split=0.1)

Optimisers — Smarter Ways to Descend

# PyTorch equivalent of our MNIST CNN
import torch
import torch.nn as nn

class MyCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 32, 3),   # 1 channel in, 32 filters, 3×3 kernel
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(32, 64, 3),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(64*5*5, 128),
            nn.ReLU(),
            nn.Linear(128, 10)
        )
    def forward(self, x):
        return self.classifier(self.features(x))

Load a Pretrained Model

Download ResNet50 with weights trained on ImageNet (1.4M images, 1,000 classes). The model already knows edges, textures, objects.

Freeze the Feature Extractor

Lock the convolutional layers so their weights don't change. We only train the final classification head on our specific task.

Fine-Tune (Optional)

After initial training, unfreeze the last few convolutional layers and train with a very low learning rate to adapt features to your domain.

from tensorflow.keras.applications import ResNet50
from tensorflow.keras import layers, Model

# Load ResNet with ImageNet weights, remove top classifier
base = ResNet50(weights='imagenet', include_top=False, input_shape=(224,224,3))
base.trainable = False  # Freeze all layers

# Add our custom head for binary classification
x = layers.GlobalAveragePooling2D()(base.output)
x = layers.Dense(256, activation='relu')(x)
output = layers.Dense(1, activation='sigmoid')(x)  # Cat vs Dog

model = Model(inputs=base.input, outputs=output)
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Simple Flask API for your CNN
from flask import Flask, request, jsonify
import numpy as np
from tensorflow import keras
from PIL import Image
import io

app = Flask(__name__)
model = keras.models.load_model('my_cnn.h5')
class_names = ['airplane', 'cat', 'dog', 'car', 'bird']

@app.route('/predict', methods=['POST'])
def predict():
    img = Image.open(io.BytesIO(request.data)).resize((224, 224))
    arr = np.array(img) / 255.0
    pred = model.predict(arr[np.newaxis, ...])
    return jsonify({'class': class_names[pred.argmax()],
                    'confidence': float(pred.max())})

if __name__ == '__main__':
    app.run(port=5000)