Foundations — Convolution operation and filters

This page assumes you have seen nothing. We build every letter and symbol the parent note on Convolution operation and filters uses, in an order where each new idea leans only on the ones before it. A Hinglish version of the parent lives at 3.4.01 Convolution operation and filters (Hinglish).

0. A picture is a grid of numbers

Before any symbol, look at what an image is to a computer.

Look at the figure: the pale-yellow square is one pixel; its number 2 is its brightness. The image has a height (how many rows) and a width (how many columns). That is all "image" means from here on.

1. $I$ — the input image

• Plain words: $I$ = the picture-as-a-table.
• The picture: the full grid in figure s01.
• Why the topic needs it: convolution reads its numbers out of $I$, so we need a way to point at any one cell.

2. $i$ and $j$ — where we are looking

• The picture: in figure s01 the arrow labelled $(i,j)$ points at exactly one square.
• Counting starts at 0. The very top-left pixel is $I[0,0]$, not $I[1,1]$. This is called zero-indexing and every formula below relies on it.

3. $H$, $W$ — height and width

• The picture: the two arrows down the side ($H$) and along the top ($W$) in figure s01.
• Why needed: they tell us how far we can slide the filter before we fall off the edge — which is exactly what the output-size formula measures.

4. $K$ — the filter (kernel), and $k$ its size

• Plain words: $K$ is the little pattern we are hunting for. Its numbers say "I want dark here, bright there."
• The picture: the small $3\times 3$ chalk-blue grid in figure s02. Here $k=3$.
• Why the topic needs it: without a filter there is no pattern to match. The filter's weights ARE the question convolution answers.

5. $m$, $n$ — walking inside the filter

• The picture: figure s02 shows the filter laid on top of the image; the offsets $m,n$ measure how far inside the overlaid window we are.
• Why the $i+m$? The window's top-left corner is at $(i,j)$. Move $m$ down and $n$ right inside the window, and you land on image pixel $(i+m,j+n)$. That is the whole reason those sums look the way they do.

6. $\sum$ — "add up a list"

• Plain words: it is a for-loop that keeps a running total.
• Example (one dimension): $\sum _{m=0}^{2}m=0+1+2=3$.
• Why two of them? The filter is 2D, so we loop over rows ($m$) and columns ($n$). A double sum ${\sum }_m{\sum }_n$ visits every one of the $k\times k$ cells exactly once.

7. The core operation: multiply-then-add

Now every symbol in the parent's main formula is defined, so we can read it:

Figure s03 shows the three moves: overlay, multiply cell-by-cell, add into one output square.

8. The feature map — collecting every answer

• The picture: figure s03's output grid on the right — one output cell per filter position.
• Why the topic needs it: the feature map is a "heat map of matches" — bright where the pattern is present. This is the whole point of a convolution layer.

9. Sliding controls: stride $s$ and padding $p$

• The picture: figure s04 — a stride-2 jump (blue arrows) and a one-pixel zero border (pale ring).
• Why stride: shrinks the output on purpose (cheaper compute, like pooling).
• Why padding: without it the feature map is smaller than the input by $k-1$ each side; padding lets you keep the size.

10. The depth dimension: channels $c$

For colour input the filter also gains a depth, and we add across it:

Prerequisite map

Each foundation feeds the next; together they assemble the full convolution the parent note defines. From here you can move on to receptive fields, full CNN architectures, and how these filters are learned via backpropagation (with helpers like batch normalization and reused across tasks in transfer learning).

Equipment checklist

Cover the right side and answer aloud. If any stumps you, reread its section.