Feature maps and receptive fields

Core Intuition

What Are Feature Maps?

Why this formula? Start with the padded input size $H + 2p$ . Subtract the filter "reach" $k$ to get the last valid position. Divide by stride $s$ to count how many steps fit. Add 1 because positions are fencepost-counted (if you can place the filter at positions 0, 1, 2, you have 3 outputs, not 2).

Formula Deriving Feature Map Size from First Principles

Initial size: Input is $H \times W$ , padding adds $p$ on all sides → $H_{\text{padded}} = H + 2p$ .
Valid positions: The top-left of a $k \times k$ filter can start at row $0$ and must end before row $H + 2p - k + 1$ (so the bottom-right of the filter lands at $H + 2p - 1$ ). Total positions: $H + 2p - k + 1$ .
Stride effect: We step by $s$ , so positions are $0, s, 2s, \ldots$ . The number of steps is $\lfloor (H + 2p - k)/s \rfloor + 1$ . Example: $H=32, k=5, s=1, p=2$ :

\left\lfloor \frac{32 + 2 \cdot 2 - 5}{1} \right\rfloor + 1 = \left\lfloor \frac{31}{1} \right\rfloor + 1 = 32

A $5 \times 5$ conv with padding 2 preserves spatial size.

If you have $C_{\text{out}}$ filters in a convolutional layer, you produce $C_{\text{out}}$ feature maps stacked as a 3D tensor of shape $(C_{\text{out}}, H_{\text{out}}, W_{\text{out}})$ . Each channel is the "opinion" of one filter.

What Is a Receptive Field?

Key insight: A neuron in layer $L$ doesn't "see" the input directly. It sees layer $L-1$ , which saw layer $L-2$ , etc. The receptive field accumulates this chain.

Formula Receptive Field Calculation (Sequential Convolutions)

For a stack of convolutional layers, the receptive field $R_l$ at layer $l$ is computed recursively:

R_l = R_{l-1} + (k_l - 1) \cdot \prod_{i=1}^{l-1} s_i

where:

$R_0 = 1$ (input pixel sees itself),
$k_l$ is the kernel size at layer $l$ (this includes pooling windows too!),
$s_i$ is the stride at layer $i$ .

Why? Each layer $l$ expands the receptive field by $(k_l - 1)$ pixels in the layer- $l-1$ space. But those pixels correspond to $\prod_{i=1}^{l-1} s_i$ pixels in the input space (the cumulative downsampling). Important: pooling layers also count—a $k_p \times k_p$ pool with stride $s_p$ expands the receptive field by $(k_p - 1) \cdot \prod_{i=1}^{l-1} s_i$ and contributes $s_p$ to the cumulative stride product.

Derivation from scratch:

Base case: At layer 0 (the input), $R_0 = 1$ (a pixel sees itself).
Layer 1: A $k_1 \times k_1$ filter with stride $s_1$ looks at $k_1$ consecutive pixels in the input. The center pixel's receptive field is $k_1$ wide. If stride $s_1 > 1$ , adjacent outputs skip $s_1$ input pixels, but the receptive field size is still $k_1$ for the first layer: $R_1 = k_1$ .
Layer 2: Each pixel in layer 1 has $R_1 = k_1$ . Layer 2's $k_2 \times k_2$ filter spans $k_2$ pixels in layer 1. Each of those layer-1 pixels covers $k_1$ input pixels, and layer-1 used stride $s_1$ . So the layer-2 receptive field is: $R_2 = R_1 + (k_2 - 1) \cdot s_1 = k_1 + (k_2 - 1) s_1$ The $(k_2 - 1)$ is the "extra" layer-1 pixels beyond the center, scaled by $s_1$ to input space.
General: At layer $l$ , the extra coverage is $(k_l - 1)$ in layer- $l-1$ space, which maps to $(k_l - 1) \prod_{i=1}^{l-1} s_i$ input space.

Simplification for uniform layers: If all layers have kernel $k$ and stride $s$ :

R_l = k + (k-1) \sum_{i=0}^{l-2} s^i = k + (k-1) \frac{s^{l-1} - 1}{s - 1}

For $s=1$ (no downsampling): $R_l = 1 + l(k-1)$ (linear growth). For $s=2$ : $R_l = k + (k-1)(2^{l-1} - 1)$ (exponential growth).

Figure — Feature maps and receptive fields

Worked Examples

Worked example Example 1: Calculating Feature Map Size

Setup: Input $64 \times 64 \times 3$ , apply a conv layer with 32 filters of size $3 \times 3$ , stride 1, padding 1. Step 1: Calculate output height/width.

H_{\text{out}} = \left\lfloor \frac{64 + 2 \cdot 1 - 3}{1} \right\rfloor + 1 = \left\lfloor \frac{63}{1} \right\rfloor + 1 = 64

Why this step? Padding 1 adds 2 total rows/cols, $3 \times 3$ filter "eats" 3 positions, stride 1 means no skipping.

Step 2: Determine output shape.

Spatial: $64 \times 64$ (preserved by padding).
Channels: 32 (one per filter).
Final feature map shape: $32 \times 64 \times 64$ .

Interpretation: We now have 32 "opinions" (feature maps), each a $64 \times 64$ grid showing where that filter activated.

Worked example Example 2: Receptive Field in a 3-Layer CNN

Architecture:

Conv1: $3 \times 3$ kernel, stride 1.
MaxPool: $2 \times 2$ window, stride 2.
Conv2: $3 \times 3$ kernel, stride 1. Layer-by-layer (remember: pooling counts as a "layer" with kernel size $k_p$ and stride $s_p$ ):

Conv1: $R_1 = 3$ (a $3 \times 3$ filter looks at 3×3 input pixels). Cumulative stride so far $= 1$ .
MaxPool ( $k_p = 2$ , $s_p = 2$ ): The pool does expand the receptive field because its $2 \times 2$ window covers 2 conv1 outputs.

R_2 = R_1 + (k_p - 1) \cdot s_1 = 3 + (2 - 1) \cdot 1 = 4

Cumulative stride now $= s_1 \cdot s_p = 1 \cdot 2 = 2$ .

Conv2 ( $k = 3$ , stride 1): The $3 \times 3$ filter spans 3 post-pool pixels. Each post-pool pixel corresponds to a cumulative stride of 2 in input space.

R_3 = R_2 + (k - 1) \cdot (s_1 \cdot s_p) = 4 + (3 - 1) \cdot 2 = 4 + 4 = 8

Interpretation: A neuron in Conv2 is influenced by an $8 \times 8$ patch of the original input. Note how the pooling window itself added 1 pixel of receptive field, and its stride then amplified Conv2's expansion. As we add more layers with pooling, this grows exponentially.

Worked example Example 3: Why Dilated Convolutions Help

Standard 3-layer stack ( $3 \times 3$ , stride 1, no pooling):

R_3 = 1 + 3 \cdot (3 - 1) = 1 + 6 = 7

Dilated 3-layer stack ( $3 \times 3$ , dilation rates 1, 2, 4). The effective kernel size for dilation $d$ is $k_{\text{eff}} = k + (k-1)(d-1)$ :

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

Why this step? Dilation $d$ spaces out filter taps, making effective kernel size $k + (k-1)(d-1)$ . At $d=1$ there is no spacing so $k_{\text{eff}} = k$ . This explodes receptive field growth (7 → 15) without adding parameters.

Use case: Semantic segmentation (need global context without losing resolution).

Common Mistakes

Common mistake Mistake 3: Ignoring Stride (and Pooling) in Receptive Field

Wrong idea: Calculating $R_l = k_1 + k_2 + \cdots + k_l - (l-1)$ for sequential convs, and treating pooling as only a stride with no kernel expansion. Why it feels right: You're adding up kernel sizes, which seems intuitive, and pooling "just downsamples." Steel-man: The additive formula works only if all strides are 1, and it's easy to forget that a pooling window also spans multiple pixels. The fix: Stride $s > 1$ makes each layer- $l$ pixel correspond to more previous-layer pixels; multiply the expansion $(k_l - 1)$ by the cumulative stride product $\prod_{i=1}^{l-1} s_i$ . Also, a $k_p \times k_p$ pool expands the receptive field by $(k_p - 1) \times (\text{cumulative previous strides})$ AND multiplies future expansions by its stride $s_p$ . Example: Conv1 (3×3, s1) → Pool (2×2, s2) → Conv2 (3×3, s1) gives $R = 8$ , not 7.

Feynman Explain-to-a-12-Year-Old

Recall Explain Feature Maps and Receptive Fields Like I'm 12

Imagine you have a huge poster of a beach scene. You're an art detective trying to find patterns—like "where are the umbrellas?" You can't look at the whole poster at once, so you use a magnifying glass that only shows a small square.

Feature map: You slide your magnifying glass across the poster row by row. Every time you see an umbrella-like shape, you put a checkmark on a separate piece of paper in the same position. When you're done, your paper is covered with checkmarks showing "umbrella locations." That paper is a feature map—it's the output of one "umbrella detector" filter.

Now imagine you have 100 different detectors (magnifying glasses with different colored lenses)—one for umbrellas, one for waves, one for people, etc. You get 100 different papers (feature maps), each showing where that pattern appears.

Receptive field: At first, your magnifying glass only shows a 3×3 square of the poster (tiny!). You can only detect tiny edges. Then you stack another detective on top of you: they look at your checkmark paper with their magnifying glass. Now they're combining your tiny detections into bigger patterns—maybe "this cluster of edge checkmarks forms a circle." Since they're looking at your paper (which summarized 3×3 patches), they're indirectly seeing 5×5 of the original poster. That 5×5 is their receptive field—how much of the original poster influences one of their decisions.

Add a third detective looking at the second's paper, and now they see 7×7 of the original poster. The higher up you go, the bigger the "field of view" back to the original scene. That's how CNNs understand context—low layers see pixels, high layers see objects.

Mnemonic

Connections

3.4.01-Convolutional-layers: Feature maps are the outputs of convolutional layers; receptive field depends on conv parameters.
3.4.02-Pooling-layers: Pooling increases receptive field via both its window size and its stride, but doesn't add learnable parameters.
3.4.03-Padding-and-stride: Padding preserves spatial size; stride controls downsampling and receptive field growth rate.
3.4.05-CNN-architectures: Deep architectures (ResNet, VGG) are designed to grow receptive fields efficiently while controlling parameters.
3.3.02-Activation-functions: Feature maps are passed through ReLU/etc. to introduce nonlinearity.
4.2.01-Object-detection: Large receptive fields are critical for detecting large objects in context.

Active Recall Flashcards

#flashcards/ai-ml

What is a feature map in a CNN?

The 2D output produced when a single convolutional filter slides across an input. It shows the spatial locations where the filter responds strongly. If you have

C_{\text{out}}

filters, you get

C_{\text{out}}

feature maps.

How do you calculate the spatial size of a feature map?

H_{\text{out}} = \lfloor (H + 2p - k)/s \rfloor + 1

, where

H

is input height,

p

is padding,

k

is kernel size,

s

is stride. Same formula for width.

What is the receptive field of a neuron in a CNN?

The region in the original input image that can influence that neuron's activation value. It grows with depth due to stacking convolutions.

How does stride affect receptive field growth?

Stride

s

multiplies the receptive field expansion. Formula:

R_l = R_{l-1} + (k_l - 1) \prod_{i=1}^{l-1} s_i

. Stride-2 pooling causes exponential growth; stride-1 causes linear growth.

Does a pooling layer affect the receptive field, and how?

Yes. A

k_p \times k_p

pool with stride

s_p

expands the receptive field by

(k_p - 1) \times

(cumulative previous strides), AND its stride

s_p

multiplies all future layers' expansions.

What is the receptive field of a single

3 \times 3

conv layer (stride 1)?

R_1 = 3

(the kernel size itself, since it looks directly at the input).

If you stack two

3 \times 3

convs (stride 1), what is the receptive field at layer 2?

R_2 = 3 + (3-1) \cdot 1 = 5

. Each layer-2 pixel sees a

5 \times 5

patch of the input.

Why do deeper CNNs have better context understanding?

Deeper layers have exponentially larger receptive fields (especially with pooling), so neurons "see" more of the input image—enabling recognition of large-scale patterns and spatial relationships.

What happens to feature map size with padding

p = (k-1)/2

and stride 1?

The output size equals the input size (spatial dimensions preserved). Example:

k=3, p=1

keeps

H_{\text{out}} = H

How does dilated convolution affect the effective kernel size and receptive field?

The effective kernel size is

k_{\text{eff}} = k + (k-1)(d-1)

for dilation

d

. At

d=1

this equals

k

; larger

d

inflates the receptive field without adding parameters. Example:

3 \times 3

with dilation 2 has effective size

5 \times 5

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Chalo ise simple tareeke se samajhte hain. Socho ek CNN ek building ki tarah hai jisme kai floors hain. Sabse pehla floor sirf chhote-chhote patches dekh sakta hai — jaise sirf edges ya lines detect karna. Aage ke floors in edges ko combine karke corners, textures, aur phir badi shapes jaise aankh ya wheel banate hain. Har layer thoda wider area dekhti hai aur higher-level concept mein sochti hai. Yaha do important cheezein hain: feature map yaani ek filter ki "opinion" — ek pura grid jo batata hai ki filter image mein kahan-kahan "fire" ho raha hai. Aur receptive field yaani original image ka kitna hissa ek single pixel ko influence kar raha hai.

Feature map ka size nikalne ke liye ek formula hai: input size $H+2p$ mein se filter reach $k$ subtract karo, phir stride $s$ se divide karo, aur last mein $+1$ karo (kyunki positions fencepost-style count hoti hain — agar 0,1,2 positions hain to 3 outputs hote hain, 2 nahi). Jaise agar $H=32, k=5, s=1, p=2$ ho to output bhi 32 aata hai, matlab padding 2 wala $5\times5$ conv spatial size ko preserve kar leta hai. Aur agar layer mein $C_{out}$ filters hain to utni hi feature maps banti hain, sab ek 3D tensor mein stack ho jaati hain — har channel ek alag filter ki opinion.

Receptive field ka concept isliye zaroori hai kyunki koi bhi deep neuron input ko directly nahi dekhta — woh apni pichhli layer ko dekhta hai, jo apni pichhli ko, aur ye chain recursively expand hoti jaati hai. Formula hai $R_l = R_{l-1} + (k_l - 1)\cdot \prod s_i$ , jisme pooling layers bhi count hoti hain. Iska matlab ye hai ki jaise-jaise hum deeper jaate hain, receptive field exponentially badhta hai, jisse neuron context samajh pata hai — jaise "ye edge ek face ka part hai, koi random line nahi". Yahi baat CNN ko itna powerful banati hai image samajhne mein, kyunki woh chhoti details se lekar badi meaning tak sab hierarchy mein capture kar leta hai.

Core Intuition

What Are Feature Maps?

What Is a Receptive Field?

Worked Examples

Common Mistakes

Feynman Explain-to-a-12-Year-Old

Mnemonic

Connections

Active Recall Flashcards

Concept Map

Hinglish (regional understanding)

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — Convolutional Neural Networks

Connections