Convolution and Feature Maps Playground

see which visual patterns survive each kernel choice

Starting values — Convolution and Feature Maps Playground

Input image	digit-like strokes
Kernel	sobel-x
Stride	1
Padding	same (keep size tendency)

Change any control above and the results recompute from these.

Loading interactive simulation...

Without padding, a deep network shrinks the image away 🖖

An unpadded 3×3 kernel at stride 1 costs you one pixel on every edge, so this tool's 28×28 input comes out 26×26. That sounds harmless until you stack layers: ten leave 8×8, and after fourteen there is nothing left. This is the whole reason "same" padding exists — adding a one-pixel border restores the output to the input size and lets a network be as deep as you like. Stride compounds it in the other direction, dividing rather than subtracting: blur at stride 2 turns 28×28 into 14×14 in one layer. The two settings on this tool are therefore not cosmetic: they decide how many layers your architecture can afford before it runs out of image.

A tiny window that slides 🖖

A convolution slides a small grid of numbers, the kernel, across the image. At each stop it multiplies the overlapping values and adds them into one output pixel. The result is a feature map that brightens wherever the kernel's pattern appears. Try the edge-detect kernel here: flat regions go dark while boundaries light up, because the kernel responds to change, not to brightness itself.

It isn't really convolution 🖖

The operation nearly every CNN calls "convolution" is actually cross-correlation. True mathematical convolution first flips the kernel top-to-bottom and left-to-right before sliding it; deep-learning libraries skip that flip. Since the network learns the weights anyway, a flipped kernel would simply be learned in reverse and give an identical result, which is why the misnomer stuck. With a symmetric kernel like blur, the two are indistinguishable.

Common wrong intuition

A deeper feature map is not always "better". High stride or harsh kernels can remove information your later layers needed.

Problem solved in full

Output map size for a 28×28 input map and 3×3 sobel-x kernel 6 steps
The layer: a 28×28 input map, a 3×3 sobel-x kernel, stride 1, padding same. Work out the size of the output map and what one pass costs in multiply-adds — then find how many such layers have to be stacked before a single output pixel depends on every pixel of the image.
1. Padding fixes the size, so settle it first. same lays a one-pixel border of zeros around the map, which is exactly enough for a 3×3 window to sit centred on a corner pixel instead of hanging off the edge. The border a kernel needs is half of it, not counting the centre.
  
  $P = \frac{K _{s} - 1}{2} = \frac{3 - 1}{2} = 1$
2. Slide the window along one row. Its left edge starts at 0 and advances by the stride until its right edge reaches the end of the padded row, so counting output pixels is a fencepost count: the number of advances, plus 1 for the starting position. At stride 1 the border gives back exactly the 2 columns the kernel takes away, which is what same is named for.
  
  $N_{o u t} = ⌊ \frac{N _{in} + 2 P - K _{s}}{S} ⌋ + 1 = ⌊ \frac{28 + 2 - 3}{1} ⌋ + 1 = 28$
3. Each of the 784 output pixels is one weighted sum of 9 input values. Add the sobel-x weights and they cancel to 0, so any window whose 9 inputs are all equal returns exactly 0 — however bright that region is. The map goes dark wherever the image is flat and responds only where the left column of the window differs from the right.
  
  $y = i, j \sum w_{ij} x_{ij}, i, j \sum w_{ij} = (- 1 + 0 + 1) + (- 2 + 0 + 2) + (- 1 + 0 + 1) = 0$
4. The arithmetic bill follows: 9 multiply-accumulates per output pixel, one output pixel per window position. The panel prints that count.
  
  $MACs = N_{o u t}^{2} \times K_{s}^{2} = 2 8^{2} \times 9 = 7056$
5. Depth is where it compounds. After one layer an output pixel sees 3 input pixels across. Add a second and each of those 3 was itself a window of 3 — but neighbouring windows overlap by 2, so the span reaches 5, not 9. Every further 3×3 stride-1 layer widens it by exactly 2.
  
  $r_{1} = 3, r_{L} = r_{L - 1} + 2 ⟹ r_{L} = 2 L + 1$
6. Set the span to cover all 28 columns and solve for the depth. 13 layers reach 27 and fall one column short; the 14th is the first whose output pixels can be influenced by the whole image.
  
  $2 L + 1 \geq 28 ⟹ L \geq 13.5 ⟹ L = 14, r_{14} = 29$
Answer

28×28 out, 7056 multiply-adds per layer, and 14 layers before one pixel sees the whole image. Now count what that reach costs. The 14 stacked layers spend 14 × 9 = 126 multiply-accumulates per output pixel. A single layer reaching just as far needs a 29×29 kernel, at 841 per output pixel — 6.7 times more arithmetic for exactly the same field of view. Depth buys reach far more cheaply than width does, which is why vision networks are long stacks of 3×3 kernels rather than short stacks of large ones.

$\frac{2 9 ^{2}}{14 \times 3 ^{2}} = \frac{841}{126} = 6.7$

References (1)

Insight block 3 — the operation called convolution is cross-correlation: I. Goodfellow, Y. Bengio and A. Courville, Deep Learning, ch. 9. MIT Press, 2016. ISBN 978-0-262-03561-3 — "many machine learning libraries implement cross-correlation but call it convolution".

By the 42Math team · Reviewed against published sources. Corrections welcome.