Training

One loop is four steps

Training repeats the same four steps over and over. First, feed it one example and get an answer out of it. Second, measure how far that answer is from the correct one as a single number. Third, work out which dial should turn which way to bring that number down. Fourth, turn it that way by a tiny amount.

Then it moves to the next example and runs the same four steps again. On a bike, that's the same as riding, feeling how much you leaned, knowing which way to correct, and correcting a little.

This one loop runs millions, even billions of times. What changes in a single loop is too small to even notice, but that tiny change piles up until what once said anything at all starts producing a reasonably plausible answer.

Why the correction stays small

There's a real reason you never correct by a large amount at once: the one example you just looked at doesn't represent everything. Swing hard in a new direction because of one strange example, and everything built up so far gets thrown out of balance all at once — the same as jerking the handlebars hard after leaning right and falling the other way instead.

So the size of each step gets set very small on purpose. This step size is called the learning rate. Too large, and it wobbles back and forth around the right answer without ever settling; too small, and it never arrives at all. Finding the right size is one of the important jobs for whoever is running the training.

Looking at several examples bundled together, instead of one at a time, is common too. Averaging over a bundle keeps a single strange example from throwing the direction off, which steadies the whole walk.

The size of the gap gets measured as a single number

For training to run at all, it needs to know, as a number, how wrong things currently are. The ruler used to measure that gap is called the loss function. Match the correct answer exactly and it sits near zero; drift further away and it grows.

Training has exactly one goal: shrink that number. There's no instruction anywhere that says "draw well" or "speak well." A person's job stops at deciding what to use as the ruler — everything after that flows on its own toward shrinking that number.

Which is exactly why picking the wrong ruler sends things somewhere strange. On a bike, measuring only "did you avoid falling" teaches it to just stand still. This exact kind of accident happens surprisingly often in real training.

Training longer doesn't keep helping forever

Keep training running, and the loss keeps shrinking. But past a certain point, something strange starts happening. It keeps getting better and better at the examples it trained on, while somehow getting worse on examples it's never seen. Instead of finding the rule, it started memorizing what it saw. This state is called overfitting.

So a separate set of examples gets held back from training and checked periodically. The moment that score stops improving and turns the other way, training gets stopped. It's similar to how looping the same street after you've already stopped falling doesn't build skill — you have to actually go somewhere new for that.

Once training ends, a model is left behind

The moment training stops, the dials freeze exactly where they are. That one frozen set of values, saved, is the model. Training is the name for the process; the model is what that process leaves behind.

A frozen model doesn't keep growing on its own. While a service is producing an answer, no training is happening. It's the same as barely learning anything new while riding a bike you already know how to ride. Changing what it can do means running training all over again — though there's also a separate approach where a finished model gets fed a little more new data just to shift its character.