Feature maps and receptive fields: Question bank

This is a question bank for the ideas in the parent topic. Each line is a question ::: answer reveal. The goal is not arithmetic (that lives in D3/D4) — it is to catch the conceptual traps: what a feature map really is, why receptive fields grow the way they do, and the boundary cases that break naive intuition.

Prerequisites worth re-reading if a question stings: 3.4.01-Convolutional-layers, 3.4.02-Pooling-layers, 3.4.03-Padding-and-stride, 3.3.02-Activation-functions.

True or false — justify

A feature map and a filter are the same kind of object.

False. A filter is a small fixed grid of learned weights (the same numbers everywhere); a feature map is the large grid of activations those weights produced by sliding across the input — one is the stamp, the other is the ink it left everywhere.

One convolutional layer with 32 filters produces one feature map.

False. It produces 32 feature maps, one "opinion" per filter, stacked into a tensor of shape

(32, H_{out}, W_{out})

— each channel answers "where did my pattern fire?"

Increasing padding makes the receptive field of a deep neuron larger.

False. Padding changes the output size (border handling), not how many real input pixels feed a neuron; receptive field is driven by kernel sizes and strides, so padding leaves it unchanged.

For a stack of stride-1 layers, the receptive field grows exponentially with depth.

False. With

s = 1

every stride product is

1

, so

R_{l} = 1 + l (k - 1)

— that is linear growth. Exponential growth needs stride/pooling (

s > 1

) to multiply the expansion.

A pooling layer does not change the receptive field because it has no learnable weights.

False. Having no weights is irrelevant — a

2 \times 2

pool still spans 2 previous-layer pixels, so it both adds

(k_{p} - 1)

to the receptive field and multiplies later layers via its stride

s_{p}

A neuron in layer

L

looks directly at the input image pixels.

False. It only reads layer

L - 1

, which read

L - 2

, and so on — the receptive field is a recursive accumulation through every intermediate layer, not a direct view.

Two 3×3 convolutions stacked give the same receptive field as one 5×5 convolution.

True.

R_{2} = 3 + (3 - 1) \cdot 1 = 5

, matching a single

5 \times 5

— but the stacked pair uses fewer parameters and adds a nonlinearity in between, which is why deep nets prefer it.

Dilation makes a kernel physically bigger, so it costs more parameters.

False. Dilation only spaces out the same taps, so parameters stay fixed; the effective kernel size grows to

k + (k - 1) (d - 1)

while the weight count does not.

Every value in a feature map is guaranteed to be non-negative.

False in general. The raw convolution output can be negative; non-negativity only holds after a non-negative activation like ReLU is applied.

Spot the error

"Receptive field at layer

l

R_{l} = R_{l - 1} + (k_{l} - 1) \cdot s_{l}

Wrong stride. The multiplier is the cumulative stride of all earlier layers

\prod_{i = 1}^{l - 1} s_{i}

, not the current layer's own stride

s_{l}

— layer

l

's stride affects layers after it, not itself.

"The first conv layer with

k = 3, s = 2

has receptive field

R_{1} = k / s = 1.5

Wrong. For the very first layer

R_{1} = k = 3

regardless of stride; stride spaces out where outputs land, it does not shrink how many input pixels each output reads.

"Padding 'same' means the receptive field equals the input size."

Wrong. "Same" padding just keeps the output spatial size equal to the input; the receptive field can still be a tiny patch (e.g.

3 \times 3

) far smaller than the whole image.

R_{0} = 0

because the input hasn't been convolved yet."

Wrong base case.

R_{0} = 1

: an input pixel already "sees itself," so the recursion starts at 1, and starting at 0 undercounts every later layer by one.

"A 5×5 conv with stride 1 and padding 2 on a

32 \times 32

input gives a

28 \times 28

output."

Wrong.

⌊(32 + 4 - 5) /1 ⌋ + 1 = 32

— padding 2 exactly compensates the

5 \times 5

reach, so the size is preserved at

32 \times 32

, not shrunk.

"Global average pooling has a receptive field of one pixel because it outputs one number per channel."

Wrong. It averages the entire feature map, so its receptive field is the full spatial extent that feature map already accumulated — outputting one number does not mean it saw one pixel.

Why questions

Why does the size formula have "

+ 1

" at the end?

Because valid filter positions are fencepost-counted: placeable positions

0, 1, 2

are 3 outputs, not 2 — the

+ 1

converts a count of gaps into a count of positions.

Why do we take the floor

⌊ \cdot ⌋

in the output-size formula?

A filter can only sit at whole-pixel positions; if the stride does not divide the leftover space evenly, the last partial step is discarded rather than producing a fractional output row.

Why does stride multiply later receptive-field expansions instead of adding?

A stride-

s

layer means each of its output pixels is

s

input pixels apart, so every "extra" pixel a later kernel reaches corresponds to

s

input pixels — the effect compounds multiplicatively down the stack.

Why do deeper layers "understand context" that shallow layers cannot?

Their larger receptive field lets one neuron aggregate a wide input region, so it can encode "this edge belongs to a face" rather than just "there is an edge here."

Why are stacked small kernels preferred over one large kernel for the same receptive field?

They reach the same coverage with fewer weights and insert extra nonlinearities between them, giving more expressive power at lower cost.

Why do dilated convolutions help semantic segmentation specifically?

They enlarge the receptive field (global context) without downsampling, so spatial resolution is kept intact — essential when every output pixel needs a precise label.

Why must pooling layers be included when computing receptive fields?

Their window covers multiple previous-layer pixels (adding to

R

) and their stride downsamples (multiplying later expansions) — omitting them drastically undercounts the true receptive field.

Edge cases

What is the receptive field of a

1 \times 1

convolution?

Exactly 1 pixel of the current layer:

(k - 1) = 0

so it adds nothing to

R

— it mixes channels at a single spatial location, never widening the spatial view.

What happens to the output size when the kernel is larger than the padded input?

The numerator

H + 2 p - k

goes negative, the formula yields a non-positive value, and the layer is invalid — there is simply no place to fully seat the filter.

If stride

s = 1

and

k = 1

, what is the output size relative to input?

Identical:

⌊(H - 1) /1 ⌋ + 1 = H

— a

1 \times 1

stride-1 conv preserves spatial dimensions exactly.

Two feature maps in the same layer at the same spatial location: do they share a receptive field?

Yes. Receptive field is a purely geometric property of the architecture, so all channels at one position see the identical input patch; only their weights (and thus values) differ.

Can a neuron's receptive field extend beyond the actual image (into padding)?

Yes. Padded zeros lie inside the receptive-field window at the borders, so edge neurons "see" a region partly filled with padding rather than real pixels.

Does an activation function like ReLU change the receptive field?

No. Activations act pointwise (one input → one output at the same location), so they alter values but never the spatial region a neuron depends on.

If a

2 \times 2

stride-2 pool is applied to an odd-sized

7 \times 7

map, what size results?

⌊(7 - 2) /2 ⌋ + 1 = 3

, giving

3 \times 3

— the leftover final row/column that cannot fill a full window is simply dropped.

Recall One-line self-test

Name the two things a pooling layer contributes to the receptive-field recursion. ::: An additive term $(k_{p} - 1) \cdot \prod s_{i}$ from its window, and a multiplicative factor $s_{p}$ into the cumulative stride product for all later layers.

Related: 3.4.05-CNN-architectures, 4.2.01-Object-detection.