Padding for Same Convolution

easyFREEConvolutional Neural Networks (CNNs)Deep LearningDeep Learning 1

Problem Statement

Determine the padding $P$ required to keep the output size equal to the input size (assuming stride S=1).

Background

To maintain spatial dimensions ( $O = I$ ) with stride 1, we solve:

$I = I - F + 2P + 1$

This gives us: $P = \frac{F - 1}{2}$

This is called "same" padding because the output has the same spatial dimensions as the input.

Your Task

Write a function calculate_same_padding(filter_size) returning the integer padding amount. Assume the filter size is always odd.

Output Format

Return an integer representing the padding needed for "same" convolution.

Example

Input

filter_size=5

Output

Reasoning

Input: filter_size is the side length $F$ of a square kernel, here $F = 5$ (a $5 \times 5$ patch), with stride $S = 1$ .
Why padding is needed: with no padding, a $5$ -wide window fits into an $I$ -wide image only $I - 5 + 1 = I - 4$ times, so the output shrinks by $4$ pixels per side length.
The math: setting the output size equal to the input, $I = I - F + 2P + 1$ , the $I$ cancels and leaves $2P = F - 1 = 4$ , so $P = 2$ .
Output: 2, meaning two rows/columns of padding on each side, so the $4$ lost pixels are restored exactly.
Notice that the padding depends only on $F$ , not on the image size. Because $F$ is odd, $F - 1$ is even and $P$ is always a whole number: $F = 3$ gives $1$ , $F = 7$ gives $3$ . An even $F$ would need uneven padding on the two sides.

Constraints

filter_size is always an odd number
1 <= filter_size <= 15

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

Convolution Operation: In CNNs, convolution slides a filter (kernel) of size $F \times F$ over input of size $I \times I$ , computing dot products at each position. Without padding, output size shrinks.

Output Size Formula (stride $S=1$ ): $O = I - F + 2P + 1$ where $P$ is padding added equally to both sides.

Same Padding: Set $O = I$ to preserve dimensions: $I = I - F + 2P + 1$ $\Rightarrow 2P = F - 1$ $\Rightarrow P = \frac{F-1}{2}$ Odd $F$ ensures $P$ is integer (e.g., $F=5 \Rightarrow P=2$ ).

Why Padding Matters: Zero-padding enables translation equivariance (features shift predictably) and maintains size through network layers.

2. Algorithm Approach

Direct Mathematical Computation: Use the derived formula $P = \frac{F-1}{2}$ . Since $F$ is guaranteed odd, no floating-point or rounding needed.

Integer Arithmetic: In Python, (F-1)//2 performs floor division, safe for odd positives.

No Search/Iteration Required: Purely algebraic—no loops, tables, or conditionals.

3. Step-by-Step Strategy

Input: Receive odd integer filter_size ( $F$ ).
Compute: $P = \frac{F-1}{2}$ .
Return: Integer $P$ .

def calculate_same_padding(filter_size):
 return (filter_size - 1) // 2

Verification:

$F=1$ : $P=0$ (no padding needed)
$F=3$ : $P=1$
$F=5$ : $P=2$
$F=15$ : $P=7$

4. Common Pitfalls

Using Float Division: return (F-1)/2 → 2.0 (not int).
Assuming Even $F$ : Code breaks (e.g., $F=4 \Rightarrow P=1.5$ ), but constraint prevents this.
Off-by-One: Wrong formula like $P = F//2$ fails ( $F=5 \Rightarrow 2$ correct, but $F=3 \Rightarrow 1$ correct vs $1$ wrong if $F//2=1$ ).
Negative/Zero Input: Constraints ( $1 \leq F \leq 15$ , odd) prevent, but production code might add validation.
Confusing Padding Types: "Same" assumes symmetric padding; asymmetric padding exists but not required here.

5. Time & Space Complexity

Time: $O(1)$ — single arithmetic operation.
Space: $O(1)$ — scalar input/output, no data structures.

Scalability: Independent of input size; formula generalizes beyond constraints to any odd $F$ .

solution.py

Python 3.13

Test results