📌 Daily Briefing

Convolutional Neural Networks — seeing with sliding filters

Intuition. A fully connected layer looking at a 224×224 image needs ~150K weights per neuron — and it has to relearn "an edge" separately at every pixel position. A convolutional layer fixes both problems with one idea: learn a tiny filter (say 3×3) and slide it across the whole image. The same 9 weights detect the same pattern everywhere. That's weight sharing, and it encodes a physical truth: a cat's ear is a cat's ear whether it appears top-left or bottom-right (translation equivariance).

Mechanism. At each position, the filter computes a dot product between its weights and the local patch of pixels; sliding it produces a feature map — a heatmap of "how strongly does this pattern appear here?". A conv layer learns many filters in parallel (e.g. 64), producing 64 feature maps. Two knobs control geometry: stride (step size of the slide) and padding (zeros added at the border so the output doesn't shrink). Output size follows (N − F + 2P)/S + 1 for input N, filter F, padding P, stride S. Between conv layers, pooling (usually 2×2 max-pool) downsamples each map, keeping the strongest activation per region — building in a little translation invariance and halving the spatial resolution.

Depth builds abstraction. Stacked conv layers form a hierarchy: layer 1 learns edges and color blobs, layer 2 combines them into corners and textures, deeper layers respond to eyes, wheels, faces. Each neuron's receptive field — the input region it can see — grows with depth, so late layers reason about whole objects while early layers handle local detail.

# A 3x3 vertical-edge filter, by hand (numpy)
import numpy as np
img = np.zeros((6,6)); img[:, 3:] = 1.0        # dark left, bright right
k = np.array([[ -1,0,1],[-2,0,2],[-1,0,1]])    # Sobel filter
out = np.zeros((4,4))
for i in range(4):
    for j in range(4):
        out[i,j] = (img[i:i+3, j:j+3] * k).sum()
print(out)   # strong response exactly at the vertical edge (columns 2-3)

Why it matters. CNNs (LeNet → AlexNet 2012 → ResNet 2015) made deep learning work in practice and powered the first ImageNet breakthroughs; parameter sharing made deep vision models trainable at all. Their DNA is everywhere today: vision encoders in multimodal LLMs, convolutional front-ends in speech models, and the "local pattern → hierarchy of features" principle that attention later generalized. Next stop in the curriculum: architectures for sequences — RNNs and LSTMs.