Visual walkthrough — Feature maps and receptive fields

This is a picture-first walkthrough of Feature maps and receptive fields. We start from one pixel and never use a symbol before it is drawn.

Step 1 — One pixel is its own receptive field

WHAT. Before any filter touches the image, ask: how much of the input influences a single input pixel? Only itself. So we define the receptive field $R_0=1$.

WHY. Every recursion needs a starting point (a "base case") — a known value we can build on top of. Growth formulas that don't state where they start are useless, so we pin down the smallest, most obvious case: a lone pixel sees a $1\times 1$ region.

PICTURE. In the figure the input row is a strip of squares. One square is highlighted in pale yellow; the bracket under it spans exactly one square — width $1$. That bracket is $R_0$.

Symbol check:

• $R_0$ — the subscript $0$ means "layer 0", i.e. the raw input. Its value is $1$ pixel.

Step 2 — One convolution layer: the filter sets the first width

WHAT. Slide a filter of width $k_1$ over the input. Each output value is computed from $k_1$ neighbouring input pixels. So the first-layer receptive field is $R_1=k_1.$

WHY. We use $k_1$ (the kernel size) and not anything else because the kernel size is literally how many input pixels the filter reaches across in one placement. Stride does not enter yet: stride tells you how far apart different outputs sit, but a single output's reach is fixed by the kernel width alone. (Full size bookkeeping for outputs lives in Padding and stride.)

PICTURE. A window of $k_1=3$ squares in chalk blue sits over the input; the arrow drops down to one output square. The bracket over the three input squares is $R_1=3$.

Symbol check:

• $k_1$ — width of the layer-1 filter, in input pixels. Here $3$.
• $R_1=k_1$ — for the first layer only, RF equals kernel size.

Reveal:

Step 3 — The stride "zoom factor": the jump register

WHAT. Define the cumulative stride after layer $l$ as $J_l={\prod }_{i=1}^l{s}_i=s_1\cdot s_2\cdots s_l,$ with $J_0=1$. It says: moving one step in this layer's grid = moving $J_l$ pixels in the input.

WHY. We need this because upcoming layers count neighbours in their own grid, but we insist on measuring RF in input pixels. $J_l$ is the exchange rate that converts "one step here" into "this many input pixels". We use a product (not a sum) because each stride multiplies the previous scaling — a stride 2 after a stride 2 means one deep step skips $2\times 2=4$ input pixels.

PICTURE. Two stacked grids: the top (input) has fine squares; the bottom (after stride 2) has coarse squares. One coarse square spans two fine squares — the pink bracket labels this gap $J_1=2$.

Symbol check:

• $s_i$ — the stride of layer $i$ (how many input-grid steps the filter jumps).
• $\prod$ — "multiply them all together".
• $J_l$ — the pixels-per-step exchange rate after $l$ layers.

Step 4 — Adding a second layer: neighbours cost stride-sized jumps

WHAT. A layer-2 filter of width $k_2$ reads $k_2$ layer-1 values. The centre one already sees $R_1$ input pixels. The other $k_2-1$ values sit further out, and each extra step out is $J_1$ input pixels away. So the new width is $R_2=R_1+(k_2-1)\cdot J_1.$

WHY. We split the $k_2$ neighbours into "the centre one" ($R_1$ already accounted for) plus "$k_2-1$ extra ones". Each extra neighbour is one layer-1 step away, and Step 3 told us one layer-1 step $=J_1$ input pixels. That is exactly why $J_1$ (the exchange rate) multiplies $(k_2-1)$ — we're converting extra layer-1 steps into input pixels.

PICTURE. Top strip = input. Middle strip = layer-1 outputs, each labelled with the $R_1=3$ block it covers. A layer-2 window of $k_2=3$ middle-cells is drawn; its outer two cells reach fresh input pixels. The total bracket over the input is $R_2$.

Term-by-term:

• $R_1$ — width the centre neighbour already covers.
• $(k_2-1)$ — the number of extra neighbours beyond the centre.
• $J_1$ — input pixels each extra neighbour reaches further out.

Step 5 — The general recursion (peel one layer at a time)

WHAT. Nothing about Step 4 was special to layer 2. Let $k_l$ be the ==kernel size at layer $l$== — the number of values that layer's filter reads across, measured in the grid of layer $l-1$. At any layer $l$, the extra $(k_l-1)$ neighbours each cost $J_{l-1}$ input pixels: $\boxed{R_l=R_{l-1}+(k_l-1)\cdot J_{l-1}},J_{l-1}={\prod }_{i=1}^{l-1}{s}_i.$

WHY. We reuse the Step-4 argument instead of re-deriving it because the geometry repeats identically at every layer — that is the whole point of a recursion: one rule, applied over and over. We use $J_{l-1}$ (strides before layer $l$) because layer $l$'s own stride affects later layers, not the reach of its own neurons.

PICTURE. A staircase: each step up is a layer; the horizontal bar (RF) gets wider each step, and next to each widening is the label $(k_l-1)\cdot J_{l-1}$ showing exactly how much was added.

Reveal:

Step 6 — Pooling is just another layer

WHAT. A pooling window of size $k_p$ and stride $s_p$ obeys the same two updates — the RF recursion and the jump update: $R_l=R_{l-1}+(k_p-1)\cdot J_{l-1},J_l=J_{l-1}\cdot s_p.$ Just plug $k_l=k_p$ and $s_l=s_p$ into the exact rules from Steps 3 and 5.

WHY. Pooling reads a $k_p\times k_p$ patch and jumps by $s_p$ — geometrically identical to a strided conv. The math cannot tell them apart, so neither should we. Forgetting to count pooling is the #1 receptive-field bug. Note the jump update $J_l=J_{l-1}\cdot s_p$ is written right next to the RF update so the pool's two effects — widen now, amplify later — stay visible together.

PICTURE. A $2\times 2$ pool (yellow) sits over two conv outputs; the RF widens by $(2-1)\cdot J=1$, then the pool's stride $2$ doubles $J$ for everything downstream.

Step 7 — Edge and degenerate cases

WHAT & WHY. A formula you trust only in the "nice" case is a trap. Check the corners by driving the boxed recursion $R_l=R_{l-1}+(k_l-1)J_{l-1}$ into each extreme:

• All strides $=1$ ($J_{j-1}\equiv 1$): the recursion becomes $R_l=1+{\sum }_{j=1}^l(k_j-1)$. For uniform $k$ this is $R_l=1+l(k-1)$ — linear growth. Small kernels stacked deeply grow RF slowly.
• All strides $=2$, uniform $k$: now $J_{j-1}=2^{j-1}$, so $R_l=1+(k-1){\sum }_{j=1}^l{2}^{j-1}=1+(k-1)(2^l-1),$ using the geometric sum ${\sum }_{j=1}^l{2}^{j-1}=2^l-1$. This is exponential growth — the reason real architectures downsample. (Check: $l=1$ gives $1+(k-1)(2-1)=k$ ✓.)
• $k=1$ (1×1 conv): contributes $(1-1)\cdot J=0$. RF does not grow — a $1\times 1$ conv mixes channels, never widens spatial reach.
• Dilation $d$: replace $k$ by an effective kernel $k_{\text{eff}}=k+(k-1)(d-1)$ — derived just below.

WHY $k_{\text{eff}}=k+(k-1)(d-1)$? A dilation $d$ inserts $d-1$ empty gaps between consecutive filter taps. Picture $k$ taps laid on the input: there are $k-1$ gaps between them. With no dilation ($d=1$) each gap is $1$ pixel wide, so the taps span $k$ pixels. With dilation $d$ each gap is stretched to $d$ pixels — so each of the $k-1$ gaps gains $(d-1)$ extra pixels. Total span: $k_{\text{eff}}=\underset{\text{taps at }d=1}{\underbrace{k}}+\underset{\text{number of gaps}}{\underbrace{(k-1)}}\cdot \underset{\text{extra pixels per gap}}{\underbrace{(d-1)}}.$ At $d=1$ this correctly gives $k_{\text{eff}}=k$ (no stretch). Feeding $k_{\text{eff}}$ into the same recursion:

• Layer 1, $d=1$: $k_{\text{eff}}=3\Rightarrow R_1=3$.
• Layer 2, $d=2$: $k_{\text{eff}}=5\Rightarrow R_2=3+(5-1)\cdot 1=7$.
• Layer 3, $d=4$: $k_{\text{eff}}=9\Rightarrow R_3=7+(9-1)\cdot 1=15$.

RF explodes $7\to 15$ with no extra parameters — the trick behind dense prediction in object detection and segmentation.

PICTURE. Two curves on the same axes: linear (stride 1) crawling up, exponential (stride 2) rocketing — both drawn from the boxed recursion.

The one-picture summary

The single figure stacks the whole chain: input pixel → conv widens by $k_1$ → each further layer adds $(k_l-1)J_{l-1}$ → pooling multiplies $J$ → RF fans out over the input. Read it left-to-right and you have re-derived the recursion.