How does a neural network learn?

How does a neural network learn?

If a neural network begins with poor guesses, what would it need in order to improve? It would need a way to measure how wrong it was and a way to decide which internal settings contributed to that error. The first is easy to imagine. The second is the hard one, and it is worth sitting with: a network may hold millions of adjustable numbers, and the error it produced is a single number at the end. How could blame for one number be apportioned among millions?

The network transforms an input through layers of weighted calculations and produces a prediction. A loss function compares that prediction with the desired result and turns the mismatch into a number. Lower loss means the current settings performed better on that example.

Now ask the obvious question: which way should a weight move? You could try nudging one weight up, re-running the whole network, and seeing whether the loss fell. That works, and it is hopeless — with a million weights you would need a million re-runs to take one step. What we actually want, for each weight, is a slope: if this weight rose slightly, would the loss rise or fall, and how steeply? That collection of slopes, one per weight, is the gradient. It is not a mysterious object. It is a very long list of answers to a very simple question, and it points in the direction of steepest increase of the loss — so moving against it reduces error.

The saving grace is that the network is a composition of simple steps, and the chain rule of calculus says the slope through a chain of steps is the product of the slopes of each step. So you can compute the slope at the output, hand it backwards to the layer beneath, multiply, and continue. That is backpropagation: not a separate learning algorithm but a bookkeeping method that gets every weight's slope in roughly the cost of one forward pass, instead of one pass per weight. The entire practicality of deep learning rests on that accounting trick.

Having a direction is not the same as knowing how far to go. The step size is the learning rate, and it is the setting people spend the most time on. Too small, and training crawls, or settles into the first shallow dip it finds. Too large, and the step overshoots the bottom of the valley and lands higher up the far side — repeat that and the loss climbs instead of falling, sometimes to infinity within a few dozen steps. There is no correct value in the abstract; it depends on the problem, and much of modern optimizer design is machinery for adjusting it as training proceeds.

There is one more requirement, and it is easy to miss because it looks like a detail. Between layers sits a non-linear function — something that bends the signal rather than merely scaling it. Why does that matter? Suppose it were absent, and every layer only multiplied and added. Then a stack of layers is a linear map applied to a linear map, which is itself just a linear map: a hundred-layer network would collapse, exactly, to something a single layer could compute. All the depth would be decoration. The bend between layers is what makes the composition of many simple steps able to express something no single step can, and it is the reason depth buys anything at all.

One correction is rarely enough. Training repeats the cycle across many examples, gradually finding weights that capture useful statistical patterns. What has been learned, then, is not a list of stored answers but a configuration that tends to produce suitable outputs for similar inputs.

A neural network does not necessarily reason as a human brain does, despite the biological inspiration of its name. Put more bluntly: what happens here is curve fitting. The system is adjusting parameters of a very flexible function so that it passes near the examples it was shown. That it does so at enormous scale, and that the resulting behaviour can be strikingly useful, does not change the kind of thing it is — nothing in the procedure above requires or produces understanding of the subject matter, and the network has no representation of being right, only of scoring well.

Which is why fitting the training data is a weak result on its own. A function flexible enough to approximate almost anything is flexible enough to trace noise, and a network can memorize its examples or latch onto a correlation that holds in the data and nowhere else — background texture that happens to co-occur with the label, a watermark, an artefact of how the data was collected. The standard guard is to split the data: fit on a training set, and check on a validation set the optimizer never touched. If loss keeps falling on the first while rising on the second, the network is not learning any longer, it is memorizing, and the honest response is to stop. Regularization, representative examples, and careful evaluation help, but none of them make the check unnecessary — and the moment validation data is used to choose settings, it has quietly become training data, which is why a third, untouched test set exists.

• How overfitting differs from useful learning.
• Why training and inference require different amounts of work.
• Why very deep networks were hard to train before residual connections and normalization.

Every term the collection defines is gathered in the glossary.