Visual walkthrough — Stride, padding, and dilation

This is the flagship visual companion to Stride, padding, and dilation. If a symbol shows up, we draw it first.

---

Step 1 — A row of pixels is just a row of boxes

WHAT. Forget images for a moment. An input row is a line of numbered boxes. We will use a row of 7 boxes, labelled $0,1,2,3,4,5,6$.

WHY. Convolution in 2D is the same counting problem done twice (once for width, once for height). If we nail the 1D row, the 2D formula is free. So we shrink the problem until it is countable on our fingers.

PICTURE. Look at the row below. The number under each box is its position index — its address. The red bracket marks the whole width, which we call $W_{in}$ (the "in" means input). Here $W_{in}=7$.

---

Step 2 — The filter is a small window you slide

WHAT. A filter (or kernel) is a tiny window that covers $k$ boxes at once. We use $k=3$: a window three boxes wide.

WHY. A neural net does not look at the whole row at once; it looks through a small window and slides it along, reading a few boxes at every stop. We must count how many stops the window can make. That count is the output width. So the very first thing we need is the window's own width, $k$.

PICTURE. The red window below sits at the far left. Its left edge is at position $0$; because it is 3 wide, its right edge is at position $2$. The window occupies boxes $\{0,1,2\}$.

The $-1$ matters: a 3-wide window starting at $j$ ends at $j+2$, not $j+3$. Count on your fingers — box $j$, box $j+1$, box $j+2$: that is three boxes, last index $j+2=j+(k-1)$.

---

Step 3 — How far right can the window go? The "slack"

WHAT. Slide the window right one box at a time. The window may move only while it still fits — its right edge must not fall off the row. The last legal left-edge position is where the right edge just touches the last box.

WHY. Every stop the window makes produces one output number. So the number of stops is the output width. To count stops we first find the farthest legal stop, then count everything from box $0$ up to it.

PICTURE. The red window has slid to its rightmost legal spot. Its right edge sits on box $6$ (the last box), so its left edge sits on box $4$. The distance from the first left-edge (0) to the last left-edge (4) is the slack — the free room the window has to travel.

Right edge at last box $W_{in}-1$ means left edge at: $\underset{\text{last box index}}{\underbrace{(W_{in}-1)}}-\underset{\text{window’s own length}}{\underbrace{(k-1)}}=W_{in}-k.$

The slack is $4$: left-edge can sit at $0,1,2,3,4$ — five positions.

---

Step 4 — Stride: don't stop at every box

WHAT. Stride $s$ is how many boxes we jump between stops. Stride $s=1$ stops everywhere; stride $s=2$ stops at every other box.

WHY. Stopping at every box is expensive and often redundant. Jumping by $s$ throws away stops to sample the row faster — this is downsampling. We now need: how many stops fit inside the slack if each jump is $s$ long?

PICTURE. Below, $s=2$. The window starts at box $0$ (red), jumps to $2$, then to $4$. Positions $1$ and $3$ are skipped (greyed). Three stops survive: $\{0,2,4\}$.

Number of jumps that fit in the slack: $\lfloor \frac{\text{slack}}{s}\rfloor =\lfloor \frac{W_{in}-k}{s}\rfloor =\lfloor \frac{4}{2}\rfloor =2.$

Why divide by $s$? The slack is a distance; each jump eats $s$ boxes of it. Distance $÷$ jump-length $=$ number of jumps. Exactly like "40 metres, 2 metres per step → 20 steps".

---

Step 5 — The $+1$: count the starting spot too

WHAT. The count of jumps is not the count of stops. Add one for the very first stop, which took no jump to reach.

WHY. This is the single most common error (the parent note flags it). "How many stops?" and "how many jumps?" differ by exactly one: the launch position is a stop you get for free.

PICTURE. Two jumps drawn as red arcs connect three red stops. Arcs: $2$. Stops: $3$. The lone starting box has no incoming arc — it is the $+1$.

$W_{out}=\underset{\text{jumps}=2}{\underbrace{\lfloor \frac{W_{in}-k}{s}\rfloor }}+\underset{\text{launch stop}}{\underbrace{1}}=2+1=3.$

---

Step 6 — Padding: glue on a margin first

WHAT. Padding $p$ adds $p$ extra boxes (usually zeros) on each side, before any sliding. Total added: $2p$.

WHY. Without padding, corner boxes are touched by the window only once, while middle boxes are touched many times — edges are under-represented, and the row shrinks every layer. Padding gives edges more visits and lets us control the output size.

PICTURE. The original 7 red boxes now have one white pad box on the left and one on the right. Effective width is $7+2(1)=9$. Everywhere $W_{in}$ appeared, it becomes $W_{in}+2p$.

$W_{out}=\lfloor \frac{(W_{in}+2p)-k}{s}\rfloor +1.$

• $(W_{in}+2p)$ — padded width, the new box count
• $-k$ — window still eats $k$ boxes → slack
• $÷s$ — jumps that fit
• $+1$ — launch stop

Same-padding check. To keep the output equal to the input ($s=1$), set $W_{out}=W_{in}$: $W_{in}=W_{in}+2p-k+1\Rightarrow 2p=k-1\Rightarrow p=\frac{k-1}{2}.$ For $k=3$: $p=1$. Odd $k$ gives a whole-number $p$; even $k$ would force an uneven left/right pad.

---

Step 7 — Dilation: spread the window's teeth apart

WHAT. Dilation $d$ inserts $(d-1)$ empty gaps between neighbouring window slots. The window keeps only $k$ real slots, but its effective span stretches.

WHY. We want the window to see wider — capture far-apart context — without paying for more weights or stacking more layers. Dilation stretches the reach while the parameter count stays at $k$.

PICTURE. A $k=3$ window with $d=2$: real slots (red) sit on boxes $0,2,4$, and the box between each pair (position $1$ and $3$) is a hollow gap. The window's span is now $5$ boxes even though it holds only $3$ weights.

Count the span: $k$ real slots, plus $(k-1)$ gaps between them, each gap $(d-1)$ boxes wide: $k_{eff}=\underset{\text{real slots}}{\underbrace{k}}+\underset{\text{number of gaps}}{\underbrace{(k-1)}}\underset{\text{boxes per gap}}{\underbrace{(d-1)}}.$ For $k=3,d=2$: $k_{eff}=3+(2)(1)=5$.

---

Step 8 — Snap the pieces together

WHAT. Take the Step 6 formula and swap the plain $k$ for the span $k_{eff}$. That single swap absorbs dilation.

WHY. Padding changed the box count; stride changed the jump length; dilation changed the window span. Each edited exactly one symbol, so the master formula is just the counting story with three edits applied.

PICTURE. The full assembly line: padded row → stretched window slides by stride → count stops. Every symbol is labelled where it acts.

Full worked case ($W_{in}=32,k=3,s=2,p=1,d=2$): $k_{eff}=3+(2)(1)=5,\frac{32+2-5}{2}=\frac{29}{2},\lfloor 14.5\rfloor +1=15.$

---

Step 9 — The edge cases (never leave a hole)

WHAT. Four scenarios that break naive counting.

WHY. A formula you cannot trust at the corners is a formula you cannot trust. We poke each degenerate input.

PICTURE. Four mini-panels: window bigger than row (no fit), exact fit (one stop), stride overshoots slack (floor rescues), $d=1$ collapse.

• Window too big ($k_{eff}>W_{in}+2p$): numerator negative, $\lfloor \text{neg}\rfloor +1\le 0$. Zero (or fewer) valid stops — the window cannot fit even once. Legal answer: no output; add padding.
• Exact fit ($k_{eff}=W_{in}+2p$): numerator $0$, $\lfloor 0/s\rfloor +1=1$. The window fits in precisely one spot — one output box.
• Stride overshoots slack (e.g. slack $=4$, $s=3$): $\lfloor 4/3\rfloor =1$, so $W_{out}=2$. The floor discards the illegal third stop that would hang off the edge — this is why we floor, not round.
• $d=1$ (no dilation): $k_{eff}=k+(k-1)(0)=k$. The general law collapses to the plain-stride formula from Step 5 — consistency check passed.

---

The one-picture summary

This last figure is the whole derivation compressed: a padded row, a dilated window at its stretched span $k_{eff}$, red jump-arcs of length $s$ marching across the slack, and the surviving stops counted — jumps plus one.

Recall Feynman retelling — say it back in plain words

Imagine a strip of numbered boxes. First you tape a margin of $p$ boxes onto each end, so the strip is now $W_{in}+2p$ long. You have a little window that grips $k$ boxes — but you spread its fingers apart with dilation $d$, so its whole hand now spans $k_{eff}=k+(k-1)(d-1)$ boxes. You lay the window at the far left and slide it rightward, but you don't stop at every box: you leap $s$ boxes each time. You keep leaping only while the window still fits on the strip; the room it has to travel is the slack $=(W_{in}+2p)-k_{eff}$. Count the leaps that fit: $\lfloor \text{slack}/s\rfloor$. Then add one, because the spot you launched from was itself a stop. That final count is $W_{out}$ — the number of output boxes. Do this once for width, once for height, and you have every convolution output size there is.

Recall Quick self-test

Why is there a $+1$? ::: The launch position is a stop you reach with zero jumps; jumps count arcs, stops count boxes, and boxes exceed arcs by one (fence-post rule). What does the floor $\lfloor \cdot \rfloor$ protect against? ::: A partial jump that would push the window off the edge — an illegal stop — so we drop the fraction. With $d=1$, what is $k_{eff}$? ::: $k_{eff}=k$; the general formula collapses to plain convolution. Why swap $k$ for $k_{eff}$ but nothing else, when adding dilation? ::: Dilation only changes how wide the window spans; the fitting-and-counting logic is untouched.

See also: Receptive Field Analysis (why $k_{eff}$ grows the field), Pooling Layers (stride's downsampling cousin), Semantic Segmentation Architectures (where dilation shines), Network Depth vs Width, and Convolutional Layer Basics.