A computer has no eyes. All it has is numbers. So the first question is a tiny one: how do you ask whether a small piece of a picture looks like something you are hunting for?

Try it below. On the left is a 3 × 3 snapshot. In the middle is a stencil of what you want: green squares mean “I want this bright”, red means “I want this dark”, blank means “I don’t care”. Multiply each square by the stencil and add it all up. It works like a shopping bill: every pixel is a line item, and the total is the match score.

Step 1 compared one stencil with one small piece of a picture. But a real photo has thousands of pieces. So we do the same check at every spot, one after another, using the same stencil each time.

Think of the stencil as a set of expectations: “I expect dark on the left and light on the right.” At each spot we ask one question: do the real pixels here meet that expectation? The answer is a match score. Write every score into a grid, in the same position as the spot it came from, and you get a map of where the picture meets your expectation. For an edge stencil, that is a map of where the edges are.

Below, you play the detective. Choose what you expect to see, then drag the magnifier over the elephant. Or press Scan and let it check everywhere.

Checking 676 spots for one stencil is already 676 separate sums. AlexNet’s first layer checks 3,025 spots for each of 96 stencils, for every one of over a million photos, over and over. One worker doing one sum at a time would never finish.

A graphics card is more like a stadium of 512 workers who can all do the same simple job at the same moment. Race them below.

A colour image is three grids stacked: red, green and blue. Height × width × channels. A stack of matrices like that is called a tensor. A kernel for a colour image is a tensor too, and its depth must equal the depth of what it looks at. AlexNet's first layer uses 96 kernels of size 11 × 11 × 3.

Take the 11 × 11 × 3 chunk of the image under a kernel, multiply each kernel weight by the pixel value beneath it, and add everything up. That is 363 multiplications and one number out. A kernel has 363 numbers it can set freely, its degrees of freedom, and training chooses them. Each kernel is one more way of looking: the more of them, the more the layer can notice.

After the first layer you are left with 96 maps. They become the input of the next layer, whose kernels take dot products over those maps. The output of each step is the input of the next, so by the end every image has passed through a vast number of multiplications. AlexNet has five convolutional layers, then three fully connected layers that look at everything at once.

Where do the numbers go? Click a layer. A surprising split appears: almost all of the computation happens in the convolutional layers, but almost all of the weights sit in the fully connected ones.

The operations inside AlexNet never change: dot products, a rectifier, pooling. Training changes only the weights those operations use. Backpropagation works out, for every single weight, which direction to nudge it so the answer is a little less wrong, by passing the error backwards through the layers.

On the last page the nudge was a flat plus or minus the picture. Here it is the slope of the error: w ← w − ε · ∂L/∂w. Below, a tiny network starts with random kernels and has to learn to tell vertical lines from horizontal ones. Nobody tells it what an edge detector looks like.

There is a picture that makes training click. Forget the image for a moment and treat the weights themselves as a point. A kernel with three weights is one point in 3D space; AlexNet is one point in a space with 60 million directions. Each training example puts a flat wall through the origin: weights on one side get it right, weights on the other get it wrong. Where every example’s right-hand side overlaps is a cone of feasible solutions. Training is just moving the point until it is inside the cone. Geoffrey Hinton draws exactly this picture when he teaches the perceptron.

The authors credit their result to a short list of choices, which they sort by importance in Section 3. Here is the paper in plain English, one section at a time. Each one has something to try.

Every image the network sees is mapped through those levels of multiplications into a long list of numbers. Stop one layer early and grab it: a vector with 4,096 numbers. A vector is a point in 4,096-dimensional space. Just as you can measure the distance between two points on a map, you can measure it in that space.

The authors did exactly that. They took a test image’s vector, found the training images whose vectors were closest, and the nearest images were, for example, all elephants. Yet they note that at the pixel level those pictures are generally not close, because the elephants appear in a variety of poses. This is an embedding space: distance and direction mean something about the content, not just the colours.

Now the last step. When a new picture comes in, the network turns it into its vector, which is a single point. Every picture it has seen before is already a point in the same space. To recognise the new one, find the points nearest to it and let them vote. If most of the closest points are elephants, it is probably an elephant.

Almost none of AlexNet's ingredients were new. Convolutional networks that learn their kernels were already reading ZIP codes in 1989. Backpropagation was published in 1986. What blocked a network this large was hardware and data: there were too few labelled images and not enough computing power to train something so big. The authors were explicit that their results should improve simply by waiting for faster GPUs and bigger datasets.