CNN Fully Solved Numericals

The Full Pipeline — Every CNN Block in Order

Numerical 1 — Full Pipeline: Conv → ReLU → Max Pool

Given: A 5×5 input image and a 3×3 kernel. No padding. Stride 1 for both conv and pool (2×2 pool, stride 1).

① Step 1 — Convolution (9 dot products)

The 3×3 kernel slides across the 5×5 input with stride 1. Every position produces one value. Here are all 9:

② Step 2 — ReLU Activation: max(0, x)

Apply ReLU element-wise. Every negative value becomes 0. Every positive value stays unchanged.

③ Step 3 — Max Pooling: 2×2 window, Stride 1

Output size: O = ⌊(3 − 2)/1⌋ + 1 = 2 → 2×2 output. Slide the 2×2 window over the ReLU map:

Numerical 2 — Different Kernel, Stride 2 Pool

Given: A 4×4 input image and a 3×3 sharpening kernel. No padding. Stride 1 conv, then 2×2 MaxPool with stride 2 (non-overlapping).

① Step 1 — Convolution (4 dot products on the 4×4 input)

② Step 2 — ReLU Activation

③ Step 3 — Max Pooling: 2×2 window, Stride 2

Output size: O = ⌊(2 − 2)/2⌋ + 1 = 1 → single scalar output. Only one window — it covers the entire 2×2 ReLU map:

Side-by-Side Pipeline Summary

Python — Verify Both Pipelines

import numpy as np

# ── Convolution (cross-correlation, no flip) ──────────────────
def conv2d(x, k):
    """No padding, stride 1."""
    KH, KW = k.shape
    OH, OW = x.shape[0]-KH+1, x.shape[1]-KW+1
    out = np.zeros((OH, OW))
    for i in range(OH):
        for j in range(OW):
            out[i, j] = np.sum(x[i:i+KH, j:j+KW] * k)
    return out

# ── ReLU ──────────────────────────────────────────────────────
def relu(x):
    return np.maximum(0, x)

# ── Max Pool ──────────────────────────────────────────────────
def max_pool(x, pool=2, stride=2):
    OH = (x.shape[0] - pool) // stride + 1
    OW = (x.shape[1] - pool) // stride + 1
    out = np.zeros((OH, OW))
    for i in range(OH):
        for j in range(OW):
            out[i, j] = x[i*stride:i*stride+pool, j*stride:j*stride+pool].max()
    return out

# ═══════════════════════════════════════════════
# NUMERICAL 1 — 5×5 input, vertical edge kernel
# ═══════════════════════════════════════════════
inp1 = np.array([
    [1,2,3,0,1],
    [4,5,6,1,2],
    [7,8,9,0,3],
    [2,1,0,4,5],
    [6,3,2,1,0]
])
k1 = np.array([[1,0,-1],[1,0,-1],[1,0,-1]])

fm1 = conv2d(inp1, k1)
r1  = relu(fm1)
p1  = max_pool(r1, pool=2, stride=1)

print("N1 Feature Map:\n", fm1)
print("N1 After ReLU:\n",  r1)
print("N1 Max Pool output:\n", p1)

# ═══════════════════════════════════════════════
# NUMERICAL 2 — 4×4 input, sharpening kernel
# ═══════════════════════════════════════════════
inp2 = np.array([
    [2,4,1,3],
    [5,8,2,6],
    [1,3,7,4],
    [0,2,5,9]
])
k2 = np.array([[0,-1,0],[-1,5,-1],[0,-1,0]])

fm2 = conv2d(inp2, k2)
r2  = relu(fm2)
p2  = max_pool(r2, pool=2, stride=2)

print("N2 Feature Map:\n", fm2)
print("N2 After ReLU:\n",  r2)
print("N2 Max Pool output:\n", p2)

Golden Rules — The Three-Step Sequence