Worked examples — Convolution operation and filters

This page is the "flight simulator" for the convolution operation. The parent note gave you the formula; here we fly it through every kind of situation you can meet — every sign, every degenerate size, every edge case — one fully worked example per situation, so you never hit a scenario you have not seen.

Before we start, one reminder in plain words. Convolution here means: lay a small grid of numbers (the filter, a $k\times k$ box of weights) on top of a patch of the picture, multiply each filter number by the picture number underneath it, and add all those products into a single number. Slide the box one step and repeat. Every symbol below is earned from that one sentence.

---

The scenario matrix

Every convolution problem is really one of these case classes. Each row is a "cell" you must be able to handle; the last column names the example that covers it.

#	Case class	What makes it tricky	Covered by
A	Positive output (bright-on-right edge)	sign of the sum is +	Ex 1
B	Negative output (bright-on-left edge)	sign of the sum is −	Ex 2
C	Zero output (flat region / no pattern)	perfect cancellation → 0	Ex 3
D	Padding changes the answer	zeros bleed in at the border	Ex 4
E	Stride $>1$ (which positions survive?)	output positions are skipped	Ex 5
F	Degenerate filter: $1\times 1$	no spatial mixing at all	Ex 6
G	Multi-channel (RGB) sum-across-depth	three products stacked into one	Ex 7
H	Limiting size: filter = whole image	output collapses to $1\times 1$	Ex 8
I	Word problem (real image, real filter)	translate English → numbers	Ex 9
J	Exam twist: solve for an unknown stride/padding	run the size formula backwards	Ex 10

Two formulas we will reuse constantly — from the parent note, restated in words:

We use the same $5\times 5$ input throughout so you can compare cases. Here it is, with rows $i$ down and columns $j$ across:

$$I=\left[\begin{array}{ccccc}1& 2& 3& 0& 1\\ 0& 1& 2& 3& 0\\ 2& 0& 1& 2& 1\\ 1& 1& 0& 1& 2\\ 0& 2& 1& 0& 1\end{array}\right]$$

Look at the figure: the red $3\times 3$ box is the filter's footprint. As we move it, the nine numbers under it change — that is the only thing that changes between Examples 1–3.

---

Example 1 — Cell A: a positive output (right side brighter)

Forecast: the filter's right column is $+1$ and left column is $-1$. It fires positive when the right side of the patch is brighter than the left. Guess the sign before reading on.

1. List the patch under the filter. Why this step? The formula only ever multiplies the filter by the numbers directly beneath it, so we must read them off first. Rows 0–2, columns 0–2: $\left[\begin{array}{ccc}1& 2& 3\\ 0& 1& 2\\ 2& 0& 1\end{array}\right]$
2. Multiply element-by-element with $K$. Why? That is the "picture value $\times$ filter value" inside the sum. The middle column is killed by $0$, so only the outer columns matter: $\underset{\text{row }0}{\underbrace{(1)(-1)+(3)(1)}}+\underset{\text{row }1}{\underbrace{(0)(-1)+(2)(1)}}+\underset{\text{row }2}{\underbrace{(2)(-1)+(1)(1)}}$
3. Add. Why? The single $\sum$ collapses nine products into one number: $(-1+3)+(0+2)+(-2+1)=2+2-1=3$

Verify: each row contributes (right − left): $3-1=2$, $2-0=2$, $1-2=-1$; total $3$. Positive, as forecast — the right column of the patch ($3,2,1$) does outweigh the left ($1,0,2$). ✓

---

Example 2 — Cell B: a negative output (left side brighter)

Forecast: now the patch's left column is the bright $3,2,1$ strip. A left-bright patch through a right-positive filter should give a negative number.

1. Read the patch at rows 0–2, columns 2–4. Why? New position ⇒ new nine numbers: $\left[\begin{array}{ccc}3& 0& 1\\ 2& 3& 0\\ 1& 2& 1\end{array}\right]$
2. Apply (right − left) per row (middle column is $0$). Why? Same reasoning as Ex 1, just faster: $(1-3)+(0-2)+(1-1)=-2-2+0=-4$

Verify: the sign is negative, matching the forecast. The magnitude $4$ is larger than Example 1's $3$ because the brightness drop from left to right is steeper here. ✓ (This is the $(0,2)$ entry of the full feature map.)

---

Example 3 — Cell C: a zero output (no edge, perfect cancellation)

Forecast: a flat region has no edge, so an edge detector should report exactly 0.

1. Sum the filter weights first. Why this step? When every picture value equals a constant $c$, the output is $c\times (\text{sum of all filter weights})$ — the constant factors out. Sum of $K$: each row is $-1+0+1=0$, so total $=0$.
2. Multiply out. Why? Confirms the shortcut: $5\times 0=0$.

Verify: directly, $5(-1)+5(1)$ per row $=0$, three rows $=0$. A zero-sum filter is blind to flat brightness — it only sees change. That is why edge detectors have weights summing to zero. ✓

---

Example 4 — Cell D: padding changes the border answer

Forecast: padding surrounds the top-left corner with zeros, so the filter now sees mostly $0$s. The corner answer should shrink toward a small number, not $3$.

1. Build the padded patch. Why? With $p=1$ the filter's top-left position sits over the zero ring; only the bottom-right $2\times 2$ of the filter overlaps real pixels. In the figure the gray ring is the padding, the red box is the filter: $\left[\begin{array}{ccc}0& 0& 0\\ 0& 1& 2\\ 0& 0& 1\end{array}\right](\text{bold = real image})$
2. Multiply with $K$. Why? Same formula; the zeros simply drop out: $0+0+0+0(-0?)\dots =(1)(0)+(2)(1)+(0)(0)+(1)(1)=2+1=3$ Wait — recompute carefully with $K$'s middle-column-zero: row 1 gives $0\cdot (-1)+1\cdot 0+2\cdot 1=2$; row 2 gives $0\cdot (-1)+0\cdot 0+1\cdot 1=1$. Sum $=3$.

Verify: the padded corner value is $3$ — coincidentally equal here, but now it is a border pixel of a larger $5\times 5$ output (padding preserves size). Compare Ex 1's $3$ which was an interior value of a $3\times 3$ output. Same number, different role. The key lesson: the zero ring participates in the sum, so border outputs are systematically dimmer wherever the filter would have seen bright pixels. ✓ See receptive fields for how this ring grows over layers.

---

Example 5 — Cell E: stride $>1$, which positions survive?

Forecast: stride 2 keeps every other starting column and row. From starts $0,1,2$ we drop the odd ones, keeping $0$ and $2$ → a $2\times 2$ output.

1. Run the size formula. Why? It tells us how many positions fit before we compute any values: $H_{out}=\lfloor \frac{5+2(0)-3}{2}\rfloor +1=\lfloor \frac{2}{2}\rfloor +1=1+1=2$ So output is $2\times 2$.
2. List the top-left corners of each filter placement. Why? Stride $s=2$ means the corner index jumps by 2: $(0,0),(0,2),(2,0),(2,2)$. The corners $(0,4),(4,\cdot )$ would push the filter off the edge, so the floor correctly excluded them.

Verify: four positions ⇒ $2\times 2$, matching the formula. Contrast with stride 1 which gave $3\times 3=9$ positions (Ex 1's full map). Stride 2 roughly quarters the output — the downsampling the parent note promised. ✓

---

Example 6 — Cell F: the degenerate $1\times 1$ filter

Forecast: a $1\times 1$ filter cannot mix neighbours — it just rescales every pixel. Output should be $I$ times $2$, same shape.

1. Check the output size. Why? To confirm nothing shrinks: $H_{out}=\lfloor \frac{5+0-1}{1}\rfloor +1=4+1=5$ Output is $5\times 5$, identical shape.
2. Apply the formula. Why? With $k=1$ the double sum has just one term: $(I\ast K)[i,j]=I[i,j]\cdot 2$. So $(0,0)\mapsto 1\cdot 2=2$, $(0,1)\mapsto 2\cdot 2=4$, etc.

Verify: every value doubles, no spatial change. This is why $1\times 1$ convolutions are used only to mix channels (see depthwise-separable convolutions), never spatial patterns. $I[0,0]=1\Rightarrow$ output $2$. ✓

---

Example 7 — Cell G: multi-channel (RGB) — summing across depth

Forecast: for multi-channel input we multiply per channel then add the three channels together into one number: expect $4-1+6=9$.

1. Multiply each channel. Why this step? The 3D formula ${\sum }_c{\sum }_m{\sum }_n$ has an extra sum over channels $c$; each channel is a separate multiply: $4\cdot 1=4,1\cdot (-1)=-1,2\cdot 3=6$
2. Sum across channels. Why? The output of one filter is a single number per location — depth collapses: $4+(-1)+6=9$

Verify: $9$, as forecast. Note the output has depth 1 even though input had depth 3 — one filter always produces one feature map. Stack 64 filters ⇒ output depth 64, exactly the parent note's rule. ✓

---

Example 8 — Cell H: limiting case, filter = whole image

Forecast: the filter fits in exactly one position — the output must be a single number ($1\times 1$).

1. Size formula. Why? To see the collapse: $H_{out}=\lfloor \frac{5+0-5}{1}\rfloor +1=\lfloor 0\rfloor +1=1$ Output $1\times 1$.
2. Interpret the single value. Why? With $k=H=W$, the sum runs over all 25 pixels — it is a global weighted sum of the whole image. If $K$ were all-ones, this would be the total pixel sum. For $I$ above, all-ones filter gives $\sum I$.

Verify: total of $I$: rows sum to $7,6,6,5,4$, grand total $28$. So an all-ones $5\times 5$ filter outputs the single value $28$. This is the limiting behaviour: as $k\to$ image size, convolution degenerates into one global feature — which is what a global pooling layer approximates (pooling layers). ✓

---

Example 9 — Cell I: the word problem

Forecast: "same" size for a $3\times 3$ filter needs one ring of padding, $p=1$; output stays $6\times 6$; cost = (positions) $\times$ (filter cells).

1. Solve for padding. Why? "Same" means $H_{out}=H$. Set the formula equal to $6$: $6=\frac{6+2p-3}{1}+1\Rightarrow 5=3+2p\Rightarrow p=1.$
2. Output shape. Why? Plug $p=1$ back: $H_{out}=\lfloor (6+2-3)/1\rfloor +1=6$. Output $6\times 6$.
3. Count operations. Why? Each of the $6\times 6=36$ output pixels needs one multiply-add per filter cell, and the filter has $3\times 3=9$ cells: $36\times 9=324\text{ multiply-adds.}$

Verify: $p=1$ is exactly $(k-1)/2=(3-1)/2=1$ from the parent's padding rule ✓. $36\times 9=324$ ✓. Contrast a fully-connected layer on 36 pixels → $36^2=1296$ weights: convolution is far cheaper, the parameter-sharing win from the parent note.

---

Example 10 — Cell J: the exam twist (solve backwards for stride)

Forecast: big input → small output means we skipped positions, so $s>1$. Guess $s=2$.

1. Write the size formula and isolate $s$. Why? We know everything except $s$; run the equation backwards: $12=\lfloor \frac{28+0-5}{s}\rfloor +1=\lfloor \frac{23}{s}\rfloor +1.$
2. Solve the floor equation. Why? Subtract 1: $\lfloor 23/s\rfloor =11$. We need $s$ with $23/s$ landing in $[11,12)$: $23/2=11.5$, and $\lfloor 11.5\rfloor =11$. ✓ So $s=2$.
3. Reject nearby values. Why? Always check the floor didn't hide another answer. $s=1\Rightarrow \lfloor 23\rfloor =23\ne 11$; $s=3\Rightarrow \lfloor 7.67\rfloor =7\ne 11$. Only $s=2$ works.

Verify: plug $s=2$ forward: $\lfloor 23/2\rfloor +1=\lfloor 11.5\rfloor +1=11+1=12$. Matches. ✓ The floor is the subtle part — many students forget that $23/2=11.5$ still gives a valid whole-number output because we round down.

---

Recall Self-test before you leave

A $3\times 3$ edge filter on a flat gray patch outputs what? ::: Zero — its weights sum to zero, so it is blind to constant brightness. Input $10\times 10$, $k=3$, $p=0$, $s=1$: output size? ::: $\lfloor (10-3)/1\rfloor +1=8$, so $8\times 8$. Why does a $1\times 1$ filter never detect edges? ::: It covers a single pixel, so it cannot compare neighbours — it only rescales. Input $28\times 28$, $k=5$, $p=0$, output $12\times 12$: stride? ::: $s=2$ (since $\lfloor 23/2\rfloor +1=12$). An all-ones $5\times 5$ filter over our $5\times 5$ input outputs? ::: The single number $28$ (the sum of all pixels).

Where to go next: stack these outputs and downsample in pooling, see how these filter weights are learned in backpropagation, and how whole trained stacks compose in CNN architectures.