Learn · Beginner

Convolutional neural networks: how machines learned to see

A convolutional neural network, or CNN, is a neural network that learns small reusable pattern detectors and slides each one across an entire image. Because the same detector is applied at every position, a CNN that learns what an edge looks like in one corner automatically recognizes that edge everywhere else. That single design choice is what turned computer vision from a hand-engineered craft into something a machine could learn, and convolutions still run inside most image generators, video models and on-device camera features today.

The problem convolutions solve

Imagine trying to recognize handwriting with an ordinary fully connected network. Every pixel gets its own connection to every unit in the next layer. A modest 200-by-200 colour image has 120,000 numbers in it, so the first layer alone needs tens of millions of parameters - and none of what it learns transfers between positions. Teach it to spot a loop in the top-left, and it knows nothing about loops in the bottom-right. You would need a separate detector for every possible location of every possible feature.

Two facts about images make that wasteful. First, nearby pixels are related and distant ones usually are not; an edge is a local event. Second, a pattern means the same thing wherever it appears. Convolution builds both facts into the architecture instead of making the network discover them from scratch.

How a convolution actually works

Take a small grid of learned numbers - typically 3 by 3 - called a filter or kernel. Lay it over the top-left corner of the image, multiply each filter number by the pixel underneath it, add the results, and write that single number into an output grid. Slide the filter one pixel right and repeat. When you have covered the whole image, you have a feature map: a picture of where in the original image that particular pattern occurred.

The useful analogy is a stencil you drag across a page. The stencil never changes; what changes is how strongly it matches at each spot. A filter that has learned to respond to vertical edges will light up along every vertical edge in the photo, whether that is a door frame or a tree trunk, and it costs nine numbers to store.

A layer has many filters, so it produces many feature maps in parallel. Each output then passes through an activation function, which throws away the weak responses and keeps the strong ones. Downsampling - pooling, or a filter that skips positions - shrinks the grid, so the next layer's 3-by-3 filter covers a larger region of the original image without getting bigger.

Stack these and something remarkable happens on its own. The first layer learns edges and colour blobs. The second combines edges into corners and curves. The third assembles those into textures and simple parts - an eye, a wheel spoke. By the sixth or seventh layer, filters respond to whole objects. Nobody designs this hierarchy. It falls out of gradient descent and backpropagation applied to the same stacked-filter structure, and it looks strikingly like what happens in biological visual cortex.

The history in four steps

Yann LeCun's LeNet-5 demonstrated the full recipe on handwritten digits in 1998, and it read cheques commercially. It then sat mostly idle for over a decade because the hardware and the data were not there.

Both arrived in 2012. Alex Krizhevsky, Ilya Sutskever and Geoffrey Hinton trained AlexNet on two consumer graphics cards against ImageNet's million labelled photos and cut the error rate on the field's hardest benchmark by roughly a third in one go. That result is the usual marker for the start of the deep learning era.

Depth then became the frontier, and hit a wall: past about twenty layers, deeper networks got worse, not from overfitting but because the training signal degraded on its way back down. Residual connections fixed that in 2015 by letting each layer learn a correction to its input rather than a replacement for it, which made hundred-layer networks trainable.

Then in 2020 the transformer arrived in vision, chopping an image into patches and letting attention figure out which patches relate to which. Given enough data it beats a CNN, because it does not assume locality - it learns which relationships matter. Given ordinary amounts of data, the CNN's built-in assumptions are a real advantage, which is why the 2022 ConvNeXt work showed that a convolutional network modernized with the transformer era's training tricks matches transformer accuracy on standard benchmarks.

Where convolutions live now

The honest summary is that CNNs stopped being the headline and became infrastructure. The encoder and decoder inside a diffusion image model are convolutional. Speech systems convolve over spectrograms. Phone cameras run convolutional networks for every shot you take, because the architecture is small, fast, and friendly to quantization.

Two limits are worth carrying. A CNN's translation invariance does not extend to rotation or scale - a network trained on upright faces can fail on sideways ones unless you augment the data. And convolutional vision models remain vulnerable to adversarial examples: tiny, carefully chosen pixel changes, invisible to you, that flip the prediction entirely. Learning to see is not the same as seeing, a gap that current visual benchmarks keep demonstrating.

Ground Truth. (2026, July 25). Convolutional neural networks: how machines learned to see. Ground Truth. https://groundtruth.day/learn/convolutional-neural-networks.html

@misc{groundtruth:convolutional-neural-networks,
  title  = {Convolutional neural networks: how machines learned to see},
  author = {{Ground Truth}},
  year   = {2026},
  month  = {jul},
  url    = {https://groundtruth.day/learn/convolutional-neural-networks.html}
}

Topics: cnn · computer-vision · fundamentals · architecture · deep-learning