How do you calculate the receptive field of a CNN?

Walk the layers front to back with a recurrence. Start with receptive field r = 1 and jump j = 1 at the input. For each layer with effective kernel k_eff, update r_out = r_in + (k_eff − 1) · j_in, then j_out = j_in · stride. The final layer's r is the receptive field. This tool applies that recurrence and shows every intermediate value.

What is the receptive field of two stacked 3×3 convolutions?

5 × 5 pixels. The first 3×3 gives r = 3; the second adds (3 − 1) × jump = 2 more, giving r = 5. Three stacked 3×3 convs give 7×7. In general N stacked 3×3 stride-1 convs have a receptive field of 2N + 1, which is why VGG replaced large kernels with 3×3 stacks — same reach, fewer parameters.

Does stride increase the receptive field?

Stride does not enlarge the current layer's receptive field directly, but it multiplies the jump, so every layer after it grows the receptive field faster. A stride-2 layer doubles the jump, so a downstream 3×3 conv then adds 2 × jump instead of 2 × 1. That compounding is how deep networks reach receptive fields of hundreds of pixels.

How does dilation affect the receptive field?

Dilation inflates the effective kernel size to k_eff = d · (k − 1) + 1 without adding parameters. A 3×3 conv with dilation 2 has k_eff = 5, so it covers the same receptive field as a plain 5×5 conv while keeping 9 weights. Dilated convolutions are used in segmentation networks (DeepLab, WaveNet) to widen the receptive field cheaply.

Is a larger receptive field always better?

No. A neuron must see enough context to recognise an object, so the receptive field should cover the object scale in your images — this tool's coverage badge checks that. But the effective receptive field (Luo et al., 2016) is smaller than the theoretical one and Gaussian-weighted toward the center, and an oversized receptive field wastes compute and can blur fine detail. Match it to your task.

Does pooling count as a layer for receptive field?

Yes. A pooling layer uses the same recurrence as a convolution — kernel, stride and padding all matter, it simply has no learnable weights. Set the layer type to Pool and enter its kernel and stride. AlexNet's first max-pool, for example, raises the receptive field from 11 to 19 and the jump from 4 to 8.

Does this calculator handle strided or dilated layers and padding?

Yes. Each row takes kernel, stride, padding and dilation independently, and the per-layer table shows the effective kernel, jump, receptive field, feature-center offset and output size. Padding does not change the receptive field itself; it only shifts the feature center and changes the output feature-map size.

What are the limits and what isn't supported yet?

Version 1 assumes square kernels and strides (height = width) and a single linear stack, so it does not model non-square layers, transposed (deconv) layers, or residual/branching paths where a neuron has multiple paths to the input. Kernel up to 51, stride up to 16, padding up to 25, dilation up to 16, and up to 40 layers are supported.

Deep learning · CNN

CNN Receptive Field Calculator

Work out the exact receptive field of any convolutional network, layer by layer. Enter your conv and pool layers and read off the receptive field, jump (effective stride) and output size — the numbers you paste into model cards, papers and architecture notes.

By Induwara Ashinsana— Executive Director, Ryzera TechnologiesUpdated Jul 8, 2026

Receptive field of your layer stack

Presets

Input image size (px, square)

Enables output-size and "covers image?" checks. Leave blank to skip.

Layer stack (3/40)input → output, top to bottom

Type

Kernel k

Stride s

Pad p

Dilation d

Type

Kernel k

Stride s

Pad p

Dilation d

Type

Kernel k

Stride s

Pad p

Dilation d

Receptive field

7 × 7 px

Across 3 layers

Jump (effective stride)

1 px

Input pixels between adjacent output features

Final output size

224 × 224

From 224px input

Covers the image?

RF < input (224px) — a neuron can't see the whole object

Receptive-field growth

L1 Conv

L2 Conv

L3 Conv

Per-layer arithmetic

#	Layer	k_eff	jump	RF	center	output
1	Conv 3×3s1 p1	3	1	3	0.5	224
2	Conv 3×3s1 p1	3	1	5	0.5	224
3	Conv 3×3s1 p1	3	1	7	0.5	224

Recurrence from Araujo et al., Computing Receptive Fields of CNNs(Distill, 2019); dilated kernel and output size from Dumoulin & Visin (arXiv:1603.07285). v1 assumes square kernels/strides and a single linear stack (no residual branches). Sources cited in full below the tool.

How it works

The receptive field of a neuron is the region of the input image that can influence it. For a plain stack of convolution and pooling layers it is computed by a deterministic forward recurrence — the same one published by Araujo, Norris and Sim in the Distill (2019) reference, "Computing Receptive Fields of Convolutional Neural Networks." The recurrence starts at the input with jump j = 1, receptive field r = 1 and feature center start = 0.5.

For each layer with kernel k, stride s, padding p and dilation d:

Effective kernel(accounts for dilation, from Dumoulin & Visin, 2016): k_eff = d · (k − 1) + 1. A plain kernel has d = 1, so k_eff = k.
Jump out (feature stride, how many input pixels lie between adjacent output features): j_out = j_in · s.
Receptive field out — the key relation: r_out = r_in + (k_eff − 1) · j_in. Each layer widens the receptive field by (k_eff − 1) input pixels, scaled by the jump accumulated before it — which is why strides deep in the network compound.
Feature center (used for exact alignment): start_out = start_in + ((k_eff − 1) / 2 − p) · j_in. Padding shifts the center but never changes the receptive-field size.
Output size (standard convolution arithmetic, shown when you supply an input size n): n_out = floor((n + 2p − k_eff) / s) + 1.

Pooling layers use the identical recurrence — a pool is just a convolution with those k, s and p and no learnable weights — which is why both layer types share one formula. The reported receptive field is the final layer's r_out. To keep the result trustworthy, the calculator computes it two independent ways: the step-by-step recurrence above and the equivalent closed form r = 1 + Σ (k_eff − 1) · (product of earlier strides), and only shows the "closed-form verified" badge when both agree to the pixel.

Worked examples

Three stacked 3×3 convolutions

The classic VGG result — why 3×3 stacks replaced big kernels

Start: j = 1, r = 1
Conv 3×3 s1: k_eff = 3, j = 1·1 = 1, r = 1 + (3−1)·1 = 3
Conv 3×3 s1: j = 1, r = 3 + (3−1)·1 = 5
Conv 3×3 s1: j = 1, r = 5 + (3−1)·1 = 7
Result: receptive field = 7 × 7 px, jump = 1 (matches RF = 2N+1)

AlexNet conv1 + max-pool1

Cross-checked against the published AlexNet receptive-field table

Start: j = 1, r = 1
Conv 11×11 s4 p0: k_eff = 11, j = 1·4 = 4, r = 1 + (11−1)·1 = 11
MaxPool 3×3 s2 p0: k_eff = 3, j = 4·2 = 8, r = 11 + (3−1)·4 = 19
Result: receptive field = 19 × 19 px, jump = 8 (r: 11→19, j: 4→8)

One dilated 3×3 convolution (d = 2)

Dilation widens reach without extra weights

Start: j = 1, r = 1
Conv 3×3 s1 d2: k_eff = 2·(3−1)+1 = 5
r = 1 + (5−1)·1 = 5
Result: receptive field = 5 × 5 px — the reach of a plain 5×5, with only 9 weights

Frequently asked questions

Sources & references

The formulas on this page were last cross-checked against the Distill reference and the AlexNet worked table on 2026-07-08. Everything runs in your browser — no layer data leaves your device.

Related tools

LiveAI

CNN Output Size Calc

Compute the exact output size, tensor shape, parameter count and FLOPs of a Conv2d, pooling or transposed-conv layer from kernel, stride, padding and dilation. Chain layers in stack mode and copy a ready PyTorch/Keras snippet. Runs in your browser.

Open tool

LiveAI

Top-k Accuracy Calculator

Compute classification top-1 through top-k accuracy from a pasted table of ranked predictions or raw class scores. Reports the exact hit count, a full top-1…top-k ladder with marginal gains, and the samples missed at k. Mirrors scikit-learn's top_k_accuracy_score and runs entirely in your browser.

Open tool

LiveAI

Balanced Accuracy Calc

Compute balanced accuracy (the macro-average of per-class recall) from a binary confusion matrix or per-class results, contrasted against plain accuracy, with sensitivity, specificity and the adjusted chance-corrected score. Matches scikit-learn, runs entirely in your browser.

Open tool

Pairs with the CNN Output Size Calculator — size the tensor shapes, then confirm the receptive field covers your objects.

Rate this tool

Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.