Image kernels

Every CNN starts with one humble move: slide a tiny grid of numbers — a kernel — across an image, multiply, add, write down the answer. That's convolution, and it's the entire trick. Blur, sharpen, find edges: all the same operation with different numbers in the grid. Hover the image below and watch the arithmetic happen, one pixel at a time.

3×3 kernelconvolution is linear Sobel = a derivativeCNNs learn kernels

Nine numbers, slid everywhere

Each output pixel is a weighted sum of the 3×3 input patch around it: line the kernel up on a pixel, multiply each of the 9 input values by the kernel number sitting on it, add the 9 products — that sum is the output pixel. Then slide one pixel over and do it again, everywhere. The kernel never changes as it slides — the same 9 weights judge every neighborhood in the image. Pick a kernel, then hover (or drag on) the left image to see the exact patch × kernel arithmetic for that spot.

Slide a kernel over an image

input (hover me)

output = input ⊛ kernel

kernel (editable)

hover the image →

Read the kernels like sentences

Blur says "be the average of your neighborhood" — all nine weights equal, summing to 1, so flat areas pass through and sharp details get smeared. Sharpen says "be yourself, amplified, minus your neighbors" — it boosts wherever a pixel differs from its surroundings. Edge (the Laplacian) drops the "be yourself" part entirely: weights sum to zero, so any flat region — bright or dark — outputs black, and only change survives. And Sobel is Phase 2 calculus in a trench coat: right column positive, left column negative is literally a discrete ∂brightness/∂x — a derivative, computed by sliding. Vertical edges (the house walls) light up under Sobel ↔ but vanish under Sobel ↕; the horizon does the opposite. Edit any cell in the kernel grid and invent your own.

🔬 Test the claim "convolution is linear": it's multiply-and-add with fixed weights — exactly a dot product per pixel, no ifs, no squashing. Proof you can run: blur then sharpen gives the same result as convolving with the single combined kernel — compositions of linear ops stay linear. That's also why a CNN must add a non-linearity (ReLU) after each conv layer: a stack of pure convolutions, however deep, collapses into one big convolution — one linear op, XOR-blind like the zero-hidden-layer net in the playground.

From hand-made to learned

For 40 years, computer vision meant experts hand-choosing these grids — Sobel for edges, Gaussian for noise. The CNN revolution is one idea: make the 9 numbers learnable weights and let backprop decide what to detect. Given data, the first layer of a trained CNN rediscovers edge and color detectors on its own — nobody tells it to. Later layers convolve the outputs of earlier ones, building corners from edges, eyes from corners, faces from eyes. You'll watch that pipeline run in the CNN explainer next.

⚠️ Traps: convolution is linear — the non-linearity in a CNN comes from the activation after it · the kernel's weights are shared across every position — that's why a conv layer has ~40 parameters where a dense layer would need millions · without padding, output shrinks (140×100 → 138×98 here — we pad the border) · a kernel summing to 0 outputs black on flat regions by design, not by bug · blurring loses information permanently — sharpen after blur is enhancement, not recovery.

Takeaways: output pixel = Σ (patch × kernel) · same 9 weights everywhere = weight sharing = translation tolerance · blur averages, sharpen amplifies difference, edge kernels sum to 0, Sobel ≈ a spatial derivative · CNNs don't use hand-made kernels — they learn them · conv is linear, so ReLU must follow.

Curated companion: Setosa — Image Kernels.