An interactive primer · three live demos
Nobody programs the answers. A model starts with random numbers, guesses, measures how wrong it was, nudges the numbers, and goes again — thousands of times. Everything we call AI is that loop, run at a scale where it stops feeling like a loop.
A normal program is a list of instructions a person worked out. A model is a pile of adjustable numbers that finds its own instructions from examples. That difference is the whole subject.
// a human decided all of this if (subject.includes("FREE MONEY")) spam++; else if (sender.endsWith(".ru")) spam++; else if (links > 12) spam++; // …and 10,000 more rules
Every rule is something a person had to think of. Spam changes, and the rules quietly rot. Nobody can write down the rule for “this face is Isaac” at all.
for each (example, answer) in data: guess = model(example) error = guess − answer numbers -= step × error // repeat
Nobody wrote “FREE MONEY”. The model searches for whatever separates the examples — including patterns you would never think to write down, and some you would rather it hadn’t.
Training is not teaching. It is search. The model has numbers — weights — and training keeps nudging them in whichever direction makes the error smaller. No understanding is inserted. The numbers just get less wrong.
Examples. For supervised learning, each one carries the answer you want: this email is spam, this photo is a cat, this house sold for $410k.
A function with adjustable numbers. Start simple — a straight line is a model. A language model is the same thing with hundreds of billions of numbers.
One number that says how wrong the model is right now. Training exists to make this number go down. Everything else is detail.
This is a real classifier — logistic regression, trained by gradient descent, in this page. Every dot is an example with two measurements. The model starts knowing nothing. Each repeat: guess every dot, measure the error, adjust the line.
It starts in a random orientation and rotates toward a position that puts class A on one side and class B on the other. The line is not drawn by hand; it is what the three numbers currently mean.
Loss is the only thing training minimises. It falls fast at first, then flattens — the model is getting the easy examples right and grinding on the hard ones. A flat curve is not failure; it is “this model has learned what it can”.
One repeat = one pass through the data = one update. Real systems do this millions of times. Nothing accumulates except the numbers — which is why training can stop and resume without losing the model.
The classifier you just trained has exactly three adjustable numbers: two weights and a bias. That is the entire “brain”. It works because the problem is simple — not because the maths is deep.
The neuron does one thing: it multiplies each input by a weight, adds them up, adds a bias, and squashes the result into a probability.
A weight says how much an input matters and in which direction. A negative weight flips the evidence. A bias shifts the whole decision, which is how a model can be biased toward saying yes even when the inputs are weak.
A modern network is this same unit repeated in layers — millions or billions of weights. No layer does anything a single neuron cannot do; there are just enough of them, wired together, to represent extremely complicated boundaries. Gradient descent still trains every one of those numbers the same way it trained the three in the lab above.
What the numbers cannot do: they cannot know anything the data did not contain, and they cannot tell you when they are guessing. A confident output is still just a number between 0 and 1.
A model can get every training example right and still be useless, because it learned the noise instead of the pattern. This is overfitting — the most important failure in machine learning, and the one that looks most like success.
Underfitting — the model is too simple to represent the pattern. Training error is high, test error is high, and more data will not save it. The fix is a more flexible model or better inputs.
Overfitting — the model is flexible enough to memorise each training point, including the noise. Training error falls toward zero while test error climbs. The fix is more data, a simpler model, or stopping early.
The gap between training and test performance is the honest measure. A model that scores 99% on data it has seen and 61% on data it has not has learned almost nothing useful.
Hold data back. Split examples into train and test before you touch anything. The test set is the exam; peeking at it turns the exam into more training.
Punish complexity. Add a cost for large weights (regularisation) so the model prefers a smooth answer unless the data really demands a wiggle.
Stop early. Watch the validation error while training. When it starts rising, the useful learning is over — even though the training loss is still falling.
Supervised learning needs labelled examples. Reinforcement learning gets only a reward — and has to work out which of its many actions earned it. This agent starts moving at random. Every episode is a repeat; over repeats, it finds the short path.
Nobody says “go right, then up”. The environment only says +1 at the goal and −0.02 per step. The agent’s job is to maximise the total, which quietly implies “get there fast”.
It has to keep trying random moves (exploration) while using what it already knows (exploitation). Stop exploring too early and it locks into a mediocre route forever.
The reward arrives at the end. Which of the forty moves deserves the credit? Q-learning answers by backing the value up one step at a time — repeat enough times and the whole path becomes valuable.
The loop is always the same. What changes is what the model is given: the answer, no answer, or a score.
Every example comes with the label you want. The model compares its guess to the truth and adjusts. This is the workhorse of industry.
Needs: labelled data, which is expensive and sometimes impossible.
Fails when: the labels are wrong, or the world shifts under it.
No labels at all. The model looks for grouping, compression or oddity in the data. You judge the result, because there is no answer key.
Needs: a good notion of “similar”.
Fails when: the clusters it finds are real but meaningless to you.
An agent acts, the world responds, and a reward arrives — often delayed. It learns a policy: what to do in each situation.
Needs: a simulator or a very safe real world.
Fails when: the reward can be gamed — the agent will game it.
And a fourth, hiding in plain sight. Large language models are trained mostly self-supervised: take real text, hide the next word, and let the model predict it. The label is free because it was already in the sentence. Do that across enough text and the model is forced to absorb grammar, facts and style as a side effect of getting the next token right.
The loop explains the mechanism. It does not make the output trustworthy. These are the limits worth carrying away.
When you chat with an AI, it is doing the same thing as the classifier above: given everything so far, produce the most plausible next piece of text. It was trained on an enormous amount of writing and adjusted until its predictions were good.
That is genuinely useful, and it is also why it can be fluently wrong. A plausible sentence and a true sentence are not the same target. Nothing in the loop checks facts — only whether the next token was likely.
A model inherits the gaps and biases of its examples. Train on hiring decisions that favoured one group and the model learns to repeat them — with the authority of arithmetic. Train on scraped text and it absorbs whatever that text assumed.
“The model decided” is never a full explanation. Ask what it was trained on, what it was optimised for, and who checked.
What was the training data? Whose behaviour is being reproduced, and who is missing from the examples?
What is the loss? Whatever the number rewards is what the model will get good at — including shortcuts you did not intend.
How was it tested? On data it had never seen? On people like the people it will be used on? Compared against what baseline?
If you can answer these, you understand more about machine learning than most of the marketing does.
Ready when you are.
Answer in any order you like. Every answer gets an explanation, right or wrong.
Fifteen terms that cover most conversations about machine learning.
A function with adjustable numbers that turns inputs into a prediction. Nothing more mystical than that.
A number saying how strongly one input affects the output, and in which direction. Training changes weights.
An extra adjustable number added to the weighted sum. It shifts the decision threshold, not the model’s fairness — that is a different, also important, kind of bias.
One measurable input: a pixel, a word count, a temperature. Good features make hard problems easy; bad ones hide the pattern.
The answer attached to a training example — “spam”, “cat”, “£410,000”. Only supervised learning needs them.
A single number measuring how wrong the model is. Training’s only goal is to reduce it. Choosing the loss chooses what the model cares about.
The direction and steepness of the loss with respect to each weight. Following it downhill is gradient descent.
How far each update moves the weights. Too small and training crawls; too large and it overshoots and can diverge. Try 6.0 in the first demo.
One full pass over the training data — one “repeat”. The counter in the first demo.
Learning the training examples, including their noise, so well that performance on new data gets worse.
Doing well on examples the model has never seen. The only result that matters in practice.
Using a trained model to make a prediction. No learning happens here — the numbers are frozen.
Learning with answers versus learning without them, from structure alone.
Learning a policy from rewards and consequences rather than labelled examples.
A chunk of text — roughly a word-piece — that a language model predicts one at a time. “Predict the next token” is the whole training task.