How do you calculate the output size of a convolutional layer?

For each spatial dimension, PyTorch uses H_out = floor((H_in + 2·padding − dilation·(kernel − 1) − 1) / stride + 1). Plug in your input size, padding, kernel, dilation and stride, apply the same formula to width, and the channel dimension becomes the number of filters (C_out).

What is the formula for Conv2d output size in PyTorch?

H_out = floor((H_in + 2p − d·(k − 1) − 1) / s + 1), where p is padding, k is kernel size, d is dilation and s is stride. Width uses the identical formula with W_in. This calculator applies it exactly as written in the torch.nn.Conv2d documentation, including the dilation term.

How does stride and padding affect output size?

Padding adds pixels around the input, which increases the output. Stride is the step between windows: a stride of 2 roughly halves the output size. A stride-2, kernel-3, padding-1 layer maps a 112×112 map to 56×56. Larger kernels or dilation shrink the output unless padding compensates.

What does 'same' vs 'valid' padding mean for output size?

'valid' means no padding (padding = 0), so the output shrinks. 'same' pads so that, with stride 1, the output size equals the input; with stride s it gives ceil(H_in / s). Enter 'same' or 'valid' in the padding field and the tool resolves the Keras/TensorFlow behaviour, flagging when the pad split is asymmetric.

How do you calculate the output size of a transposed convolution (deconvolution)?

PyTorch ConvTranspose2d uses H_out = (H_in − 1)·stride − 2·padding + dilation·(kernel − 1) + output_padding + 1. A 7×7 input with kernel 4, stride 2, padding 1 upsamples to 14×14 — the standard 2× 'deconv' used in DCGAN-style decoders and U-Net expansive paths.

How many parameters does a convolution layer have?

With groups = 1, params = C_out · (C_in · kH · kW) + C_out, where the last term is the optional bias. A Conv2d(3, 64, kernel 7) has 64·(3·7·7) + 64 = 9,472 parameters (9,408 without bias). Pooling layers have zero learnable parameters.

What are MACs and FLOPs for a conv layer?

A MAC is one multiply-accumulate. For Conv2d, MACs = H_out · W_out · C_out · C_in · kH · kW per sample; FLOPs ≈ 2 × MACs (one multiply plus one add). The ResNet-50 stem conv works out to about 118M MACs (~236M FLOPs). Pooling does comparisons or averages, so it reports zero MACs.

Why does my layer show 'output size ≤ 0'?

The dilated kernel is larger than the padded input, so no valid window fits. Increase the input size or padding, or reduce the kernel size, dilation or stride. This is the same condition that raises a shape error in PyTorch — the tool flags it before you hit a RuntimeError in training.

Does this handle grouped, depthwise or 1D/3D convolutions?

Not in this version. v1 covers 2D layers with groups = 1 and a square kernel — the dominant search case. For depthwise-separable convs divide the param and MAC counts by the number of groups; the spatial-size formula is identical for 1D and 3D, just applied per extra dimension.

AI / Deep Learning

CNN Output Size Calculator — Conv, Pooling & Transposed Conv

Work out the exact output size of any Conv2d, pooling or ConvTranspose2d layer. Enter the input size, kernel, stride, padding and dilation to get H×W, the full (N, C, H, W) shape, parameters and FLOPs — plus a copy-ready PyTorch/Keras snippet. Uses the official PyTorch formulas, runs entirely in your browser.

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

CNN layer output size

PyTorch-verified

Layer type

Presets

Input height (H)

Input width (W)

Input channels

Output channels

Kernel size

Stride

Padding

number, "same" or "valid"

Dilation

Batch size (N)

Output size (H × W)

112 × 112

Tensor shape (N,C,H,W)

(1, 64, 112, 112)

Parameters

9.47K

9,472 (9,408 w/o bias)

Compute (MACs)

118.01M

≈ 236.03M FLOPs · per sample

Receptive field

7 px

Effective kernel: 7

Padding applied / side

H × W, per side

PyTorch

nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, dilation=1)

Keras / TensorFlow

layers.Conv2D(64, kernel_size=7, strides=2, padding="same", dilation_rate=1, use_bias=True)

Stack mode

No layers stacked yet. Configure a layer above and press Add layer to chain it. The chain starts from your input size (224×224×3).

Formulas from the official PyTorch Conv2d, ConvTranspose2d and MaxPool2ddocs, plus Dumoulin & Visin (arXiv:1603.07285). Sources cited in full below the tool. v1 assumes groups=1 and a square kernel.

How it works

Every convolution slides a kernel across the input and records one value per valid window position. The number of positions that fit is the output size. This tool implements the formulas exactly as published in the PyTorch layer documentation — nothing is estimated.

Convolution and pooling share one formula, applied independently to height and width:

H_out = floor( (H_in + 2·padding − dilation·(kernel − 1) − 1) / stride + 1 )

The dilation·(kernel − 1) term is the effective (dilated) kernel span. Pooling uses dilation 1 and keeps the channel count unchanged (C_out = C_in), while convolution sets C_out to the number of filters. With a pooling layer's ceil_mode on, the floor becomes a ceil; the calculator also applies PyTorch's rule that drops a trailing window which would start entirely inside the right-hand padding.

"same" and "valid" padding follow Keras/TensorFlow semantics. valid means no padding. same keeps the output equal to the input at stride 1 (padding = dilation·(kernel − 1) / 2) and gives ceil(H_in / stride) at larger strides. When the required total padding is odd, TensorFlow pads one side more than the other; the tool reports the correct output size and flags the asymmetry.

Transposed convolution (also called deconvolution or fractionally-strided convolution) reverses the spatial mapping and is used to upsample in GAN decoders and U-Net expansive paths:

H_out = (H_in − 1)·stride − 2·padding + dilation·(kernel − 1) + output_padding + 1

Parameters (groups = 1) are C_out·(C_in·kH·kW) + C_out, where the final term is the optional bias. Compute is reported as MACs (multiply-accumulates): for Conv2d, H_out·W_out·C_out·C_in·kH·kW per sample, with FLOPs ≈ 2 × MACs. Transposed conv is input-driven, so its MACs use H_in·W_in. The single-layer receptive fieldis dilation·(kernel − 1) + 1, and stack mode composes it across layers using the jump/receptive-field recurrence from Dumoulin & Visin.

Worked examples

ResNet-50 stem convolution

Conv2d(3 → 64, k=7, s=2, p=3) on a 224×224 image

Effective kernel: 1·(7−1) + 1 = 7
H_out = floor((224 + 2·3 − 7)/2 + 1) = floor(223/2 + 1) = 112
Shape: (1, 64, 112, 112)
Params: 64·(3·7·7) + 64 = 9,472 (9,408 without bias)
MACs: 112·112·64·147 = 118,013,952 ≈ 118.0M (~236M FLOPs)

ResNet max-pool after the stem

MaxPool2d(k=3, s=2, p=1) on the 112×112×64 feature map

Effective kernel: 3 (pooling uses dilation 1)
H_out = floor((112 + 2·1 − 3)/2 + 1) = floor(111/2 + 1) = 56
Shape: (1, 64, 56, 56) — channels unchanged
Params: 0 (pooling has no learnable weights)
This is the classic 56×56 map every ResNet paper opens with.

DCGAN decoder upsample (transposed conv)

ConvTranspose2d(256 → 128, k=4, s=2, p=1, output_padding=0) on 7×7

H_out = (7−1)·2 − 2·1 + 1·(4−1) + 0 + 1
= 12 − 2 + 3 + 1 = 14
Shape: (1, 128, 14, 14) — a 2× upsample
Params: 128·(256·4·4) + 128 = 524,416

Edge case — kernel larger than the input

Conv2d(k=7, s=1, p=0) on a 5×5 map

H_out = floor((5 + 0 − 7)/1 + 1) = floor(−2 + 1) = −1
Output ≤ 0, so no valid window fits.
The tool flags this instead of returning NaN.
Fix: add padding (p ≥ 1), shrink the kernel, or use a larger input.

Frequently asked questions

Sources & references

Formulas on this page were last cross-checked against the PyTorch documentation on 2026-07-04. The three worked-example output sizes (112, 56, 14) and the parameter/MAC figures reconcile exactly to the cited sources.

Related tools

LiveAI

Minkowski Distance Calc

Compute the Minkowski distance (the generalized Lₚ metric) between two numeric vectors of any dimension, for any order p ≥ 1, with the full per-dimension working. Shows the Manhattan (p=1), Euclidean (p=2), and Chebyshev (p→∞) special cases side by side, and matches scikit-learn and SciPy — entirely in your browser.

Open tool

LiveAI

Cross-Entropy Loss Calc

Compute cross-entropy (log) loss for binary and multi-class classification from labels and predicted probabilities or logits. Shows per-sample loss, the mean log-loss metric, perplexity and full step-by-step working — matches scikit-learn log_loss and PyTorch CrossEntropyLoss, entirely in the browser.

Open tool

LiveAI

Silhouette Score Calc

Compute the silhouette score (silhouette coefficient) of a clustering from raw data points and labels. Get the overall score, per-cluster means, and the full per-sample a(i)/b(i)/s(i) working — with misassigned points flagged. Matches scikit-learn silhouette_score, runs entirely in your browser.

Open tool

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.