Calculate Output Volume

easyFREEConvolutional Neural Networks (CNNs)Deep LearningDeep Learning 1

Problem Statement

Calculate the spatial dimensions of a convolutional layer output.

Background

The output size $O$ of a convolutional layer is determined by input size $I$ , filter size $F$ , padding $P$ , and stride $S$ using the formula:

$O = \lfloor \frac{I - F + 2P}{S} \rfloor + 1$

If the filter is larger than the padded input (i.e., $I - F + 2P < 0$ ), the configuration is invalid.

Your Task

Write a function conv_output_size(input_size, filter_size, padding, stride) that returns the output dimension. If the configuration is invalid (filter larger than padded input), return -1.

Output Format

Return an integer representing the output dimension, or -1 if invalid.

Example

Input

input_size=32, filter_size=3, padding=1, stride=1

Output

Reasoning

Inputs: a $32$ -pixel input ( $I = 32$ ), a $3$ -wide filter ( $F = 3$ ), $1$ pixel of zero padding per side ( $P = 1$ ), and stride $S = 1$ (the filter moves one pixel at a time).
Padded width: $32 + 2 \cdot 1 = 34$ pixels for the filter to sweep.
Room to slide: the filter covers $3$ of those, leaving $I - F + 2P = 32 - 3 + 2 = 31$ pixels of travel. Non-negative, so the configuration is valid.
Count positions: $\lfloor 31 / 1 \rfloor = 31$ steps, plus the starting position: $31 + 1 = 32$ .
Output: the integer 32, one value per filter position along this dimension.
Notice: $F = 3$ , $P = 1$ , $S = 1$ keeps the width unchanged ("same" padding). Stride $2$ would give $\lfloor 31/2 \rfloor + 1 = 16$ ; the floor discards the leftover pixel the filter can't fully cover.

Constraints

1 <= input_size <= 1000
1 <= filter_size <= input_size
0 <= padding <= 100
1 <= stride <= input_size

Learn this in

CNNs & Sequence ModelsML Study Plan

More from Deep Learning 1

Early Stopping Checkeasy L2 Regularization Penaltyeasy Inverted Dropout Forwardmedium Binary Cross-Entropy Losseasy Momentum Update Stepmedium

Concept primer

1. Background Knowledge

Convolutional layers are core components of Convolutional Neural Networks (CNNs), which process grid-like data (e.g., images) by sliding filters (kernels) over the input to extract features. Key parameters affecting output size:

Input size ( $I$ ): Spatial dimension of input feature map (e.g., height/width).
Filter size ( $F$ ): Dimension of the kernel (e.g., 3×3).
Padding ( $P$ ): Zero-padding added to input borders (expands effective input to $I + 2P$ ).
Stride ( $S$ ): Step size for sliding the filter.

The standard formula for 1D/2D output size $O$ (applied independently per dimension) is:

O = \left\lfloor \frac{I - F + 2P}{S} \right\rfloor + 1

This derives from counting valid filter positions: the filter needs $F$ input positions, padded input provides $I + 2P$ , and stride $S$ determines output steps. If $I - F + 2P < 0$ , no valid positions exist (invalid config).

Prerequisites: Basic CNN architecture (conv → activation → pool), integer division/flooring in programming, and understanding CNNs process spatial hierarchies.

2. Algorithm Approach

This is a direct formula evaluation problem—no search/training needed. Common techniques:

Exact computation: Plug values into the formula with floor division.
Validity check: Pre-validate $I + 2P \geq F$ (equivalent to $I - F + 2P \geq 0$ ) to return -1 early.
Vectorized extension (for multi-dim): Apply per axis (height/width) for 2D conv, but here it's 1D scalar.

No iterative algorithms (e.g., Winograd/FFT for fast conv ) apply—pure arithmetic.

3. Step-by-Step Strategy

Validate inputs (optional, per constraints): Ensure $1 \leq I,F,S \leq 1000$ , $0 \leq P \leq 100$ , $F \leq I$ .
Compute padded size: padded = I + 2 * P.
Check validity: If padded < F, return -1.
Calculate core expression: numerator = padded - F, then output = floor(numerator / S) + 1.
Return result: Integer output size.

Python Implementation:

def conv_output_size(input_size, filter_size, padding, stride):
 padded = input_size + 2 * padding
 if padded < filter_size:
 return -1
 numerator = padded - filter_size
 output = (numerator // stride) + 1 # Floor division via //
 return output

Verification (sample): $I=32, F=3, P=1, S=1$ → padded=34 ≥3, (34-3)/1=31, floor(31)+1=32 ✓.

4. Common Pitfalls

Off-by-one errors: Forgetting +1 or mishandling floor (use // in Python, not /).
Invalid config mischeck: Testing $I < F$ ignores padding—must use $I + 2P < F$ .
Floating-point division: numerator / S may yield float; always floor explicitly.
Negative numerator: Floor of negative (e.g., Python (-1)//2 = -1)—but validity check prevents.
2D confusion: Problem is 1D (scalar return); don't assume H/W pair.
Edge cases: $S=1, P=0, F=I$ → O=1; $P=0, F=I+1$ → -1; $S>I$ → often 1 or -1.

Test edges: conv_output_size(1,1,0,1) →1; conv_output_size(5,7,1,1) →-1.

5. Time & Space Complexity

Time: $O(1)$ —constant arithmetic operations, independent of input sizes.
Space: $O(1)$ —few scalar variables, no arrays/structures.

Optimal for real-time CNN design tools; scales to batched/3D conv by vectorization (still $O(1)$ per dim).

solution.py

Python 3.13

Test results