The material was prepared last time
In the previous installment a vast body of text was turned into tokens. Now actual training begins with those tokens.
The goal is unchanged: build a machine that predicts what follows a fragment like 'our lunch menu is.' This installment looks at how that machine comes to guess correctly.
The conclusion first: learning is repetition of getting it wrong and correcting. Nothing more. It is only the number of repetitions and the count of things being corrected that escape human intuition.
The guessing game — hide the answer and ask
Training data is data whose answer is already known. There is a trick here: the text itself carries the answer.
If the corpus contains a sentence ending in a particular word, hide that final token and ask the network. Show only what precedes it and ask what comes next. The answer is already in hand, so grading is instant.
What matters is that no human has to label anything. Every piece of text on the internet becomes a problem set on its own. Move the cut point and one sentence yields countless problems. That is why training material is effectively unlimited.
At first everything is wrong
A network at the start of training knows nothing. Asked what belongs in the hidden slot, it produces a probability ranking over every token in the vocabulary — and that ranking is nonsense.
The scale is worth feeling. Counting the vocabularies directly: p50k_base holds 50,281 entries, cl100k_base 100,277, o200k_base 200,019. So the network is ranking a candidate list two hundred thousand long, every single time.
Early on it will put something absurd in first place. It is no different from someone who does not speak the language opening a dictionary and pointing at random.
But the answer is known. So grading is possible, and because grading is possible, correction is possible.
Correct backward, in proportion to the error
Once graded, the question becomes: what should have been changed, and by how much, for the right answer to come out on top?
The computation that answers this is called backpropagation. The name is intimidating; the job is simple. The error is passed backward from the output side toward the input side, each setting's contribution to that error is worked out, and from that the direction and size of its correction are decided.
Crucially, it does not jump straight to the answer. Each step moves only a little. Moving far to satisfy one problem would break the other problems it had already been getting right.
So it corrects a little, gets it wrong again, corrects a little more. That repetition is training.
What gets corrected — the knobs on a DJ console
So what exactly is being corrected? Packed inside the network are numerical adjustment knobs. Picture the knobs on a DJ console.
Input arrives, computation flows through those values, and where the knobs sit determines the probability distribution that comes out. Training turns those knobs a little at a time, hunting for the arrangement that brings the right answer to the top.
These knobs are the parameters, and the value each knob is set to is a weight. That is why the two words travel together: a parameter is the slot, a weight is the value in it.
It is also why a trained deep learning model file so often ships under the name weights. The product of training is, in the end, that list of values. Downloading a model means downloading that bundle of weights.
What 7B and 70B are counting
The 7B or 70B beside a model name is the count of those knobs. B is billion. 7B means seven billion adjustable values inside the model; 70B means seventy billion.
Not having an intuition for that number is normal. Only the direction matters: more knobs allow finer adjustment and greater expressive range, at the cost of more computation.
The cost lands in two places. Once during training, and again when the finished model actually produces an answer. The second is the one you hit in practice.
On Hugging Face, model search has a filter on parameter count in the left rail. It looks like a quality filter but is closer to a hardware question: can the machine you have actually run this?
Why Large, specifically
The Large in Large Language Model is not a marketing adjective. It points at this parameter scale. And the growth in scale was closer to an observation than a design intention.
Neural networks are an old idea. Built small, they could produce grammatical sentences but nothing a person would take as a conversational partner. As compute grew cheaper, experiments at much larger scale became possible, and past a certain point the character of the output changed. Not incrementally better — it looked like a different kind of task being performed.
This structure of parameters and weights is not unique to LLMs. Image recognition, speech, nearly every deep learning model has the same shape. Only the material and the scale differ.
Where this commonly goes wrong
The confusion you meet most often in practice is the phrase 'let's train the LLM on our data.' What the person saying it actually wants is usually not training.
Training, as just described, means nudging tens of billions of parameters, and the resources and time involved are of a different order. Wanting internal documents reflected in answers is normally solved a different way.
The criteria for choosing which way come in the final installment of this series. For now hold on to one thing: training means changing values inside the model, and that does not happen casually.
Not yet a usable model
At this point there is a model with optimized weights. But it is not yet the model people use.
Exactly one thing has been trained: what token naturally comes next. It has never learned to answer a question, to follow an instruction, or to decline a dangerous request.
A model in this state is called a base model, and everything up to here is called pre-training. The next installment looks at why a base model cannot be shipped as-is, and what else has to happen before it becomes the chatbot we use.