How does a machine get better by being wrong?

The full story

The episode's narration, word for word. Numbers link to the sources below; timestamps play that moment.

The question 0:00

Last episode's artificial neuron multiplies each input by a weight and adds them up ¹. Each weight is like a dial, and the dials decide what the network does ^1,2. Big language models, in papers from 2020 to 2023, had tens of billions of them or more ^3,4,5. Nobody sets them by hand ². The machine sets them itself, by guessing, being wrong, and adjusting ². So how does a machine get better by being wrong?

Two dials 0:32

Let's build a tiny network, about as small as one can be and still have a hidden step. One number goes in, gets multiplied by a first dial, then by a second dial, and out comes a guess ². Our one example to learn from: when the input is 2, the right answer is 3 ². Set the first dial to 1 and the second to a quarter, and the guess is just a half ². It's wrong, and now it has to get less wrong.

Wrong, as a number 1:02

To learn, the machine needs one number for how wrong it is ^2,6. Our guess is two and a half too low ². Square that miss and halve it, and you get just over three ². Squaring does three jobs: opposite misses can't cancel out, big misses count far more than small ones, and the curve is smooth, with a slope everywhere ^1,2. Add that up over every example, and the total is called the loss. Learning means making it smaller ^2,6.

A mathematician's shortcut 1:32

This idea is older than you might think. In October 1847, the French mathematician Augustin-Louis Cauchy sent a short note to the Academy of Sciences in Paris ⁷. He wanted to calculate the orbit of a body in the sky, with six unknowns at once ⁷. So he squared the errors, added them into one number, and kept stepping against its slope, downhill, to make it smaller ⁷.

Which way is downhill? 2:00

So which way should each dial turn? Try a nudge ⁸. Turn the second dial up by a hundredth, run the network again, and the loss drops by about five hundredths ^8,2. That's a slope of minus five: turning this dial up helps a lot ^8,2. Nudge the first dial instead, and the loss drops a quarter as much, a slope of minus one and a quarter ^8,2. All the slopes together are called the gradient ^1,8.

Walking downhill in fog 2:30

Picture a hillside in thick fog ⁸. The height of the ground is the loss, and where you stand is the setting of the dials ⁸. You can't see the valley, only which way the ground slopes under your feet ⁸. So you take a small step downhill, feel again, and repeat ^1,8. That's gradient descent ¹. Each dial moves by minus its slope, times a small number called the learning rate ². With a learning rate of a tenth, one step takes the loss from just over three to under one ².

How big a step? 3:04

That small number matters a lot ⁸. Make it ten times smaller, and the loss creeps: it takes 32 steps to get below a hundredth, which took just 3 steps before ^8,2. Make it 0.4, and the first step leaps right over the valley, and every step after that lands higher still ^8,2. The loss goes from 3 to 7, to 213, to more than fourteen million ². Too timid, and it crawls. Too bold, and it blows up ⁸.

Real step sizes 3:37

Real projects pick this number with care ⁸. In 1986, David Rumelhart, Geoffrey Hinton and Ronald Williams used a tenth for a small network ². OpenAI's 2020 paper on GPT-3 used six hundred-thousandths for its largest model ³, and Meta's 2023 paper on LLaMA used fifteen hundred-thousandths for its biggest ⁵. The GPT-3 paper notes that larger models typically need smaller learning rates ³.

The whole landscape 4:10

With two dials, we can draw the whole landscape. Each point on this map is a pair of dial settings, coloured by its loss, calculated ². Three steps take our loss below a hundredth ². And the valley floor isn't a point, it's a curve: any two dials that multiply to one and a half are exactly right for this example ².

Where the fog picture breaks 4:33

The fog picture breaks in four places. A network doesn't feel the slope, it calculates it exactly ^9,8. There's one direction per dial: in the 2020s language-model papers, billions of them, not two ^8,3. Each step looks at a different random batch of examples, so the ground shifts under your feet ^1,8. And the bottom you reach may not be the lowest point anywhere ^7,2. The 1986 team found networks rarely got stuck in a bad dip, and a 2014 study argued that flat, saddle-shaped stretches are the bigger trap ^2,10.

Too many dials to nudge 5:10

And nudging has a catch. Every nudge means running the whole network again, once per dial ^9,8. With a million weights, that's a million and one runs for a single step ^9,8. Fine for two dials, hopeless for a real network ^9,8. We need every slope at once.

The blame problem 5:30

The deeper puzzle already had a name. In 1961, Marvin Minsky called it the credit-assignment problem: when a long chain of decisions succeeds or fails, how do you share out the credit, or the blame ¹¹? In a network it bites hardest in the hidden layers, whose right answers nobody specifies ². And last episode's perceptron jumps in a sudden step, so a tiny weight change does nothing or flips the answer ¹. Swap the step for a smooth S-shaped curve, and there's a slope to follow again ^1,2.

Passing blame backwards 6:06

The answer is backpropagation: passing blame backwards ². At the output, the guess was two and a half too low ². The second dial's share is that blame times what flowed in through it, which was 2, so minus five ^12,2. Pass the blame back through the second dial, multiplying by its setting of a quarter ^12,2. Then the first dial's share is that times its input of 2: minus one and a quarter ^12,2. The same slopes our nudges found, only exact this time ^8,2. Each move just multiplies neighbouring numbers, a rule from calculus called the chain rule ¹².

Why it's fast 6:44

One pass forward makes the guess, and one pass backward hands every weight its share of the blame at once ^9,2. The backward pass costs about as much as the forward one ⁹. So instead of a million and one runs, the whole gradient costs roughly two ⁹. That speed-up greatly widened what neural networks could learn ⁹.

Who thought of it? 7:07

Who invented it? Depends who you ask ^13,14. Running slopes backwards through a calculation was suggested by several people from the late 1960s ¹³. Seppo Linnainmaa, a Helsinki master's student, says it came to him on a sunny afternoon in a Copenhagen park in 1970, while he was studying rounding errors, not networks ¹³. Paul Werbos applied it to neural networks by the early 1980s ^13,14, and David Parker and Yann LeCun found versions independently ². The credit is still argued over. Jürgen Schmidhuber, himself a party to these disputes, says the 1986 paper failed to cite where the method came from ¹⁴. Hinton has said he never claimed to invent it, only to show what it could learn ¹⁵.

Nature, 1986 7:59

What made it famous was a four-page paper in Nature, on the ninth of October 1986, by Rumelhart, Hinton and Williams ². It showed that hidden units trained this way invent useful features of their own ². One small network learned to spot whether six on-off inputs were a mirror image, with a neat trick using just two hidden units ². Another learned two family trees, and filled in four relationships it was never shown ².

Is this how brains learn? 8:31

Is this how your brain learns? The 1986 paper itself said it was not a plausible model of learning in brains ². Strict backpropagation needs backward connections exactly as strong as the forward ones, and the cortex doesn't seem wired that way ⁶. In 2020, Timothy Lillicrap, Hinton and colleagues argued the brain might approximate it another way ⁶. In 2022, Hinton wrote that, as a model of the cortex, it remains implausible ¹⁶. It's still an open question ^6,16.

The whole loop 9:08

Here's the loop. Guess, measure the loss, pass the blame back, nudge every dial a little downhill, repeat ^9,2. Modern training works out the slope on a random batch of examples, not all of them ^1,8. And it often uses a smarter stepper called Adam, from 2014, that tunes each dial's step size as it goes ¹⁷. Papers from OpenAI in 2020, DeepMind in 2022 and Meta in 2023 describe training language models with Adam or a close variant ^3,4,5.

Why so many examples? 9:42

Why so many examples? Partly because each step is a small nudge ^1,8. Partly because each example pulls the dials its own way, and the true downhill only shows in the average of many ^1,8. And more dials need more data: a 2022 DeepMind study found that, to get the most from a fixed amount of computing, model size and training data should grow together ⁴. Even the 1986 mirror network needed 1,425 sweeps through all 64 possible input patterns: over ninety thousand examples, to set seventeen numbers ².

Scale, dated 10:21

OpenAI's GPT-3, in 2020, had 175 billion adjustable numbers, called parameters, trained on 300 billion tokens, or chunks of words ³. DeepMind's Chinchilla, in 2022: 70 billion parameters, 1.4 trillion tokens ⁴. Meta's largest LLaMA, in 2023: 65 billion, on 1.4 trillion ⁵. By our arithmetic, that's around a hundred thousand downhill steps or more, each nudging tens or hundreds of billions of dials ^3,5.

So why 2012? 11:02

So by 1986 the recipe was on the table: a loss, a slope, and blame passed backwards ^9,2. Yet even in the late 1980s, people ran into limits, especially when they tried to train networks with many layers ⁹. The method was there, but something else was missing. So why did AI suddenly get good after 2012?

Sources

Every factual claim in the episode is tied to one of these. Spotted an error? Tell us.

1. M. Nielsen, Neural Networks and Deep Learning, ch. 1 "Using neural nets to recognize… — neuralnetworksanddeeplearning.com
2. D. E. Rumelhart, G. E. Hinton, R. J. Williams, "Learning representations by… — nature.com
3. T. Brown et al. (OpenAI), "Language Models are Few-Shot Learners" (GPT-3),… — arxiv.org
4. J. Hoffmann et al. (DeepMind), "Training Compute-Optimal Large Language Models"… — arxiv.org
5. H. Touvron et al. (Meta AI), "LLaMA: Open and Efficient Foundation Language Models",… — arxiv.org
6. T. P. Lillicrap, A. Santoro, L. Marris, C. J. Akerman, G. Hinton, "Backpropagation and… — nature.com
7. C. Lemaréchal, "Cauchy and the Gradient Method", Documenta Mathematica, Extra Volume… — web.archive.org
8. Stanford CS231n course notes, "Optimization: Stochastic Gradient Descent" — cs231n.github.io
9. M. Nielsen, Neural Networks and Deep Learning, ch. 2 "How the backpropagation… — neuralnetworksanddeeplearning.com
10. Y. Dauphin, R. Pascanu, C. Gulcehre, K. Cho, S. Ganguli, Y. Bengio, "Identifying and… — arxiv.org
11. M. Minsky, "Steps Toward Artificial Intelligence", Proceedings of the IRE 49(1),… — mit.edu
12. Stanford CS231n course notes, "Backpropagation, Intuitions" — cs231n.github.io
13. A. Griewank, "Who Invented the Reverse Mode of Differentiation?", Documenta… — web.archive.org
14. J. Schmidhuber, "Who Invented Backpropagation?" (AI Blog, IDSIA; author's own account,… — people.idsia.ch
15. Synced, "Who Invented Backpropagation? Hinton Says He Didn't, but His Work Made It… — syncedreview.com
16. G. Hinton, "The Forward-Forward Algorithm: Some Preliminary Investigations",… — arxiv.org
17. D. P. Kingma, J. Ba, "Adam: A Method for Stochastic Optimization", arXiv:1412.6980… — arxiv.org

Researched and scripted with AI assistance, fact-checked claim by claim, with synthetic narration and diagrams drawn in code. How we make episodes.