What a Convolution Actually Computes

Edit nine numbers and watch the feature map change. Weight sharing, stride, padding, ReLU, and pooling, with the parameter count next to the dense alternative.

Ch 14 14.5

Explorer

Deep Learning

18 mindifficulty 2/5

Controls

Input image

Kernel

Kernel weights (editable)

Weight sum 0 — zero-sum: a difference operator, blind to flat regions.

Stride1

Step between window positions — the cheapest way to downsample.

Max-pool window1

1 disables pooling.

Same padding

Zero-pad the border so the output keeps the input size.

ReLU after convolution

Clips negative responses to zero — this is what makes edge detectors directional.

Show cell values

Input

24×24 intensities in [0, 1].

Feature map

Raw convolution response.

Amber is a positive response, blue negative, background zero.

No pooling

Output 24×24.

Output shape

24×24

from 24×24

Response range

-3.80 … 3.80

signed response

Learnable parameters

9 weights plus a bias — independent of image size

Dense equivalent

331,776

a fully connected layer of the same output size

Why the same kernel everywhere

A convolution slides one small set of weights across every position, so a vertical edge is detected the same way in the corner as in the centre. That is translation equivariance, and it is why 10 parameters do the work of 331,776. The price is a built-in assumption: nearby pixels are related and absolute position does not matter. For tabular data that assumption is false, which is why convolution is not a general replacement for a dense layer.

Kernel arithmetic

weight sum0

response on a flat patch of 0.50

receptive field, this layer3×3

receptive field after 3 such layers7×7

stride / pooling reduction÷1

Any zero-sum kernel outputs exactly zero on a constant region: difference operators see change, not level. Stack layers to grow the receptive field — depth, not kernel size, is how convolutional networks see large structures.

Convolution is not just blurring

The operation is a learned local template match. A zero-sum kernel is blind to brightness and responds only to change; a positive-sum kernel passes brightness through. Which features a network detects is not a design decision made by hand — the nine numbers are learned by gradient descent, and the architecture only fixes their size, stride, and how many of them there are.

Predict before you look

You apply a 3×3 kernel whose nine weights sum to zero over a large region of constant brightness. What is the response there?

Scenarios

Teacher-ready starting points.

Documentation

What this shows

A 24×24 synthetic image, a fully editable 3×3 kernel, and the resulting feature map before and after ReLU and max pooling. Readouts give the output shape, the response range, and the parameter count next to the fully connected equivalent.

Cross-correlation, weight sharing, and shape arithmetic

What deep learning calls convolution is a cross-correlation: the output at position (r, c) is the sum over the 3×3 neighbourhood of input pixels times kernel weights, plus a bias. The same nine weights are applied at every position, so the layer has 10 parameters no matter how large the image is — the defining contrast with a dense layer, whose parameter count scales with input size times output size.

Because the weights do not depend on position, the layer is translation equivariant: shift the input and the feature map shifts by the same amount. Output shape follows arithmetic: with kernel size k, padding p, and stride s, the output is ⌊(n + 2p − k)/s⌋ + 1 per axis. 'Same' padding chooses p so the output matches the input; 'valid' padding takes none and loses the border.

The weight sum decides what the kernel is blind to. On a constant patch of value v the response is v·Σw, so any zero-sum kernel — Sobel, Laplacian — outputs zero on flat regions and responds only to spatial change. ReLU then clips negative responses, which turns a symmetric edge filter into a directional detector: one polarity of edge survives, the other does not.

Stacking layers, not enlarging kernels, is how the receptive field grows: L layers of 3×3 with stride 1 see a (2L + 1)-wide region with 9L weights, far fewer than a single kernel of that width. Stride and pooling shrink the map, which cheapens later layers and enlarges their receptive field in input pixels, at the cost of spatial precision.

y[r,c] = b + Σ_{i,j∈{−1,0,1}} w[i,j] · x[r+i, c+j]

out = ⌊(n + 2p − k)/s⌋ + 1

flat patch of value v  ⇒  y = v · Σw

params = k² · C_in · C_out + C_out   (independent of n)

receptive field after L layers of 3×3, stride 1 = 2L + 1

ReLU(y) = max(0, y)

Try this

Apply the identity kernel and confirm the feature map reproduces the input.
Run Sobel x on 'stripes', then on 'gradient'. Why is the response uniform on one and alternating on the other?
Turn ReLU on with Sobel x and explain which edges vanished.
Apply the box blur to 'noise' and then the Laplacian to the same image — contrast what each keeps.
Hand-edit the weights into a diagonal edge detector and test it on 'shapes'.
Set stride 2 and a 2×2 pool. Compute the expected output shape before reading the readout.
Switch same padding off and find the border rows the valid convolution discards.

Common misconception

“Convolutional layers work by smoothing the image, so they should always help.”

Smoothing is one kernel among infinitely many, and it is the one a network rarely learns. A convolution is a local template match whose nine weights are learned; zero-sum kernels ignore brightness entirely and respond only to change. The layer helps only when its built-in assumptions hold — that nearby inputs are related and absolute position does not matter. On tabular features, where column order is arbitrary, those assumptions are false and a dense layer is the right choice.

DSPA3 Chapter 14 — Deep learning and representation learning