01Why ordinary networks struggle with images

A plain fully connected neural network treats its input as one long list of numbers. To feed it a picture, you have to flatten the grid of pixels into that list — and the moment you do, you throw away the thing that makes an image an image: which pixels sit next to which. An eye in the top-left corner and the same eye shifted slightly to the right look like completely different inputs. Worse, every pixel gets its own connection to every neuron, so even a small image needs an enormous number of weights to learn.

A convolutional neural network (CNN) is a neural network built specifically for grid-structured data such as images. Instead of connecting everything to everything, it slides small learnable filters across the input to produce feature maps — preserving spatial layout and reusing the same pattern detector everywhere it looks (LeCun et al., 1998; Goodfellow, Bengio & Courville, Ch. 9).

• Spatial structure matters. In an image, a pixel only makes sense in the context of its neighbours — flattening destroys that.
• Parameters explode. Fully connecting every pixel to every neuron is wasteful and hard to train.
• CNNs are purpose-built for grids — they keep the 2-D layout and scan it with small filters.

02Three ideas that make a CNN work

Almost everything special about a CNN comes from three closely related ideas. They sound technical, but each one is just a practical answer to a problem the plain network had.

• Local receptive fields. Each unit in a convolutional layer connects only to a small local region of the previous layer — its receptive field. The network learns local patterns first (an edge here, a corner there) before combining them into anything bigger.
• Parameter sharing. The same filter weights are reused at every position on the image. A detector that finds a vertical edge in one corner finds it everywhere, which slashes the number of parameters versus a fully connected layer and gives the network translation equivariance — shift the input, and the feature map shifts the same way.
• Pooling. Pooling layers (most commonly max or average pooling) downsample a feature map — summarising each little neighbourhood into a single value. That shrinks the data, saves computation, and adds a degree of translation invariance so small shifts no longer change the answer.

These ideas have a long pedigree: they are loosely inspired by the visual cortex hierarchy of simple and complex cells with local receptive fields (Hubel & Wiesel, 1962), an idea first turned into an architecture by Fukushima neocognitron (1980). The analogy is motivational, not a literal model of the brain.

03Watch a convolution happen

Here is the operation at the heart of every CNN. A small kernel (a grid of weights) is laid over a patch of the input — the receptive field. Each overlapping pair of numbers is multiplied, all the products are added up, and that single sum becomes one cell of the output feature map. Then the kernel slides over by the stride and does it again. Step through it below: the highlighted patch is what the kernel currently sees, and the multiply-add is written out in full.

• Multiply, add, place one cell. Every feature-map cell is one dot product between the kernel and the patch beneath it.
• The kernel is shared. The exact same nine weights are reused at every window — that is parameter sharing in action.
• Stride and kernel size set the output size. A bigger stride skips positions, producing a smaller feature map (Dumoulin & Visin, 2016).

04From edges to objects: stacking layers

One convolution finds simple patterns. The power comes from stacking them. A typical CNN alternates a convolution plus a nonlinear activation with a pooling layer, again and again, then finishes with one or more fully connected layers (or a global pooling layer) that turn the final features into a prediction. Because each layer feeds on the layer below, the network learns a feature hierarchy: early layers detect edges and textures, and deeper layers combine those into parts and whole objects. The milestone architectures below are points on that same idea, not a single fixed design.

05Where CNNs stand today

CNNs drove a decade of progress in computer vision, powered by large benchmark datasets such as ImageNet. They remain a strong, efficient default for many image tasks, and their core ideas — local receptive fields, parameter sharing, pooling — show up well beyond images. But they are no longer the only state of the art: Vision Transformers and other attention-based architectures now rival or exceed CNNs on many vision benchmarks. The right choice depends on the task, the data you have, and your compute budget — not on any single architecture being universally best.

• Still a strong default for image classification, detection, and segmentation, especially when efficiency matters.
• Not the only option. Attention-based models (Vision Transformers) compete with or beat CNNs on many benchmarks.
• The ideas generalise. Local pattern detection and weight sharing apply to audio, time series, and more.

06Check your understanding

07Take it with you & go deeper