Convolutional neural networks (CNN)

Prerequisites

• The MLP: weighted sums and activations.
• Matrices and element-wise products.
• Images as grids of pixel values.

The analogy

How it works

Output size: for input width $W$, filter size $F$, padding $P$ and stride $S$: $\text{out} = \frac{W - F + 2P}{S} + 1$.

Start with one convolution by hand

Image $\begin{bmatrix} 1 & 2 & 0 \\ 0 & 1 & 3 \\ 2 & 1 & 0 \end{bmatrix}$, filter $\begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix}$, stride 1, no padding. Predict, then open "Check".

Finish the picture: sizes and parameters

A real layer: input 32 × 32 × 3 (RGB), 16 filters of size 5 × 5, padding 2, stride 1.

• Output size. Predict it.
  Check

  $(32 - 5 + 2 \cdot 2)/1 + 1 = 32$, so 32 × 32 × 16 (one channel per filter).

• Parameters, compared with a dense layer. Predict both.
  Check

  Conv: $(5 \cdot 5 \cdot 3 + 1) \cdot 16 = 1{,}216$. A dense layer from 3,072 inputs to 16,384 outputs would need about 50 million weights.

Full worked calculation

The page's convolution, the 3 × 3 image $\begin{bmatrix} 1 & 2 & 0 \\ 0 & 1 & 3 \\ 2 & 1 & 0 \end{bmatrix}$ with the 2 × 2 filter $\begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix}$, computed at every position, then bias and ReLU, output sizes with padding and stride, and the parameter count.

1. 1Place the filter at the top-left

   $$\begin{bmatrix} 1 & 2 \\ 0 & 1 \end{bmatrix} \odot \begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix} = \begin{bmatrix} 1 & 0 \\ 0 & -1 \end{bmatrix} \;\Rightarrow\; \text{sum} = 0$$

   Multiply element by element and add. This filter computes "top-left minus bottom-right", a diagonal edge detector: 0 means no change along the diagonal here.

2. 2Slide one step right

   $$\text{patch } \begin{bmatrix} 2 & 0 \\ 1 & 3 \end{bmatrix}: \; 2 - 3 = -1$$

   Only the two diagonal corners matter for this filter. The bottom-right is brighter than the top-left, so the response is negative.

3. 3Finish the grid

   $$\text{output} = \begin{bmatrix} 0 & -1 \\ -1 & 1 \end{bmatrix}$$

   Four positions fit (two across, two down), so the output is 2 × 2. Each output number says how strongly the pattern is present at that place.

4. 4Bias and ReLU

   $$\text{bias } 0, \;\; \text{ReLU} \;\Rightarrow\; \begin{bmatrix} 0 & 0 \\ 0 & 1 \end{bmatrix}$$

   Like any neuron, the filter has one bias added at every position, then an activation. ReLU keeps only the place where the pattern clearly appears: bottom-right.

5. 5Output size formula

   $$\text{out} = \frac{W - F + 2P}{S} + 1: \quad \frac{3 - 2 + 0}{1} + 1 = 2, \qquad \text{with } P = 1: \; \frac{3 - 2 + 2}{1} + 1 = 4$$

   $W$ input width, $F$ filter size, $P$ padding, $S$ stride. Padding with zeros lets the filter also sit on the borders. For a 32-wide image, a 5 × 5 filter with $P = 2$ and $S = 1$ keeps the size: $(32 - 5 + 4) + 1 = 32$.

6. 6Count the parameters

   $$\text{conv: } 2 \cdot 2 + 1 = 5, \qquad \text{dense layer } 9 \to 4: \; 9 \cdot 4 + 4 = 40$$

   The same 5 numbers are reused at every position (weight sharing). A dense layer producing 4 outputs from 9 pixels needs 8 times more, and the gap grows enormously with real image sizes.

The rule in plain words

A convolutional layer slides each small filter over the input (with a stride, after optional zero padding) and computes a weighted sum at every position, producing one feature map per filter.

Stack conv layers (with ReLU and pooling) to detect increasingly complex patterns, then finish with dense layers for the prediction.

The code

Read this code after you have convolved the 3 × 3 image by hand. It will make more sense.

int conv_out_size(int w, int f, int pad, int stride) {   /* integer division rounds down */
    return (w - f + 2 * pad) / stride + 1;
}

void conv2d(double img[][3], int n, double k[][2], int f, double out[][2]) {   /* valid, stride 1 */
    for (int r = 0; r + f <= n; r++)
        for (int c = 0; c + f <= n; c++) {
            double s = 0;
            for (int i = 0; i < f; i++)
                for (int j = 0; j < f; j++) s += img[r + i][c + j] * k[i][j];   /* patch × filter */
            out[r][c] = s;
        }
}

flowchart LR
  I["image 32×32×3"] --> C1["conv 5×5, 16 filters + ReLU"]
  C1 --> P1["pool 2×2 → 16×16×16"]
  P1 --> C2["conv + ReLU"]
  C2 --> P2["pool"]
  P2 --> F["flatten → dense → softmax"]
          

Putting numbers on it

The two numbers to know for every conv layer:

Common mistakes

• Forgetting the input channels when counting parameters (a 5 × 5 filter on RGB has 75 weights, not 25).
• Forgetting the $+1$ in the output-size formula.
• Thinking the parameter count depends on the image size; it doesn't, because the filter is shared.

Try it yourself

Did you know?

Key points to remember

If you remember one thing from each line, remember the because.

• Convolution finds patterns anywhere because the same filter is applied at every position.
• CNNs need few parameters because a filter's weights are shared across the whole image.
• Padding preserves size because extra border pixels let the filter cover the edges.
• Stride shrinks the output because the filter skips positions.
• Deeper layers see bigger patterns because each layer combines features from a wider area of the input.

Self-check questions

Answer these in order, out loud. They follow the page, so your answers become the script of your video.

1. How is a convolutional filter like a magnifying glass that recognises one shape?
   Sample answer

   It slides over every spot of the image and reports how strongly its shape appears there, producing a map of matches.

2. Convolve the 3 × 3 image with the filter [[1, 0], [0, −1]].
   Sample answer

   The four patches give 0, −1, −1, 1, so the output is [[0, −1], [−1, 1]].

3. Why does the loop run while r + f <= n?

   A good answer mentions where the filter fits.

   Sample answer

   The filter of size $f$ must fit entirely inside the image; the last valid top-left row is $n - f$, which gives $n - f + 1$ output rows.

4. So what is a CNN, in one sentence?
   Sample answer

   A neural network whose layers slide small learned filters over the input, sharing weights across positions to detect local patterns.

5. Why does a conv layer have far fewer parameters than a dense layer on images?

   A good answer mentions sharing.

   Sample answer

   A dense layer connects every pixel to every output; a conv layer reuses the same small filter everywhere, so its weights don't grow with the image size.

6. Give the output-size and parameter formulas.
   Sample answer

   Output $= (W - F + 2P)/S + 1$; parameters $= (F \cdot F \cdot C_{\text{in}} + 1) \cdot C_{\text{out}}$.

7. Compute the output size for 32 × 32 input, 5 × 5 filter, padding 2, stride 1.
   Sample answer

   $(32 - 5 + 4)/1 + 1 = 32$.

8. If you had to teach this to a friend in 2 minutes, what would you leave out, and why?
   Sample answer

   I'd leave out stride and the parameter formula. I'd keep the magnifying-glass analogy, the 3 × 3 convolution, and "shared small filters find local patterns anywhere".

External resources

• Stanford CS231n: Convolutional networks: the standard explanation, with an animated demo.
• CNN Explainer: an interactive visualisation of a small CNN.
• PyTorch docs: nn.Conv2d: shape formulas and parameters.

Videos

• 3Blue1Brown: But what is a convolution?: convolution explained visually.