Conv2D Output Size

easyFREECNNsDeep LearningCV: Deep Learning

Implement a calculation for the output dimensions of a 2D convolution operation, a fundamental component in Convolutional Neural Networks (CNNs). This operation is crucial for image processing tasks, where understanding the output size is essential for subsequent layers.

In CNNs, the 2D convolution operation involves sliding a kernel over an input image, performing a dot product at each position to generate a feature map. The output size of this operation depends on several factors, including the input size $H_{in}$ and $W_{in}$ , the kernel size $K$ , the padding $P$ , and the stride $S$ .

To calculate the output dimensions, follow these steps:

Determine the input size $H_{in}$ and $W_{in}$ .
Specify the kernel size $K$ , padding $P$ , and stride $S$ .
Apply the formula to both height and width.

H_{out} = \lfloor\frac{H_{in} + 2P - K}{S}\rfloor + 1

This technique is widely used in image classification tasks.

Example

Input

conv_output_size(32, 32, 3, 1, 1)

Output

(32, 32)

Reasoning

Inputs: a $32 \times 32$ feature map ( $H_{in} = W_{in} = 32$ ), a $3 \times 3$ kernel ( $K = 3$ ), one ring of zero padding ( $P = 1$ ) and stride $S = 1$ .
Padding adds $P$ rows on top and on bottom, so the padded height is $32 + 2 \cdot 1 = 34$ .
A $3$ -tall kernel fits into $34 - 3 = 31$ shifts below its first position; with $S = 1$ every shift is used, giving $\lfloor 31 / 1 \rfloor + 1 = 32$ positions.
Width follows the same arithmetic with $W_{in}$ in place of $H_{in}$ , so $W_{out} = 32$ as well, giving (32, 32), height first.
Notice that $P = 1$ with $K = 3$ exactly cancels the $K - 1 = 2$ pixels the kernel would otherwise lose, so the size is preserved; without padding it would shrink to $30 \times 30$ .
The floor only matters when $S > 1$ and the shifts don't divide evenly: a leftover strip shorter than one stride adds no output.

Constraints

Return (H_out, W_out)

Learn this in

Vision EncodersVLM Study Plan

More from CV: Deep Learning

Implement Max Pooling with Indiceshard Depthwise Separable Convolutionmedium Softmax Cross-Entropy Gradientmedium Batch Normalization Forward Passhard Flatten Feature Mapeasy

Concept primer

Background Knowledge

Convolutional Neural Networks (CNNs) use 2D convolutions (Conv2D) to slide a small filter (kernel) over an input image (or feature map) to produce an output feature map. At each position, the kernel and the corresponding input patch are multiplied elementwise and summed, giving one output value. Repeating this over all valid positions builds the full output grid. The output’s height and width depend on how far the kernel can move over the input while still staying (possibly after padding) within bounds.

Three hyperparameters control this movement:

Kernel size $K$ : the spatial size of the filter (e.g., $3 \times 3$ ). Larger kernels “consume” more spatial extent per position, generally reducing output size.
Padding $P$ : how many pixels are added around the border of the input (typically with zeros). Padding lets the kernel be centered near edges, increasing the effective input size.
Stride $S$ : how many pixels the kernel shifts each step. Larger stride means fewer positions, thus smaller output.

The given formula for output height

H_{out} = \left\lfloor\frac{H_{in} + 2P - K}{S}\right\rfloor + 1

comes from counting how many stride steps fit between the first valid kernel placement and the last one. An analogous formula holds for width, replacing $H_{in}$ with $W_{in}$ .

Algorithm / Approach

The general approach to such problems:

Interpret the formula as:

Effective input size in that dimension: $H_{in} + 2P$ .
Remaining space after placing one kernel: $(H_{in} + 2P - K)$ .
Number of stride steps that fit in that remaining space: $\left\lfloor$ \frac{H_{in} + 2P - K}{S} $\right\rfloor$ .
Add 1 for the first position.

Apply the same pattern for width:

W_{out} = \left\lfloor\frac{W_{in} + 2P - K}{S}\right\rfloor + 1

Use integer math carefully, respecting the floor operation.

Step-by-Step Strategy

To compute Conv2D output size:

Identify input dimensions

$H_{in}$ : input height
$W_{in}$ : input width

Identify Conv2D parameters

Kernel size $K$ (assuming square for this problem; otherwise use $K_h$ and $K_w$ )
Padding $P$
Stride $S$

Compute effective sizes

$H_{$ \text{eff} $} = H_{in} + 2P$
$W_{$ \text{eff} $} = W_{in} + 2P$

Apply the formula for each dimension

$H_{out} = \left\lfloor \dfrac{H_{$ \text{eff} $} - K}{S} \right\rfloor + 1$
$W_{out} = \left\lfloor \dfrac{W_{$ \text{eff} $} - K}{S} \right\rfloor + 1$

Return the output shape

If the problem ignores channels: just $(H_{out}, W_{out})$ .
In practice with channels: $(C_{out}, H_{out}, W_{out})$ , with $C_{out}$ specified by the layer.

Example skeleton (Python-style):

def conv2d_output_size(H_in, W_in, K, P, S):
 H_out = (H_in + 2 * P - K) // S + 1
 W_out = (W_in + 2 * P - K) // S + 1
 return H_out, W_out

Common Pitfalls

Forgetting padding on both sides: Use $2P$ , not just $P$ .
Ignoring floor behavior: In code, make sure you use integer division // (or an explicit floor) if you’re working with integers.
Invalid configurations:
When $H_{in} + 2P < K$ , the kernel does not fit even once: the formula becomes invalid or gives non-positive output.
When $(H_{in} + 2P - K)$ is not divisible by $S$ , the floor means the last possible kernel position may not align perfectly with the far edge.
Mixing up parameters: Confusing stride with padding, or using width where height should be used.

Time & Space Complexity

If you are only computing the output size using the formula, the complexity is:

Time complexity: $O(1)$ — a constant number of arithmetic operations.
Space complexity: $O(1)$ — only a few scalar variables are needed.

(For context, actually performing the convolution has higher cost, but this problem only concerns calculating the output dimensions.)

solution.py

Python 3.13

Test results