Training in Plain Words

Every few weeks Iris hears the same status update: "the delivery model is training overnight — numbers on Monday." She has been picturing something like study. The computer poring over Chapter 2's orders table, noticing things, growing wiser by the hour. So she finally asks a data scientist to describe one minute of what actually happens in there. The answer contains no wisdom at all.

Training is a loop — dumb and endlessly patient. Make a guess. Measure how wrong it was. Adjust the model's numbers a tiny step in whichever direction makes the wrongness smaller. Do it again, a few million times. That is the entire secret. This page walks the loop once, slowly, because the loop is machine learning: everything before it in this book was preparation, and everything after it is judgment about its results.

Guesspredict every order in the table

→

Measure the errorthe loss — the bill for error

→

Nudge the numberseach parameter, slightly

→

Repeatavg miss: 26 → 12 → 6 → 4 min

→

Trained modelnumbers frozen, ready to use

Start Stupid

Before training begins, the model from Topic 04 already exists as a file — but its parameters, the learned numbers, have not learned anything yet. They are set at random, the way you might spin every dial on an unfamiliar machine before reading the manual. Ask this newborn model about a three-kilometer dinner order and it might answer four minutes, or three hours. Its first guesses across the whole orders table are not merely bad; they are noise.

Here is the part beginners find hardest to accept: that does not matter. Random is a perfectly good starting point, because the loop never needs a good guess to begin — it only needs to know, for each guess, which direction is less wrong. The starting line can be anywhere. What training supplies is the direction of travel.

Measure the Miss

Which makes the second step the heart of the loop. Take one row of the orders table: the features say 3.2 kilometers, 7 p.m., Thai place; the label says the delivery actually took 38 minutes. The untrained model guesses 71. The gap — 33 minutes of wrong — is one miss. Now do the same for every row and combine all the misses into a single number. That number is the loss: one figure that says how wrong the model is, right now, across everything it has seen.

Think of the loss as the bill for error. Every miss adds to it, bigger misses add more, and the whole ambition of training is to drive the bill down. Hold on to that framing — it keeps paying rent. Overfitting (Topic 14), model tuning, even the way chatbots are made (Chapter 9) are all stories about a system working to shrink some bill.

Nudge and Repeat

Now the move that makes it learning. Take each parameter and change it slightly — in whichever direction makes the loss a little smaller. Then guess again with the new numbers, measure the new loss, nudge again. Each lap, the bill drops a bit. After thousands or millions of laps, guesses that began absurd land within a few minutes of the truth, the loss stops falling, and the loop ends. That entire process — guess, measure, nudge, repeat — is what the word "training" means. Nothing else happens overnight.

If you have ever tuned a guitar string by ear, you have run this exact loop yourself. Pluck the string, hear how far off the note is, turn the peg a little, pluck again. Nobody calculates the final peg position from physics — they iterate their way to it. The pluck is the guess, the off-ness is the loss, the peg is a parameter. And notice how tuning ends: not with the tuner understanding music, but with a string that sounds right. Training ends the same way — not with understanding, but with numbers that make the guesses come out close.

Why It Takes Computers

Notice what the loop never contains: no insight, no understanding, no moment where the model "gets it". Its error score goes down — that is the model's entire biography. Every individual step is arithmetic a patient twelve-year-old could do: compare two numbers, add up the misses, adjust a dial. What no human could survive is the scale. Thousands of rows, times every parameter in the file, times thousands of laps — for Plateful's modest delivery model, that is already billions of small calculations. For the giant models of Chapters 8 and 9, it is a number with no everyday name.

That scale is the honest answer to why training runs overnight, and why the field cares so much about special chips that happen to do exactly this kind of repetitive arithmetic very fast — Chapter 8 introduces them, once the models grow big enough to need them. And it explains the economics you met in Topic 04: training is the expensive event, done deliberately and rarely. "We trained it" never means "it studied". It means "we ran the loop until the bill stopped shrinking" — and then froze the result and put it to work.