Convolution, Padding, Stride & Pooling

The exact arithmetic behind every feature map a CNN ever produces — one sliding dot product, one output-size formula, and the padding, stride and pooling knobs that control it.

• Define the convolution operation as a sliding elementwise multiply-and-sum, and derive the output-size formula.
• Compute feature-map output sizes by hand for given kernel size, stride and padding, including cases that don't fit.
• Explain why zero padding is used, and why odd-sized kernels are preferred for "same" padding.
• Extend convolution to multi-channel inputs and count the parameters in a convolutional layer.
• Distinguish stride (which reduces resolution) from dilation (which enlarges receptive field without doing so).
• Perform max pooling and Sobel edge detection by hand on small worked examples.

1. The Convolution Operation

A convolutional layer works with a small learnable filter (or kernel) — typically 3×3 or 5×5 — that slides across the input. At every position, the filter and the underlying patch of the input are multiplied elementwise and summed into a single number: a dot product between the flattened filter and the flattened patch. The filter then moves by stride \(S\) pixels and repeats, producing one output value per position — together, these values form the output feature map.

Three worked examples, all with input \(H=W=7\):

2. Sliding the Filter: Interactive Walkthrough

To make the sliding mechanism concrete, here is a 3×3 Sobel \(G_x\) filter (introduced formally in Section 7) sliding over a small 5×5 image with a vertical edge — pixels 10 on the left, 80 on the right. With \(W=5, K=3, S=1\), the output-size formula gives \(W'=(5-3)/1+1=3\), so there are exactly 9 valid filter positions.

You can replay all 9 positions interactively below — useful for testing yourself before moving on:

Input (5×5)

G_x output (3×3)

3. Zero Padding

Every convolution without padding shrinks the feature map (the 7×7 → 5×5 example above). Stack enough layers like that and the feature map vanishes long before the network gets deep. Zero padding adds \(P\) rows/columns of zeros around the border of the input before convolving, which updates the output-size formula:

$$W' = \frac{W-K+2P}{S}+1$$

In general, to preserve spatial size exactly with stride 1, you need:

$$P = \frac{K-1}{2}$$

4. Multi-Channel Convolution

Real images aren't single 2D grids — an RGB image has \(D=3\) channels. A filter for a \(D\)-channel input must itself be \(D\)-channel (e.g. a 3×3×3 filter for an RGB image). The convolution multiplies-and-sums across all channels simultaneously at each spatial position — so, importantly, one filter always produces one 2D output map, regardless of how many input channels it read from.

Depth in the output comes from using multiple filters. Apply \(D_K\) independent filters to the same input, and you get a \(D_K\)-channel output — each filter contributing exactly one of those channels.

5. Stride & Dilation

Stride controls how far the filter jumps between positions. Stride 1 (the default) moves the filter one pixel at a time, producing a dense, high-resolution output. Stride 2 moves the filter two pixels at a time — this subsamples the image and roughly halves the output resolution in each dimension, directly reducing the amount of computation in every subsequent layer.

Dilation is a different knob entirely. With dilation factor \(l\), the filter samples every \(l\)-th pixel instead of a contiguous patch — the filter's weights don't change in count, but the pixels they touch spread out. A nominal 3×3 filter with dilation 2 skips every other pixel and so actually spans a 5×5 receptive field, while still only doing 9 multiply-adds.

Standard 3×3 (dilation 1)

Dilated 3×3, dilation 2 → spans 5×5

6. Pooling

Pooling spatially down-samples a feature map: fewer values means fewer parameters downstream, less computation, and reduced risk of overfitting. The most common choice is max pooling — typically a 2×2 window with stride 2 — which keeps only the largest value in each window. Pooling uses the same output-size formula as convolution (Section 1), almost always with no padding, and has no learnable parameters at all — it's a fixed, deterministic operation.

Replay the same four windows interactively below — useful for testing yourself before moving on:

Input (4×4)

Max-pooled output (2×2)

7. Sobel Edge Detection: Convolution in Action

Convolution isn't only for learned CNN filters — the classic, hand-designed Sobel operator is a concrete, motivating example of what a single well-chosen 3×3 filter can compute: image gradients, and from them, edges. Two fixed kernels estimate the gradient in the horizontal (\(x\)) and vertical (\(y\)) directions:

$$G_x=\begin{bmatrix}-1&0&1\\-2&0&2\\-1&0&1\end{bmatrix} \qquad G_y=\begin{bmatrix}-1&-2&-1\\0&0&0\\1&2&1\end{bmatrix}$$

Convolving a local neighborhood \(N\) with each kernel gives two numbers, \(S_x = N * G_x\) and \(S_y = N * G_y\), which combine into a gradient magnitude and direction:

$$|\nabla I|=\sqrt{S_x^2+S_y^2} \qquad \theta=\arctan2(S_y, S_x)$$

A large \(|\nabla I|\) means pixel intensity is changing sharply at that location — an edge. A small (near-zero) magnitude means the neighborhood is roughly flat.

Prefer to click through the same computation interactively, one row at a time? Same numbers, same order — useful for testing yourself before moving on:

8. Common Pitfalls

9. Summary

10. Code: Convolution Arithmetic, Pooling & Sobel

This NumPy script reproduces every worked number above: the output-size formula and its three K/S test cases, the "same"-padding check, the multi-channel shape/parameter formula, the exact 4×4 max-pooling example, and Sobel \(S_x, S_y\) on the worked neighborhood.

"""
Lecture 13 -- Convolution, Padding, Stride & Pooling
Reproduces: the output-size formula (with/without padding), the
multi-channel conv parameter-count formula, the exact 4x4 max-pooling
worked example, and Sobel Sx/Sy/|grad I| on the worked neighborhood.
"""
import numpy as np

# ---- 1. Output-size formula: W' = (W - K + 2P)/S + 1 ----
def output_size(W, K, S, P=0):
    num = W - K + 2 * P
    if num % S != 0:
        return None  # cannot scan the whole image
    return num // S + 1

for K, S in [(3, 1), (3, 2), (3, 3)]:
    out = output_size(7, K, S)
    print(f"W=7, K={K}, S={S}, P=0 -> {out if out else 'INVALID (does not fit)'}")
print(f"W=7, K=3, S=1, P=1 (same padding) -> {output_size(7, 3, 1, 1)}\n")

# ---- 2. Multi-channel convolution: output shape + parameter count ----
def conv_output(H, W, D_in, K, S, P, D_k):
    Hp, Wp = output_size(H, K, S, P), output_size(W, K, S, P)
    params = (K * K * D_in * D_k) + D_k
    return (Hp, Wp, D_k), params

shape, params = conv_output(28, 28, 3, K=3, S=1, P=1, D_k=15)
print(f"28x28x3 input, 3x3 filter, P=1, 15 filters -> {shape}, {params} params\n")

# ---- 3. Max pooling: exact 4x4 worked example ----
def max_pool(mat, size=2, stride=2):
    mat = np.array(mat)
    out_h = (mat.shape[0] - size)//stride + 1
    out_w = (mat.shape[1] - size)//stride + 1
    out = np.zeros((out_h, out_w))
    for r in range(out_h):
        for c in range(out_w):
            out[r, c] = mat[r*stride:r*stride+size, c*stride:c*stride+size].max()
    return out

X = [[1, 3, 2, 0], [4, 6, 1, 2], [0, 1, 3, 5], [2, 2, 2, 4]]
pooled = max_pool(X)
print("Max pooling 4x4 -> 2x2:\n", pooled)
assert np.array_equal(pooled, [[6, 2], [2, 5]]), "does not match worked example!"

# ---- 4. Sobel edge detection ----
def conv2d_valid(img, kernel):
    img, kernel = np.array(img, float), np.array(kernel, float)
    kh, kw = kernel.shape
    H, W = img.shape
    out = np.zeros((H - kh + 1, W - kw + 1))
    for r in range(out.shape[0]):
        for c in range(out.shape[1]):
            out[r, c] = np.sum(img[r:r+kh, c:c+kw] * kernel)
    return out

Gx = [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
Gy = [[-1, -2, -1], [0, 0, 0], [1, 2, 1]]
N = [[10, 10, 10], [10, 50, 80], [10, 50, 80]]

Sx = conv2d_valid(N, Gx)[0, 0]
Sy = conv2d_valid(N, Gy)[0, 0]
mag = np.sqrt(Sx**2 + Sy**2)
theta = np.degrees(np.arctan2(Sy, Sx))
print(f"\nSobel on N: Sx={Sx:.0f}, Sy={Sy:.0f}, |grad I|={mag:.2f}, theta={theta:.1f} deg")
print("(Course slide rounds |grad I| to ~258.8.)")

# Slide Gx across a 5x5 vertical-edge image (matches the interactive demo)
img5 = [[10, 10, 10, 80, 80]] * 5
print("\nSobel-Gx response over the 5x5 vertical-edge image (3x3 output):\n",
      conv2d_valid(img5, Gx))

⬇ Download lecture-13-convolution-pooling.py   More resources for this lecture →