Parameters and Model Capacity
Parameters are the learned numbers that training changes. They are the thing being updated, not the data being read.
Learning Without an Answer Sheet
Most machine learning systems are trained on examples that someone has already marked with the correct answer. A photo labeled as a cat, or a review labeled as positive, gives the learner something specific to aim for. Preparing those labels takes effort, and that effort limits how much training data can be collected.
Language models follow a different path. They learn from ordinary text sequences, and no one has to attach a label to each one. This article follows that idea from the ground up. We will look at where the training text comes from, how the size of a model is counted, why that count matters, and why a bigger model changes how much data it needs. Along the way we will see that the word large is a moving target.
The reason this matters is availability. Text sequences are everywhere: books, blog posts, articles, and Reddit comments. Because the raw material is so plentiful and needs no labeling step, it is possible to assemble a very large training set. Scale in the training data is what allows a language model to grow into what we call an LLM.
Following One Sentence Through Training
The central question is how a plain sentence can become training examples when nobody annotated it. The answer is that the text itself supplies the target. Take a sentence and slide along it: at each position, the words seen so far are the input, and the word that comes next is the target the model should learn to predict. No human had to write that target down. It is already sitting in the sentence.
Turning one sentence into training pairs
Derive the input and target pairs from the sentence: The cat sat on the mat.
- 1Step 1: Read the first word
The word The is the input. The word that follows it, cat, is the target.
- 2Step 2: Slide forward one position
Now the input is The cat and the target is sat. The text grows with each step, and the next word is always the target.
- 3Step 3: Continue to the end
The pairs continue through on to the and the to mat. The final word mat has no word after it in this sentence, so it serves only as a target.
- 4Step 4: Check that no human labeled anything
Every target was already present in the sentence. The source's key point is that the labels come for free from the text.
Five input-target pairs came from a single sentence, and none of them required a person to mark an answer.
What a Parameter Is
A parameter is a variable within an ML model that is updated through the training process. Each time training runs, these variables change, and the final values are what the trained model uses.
A parameter is therefore not something you type in before training. It starts with some value, and training adjusts it again and again as the model sees text. When training finishes, the collection of settled values is the model. Using the trained model means reading those fixed values and applying them to new input.
Parameters are the learned numbers that training changes. They are the thing being updated, not the data being read.
Counting Model Size and Capacity
Before asking how large a language model is, we need a way to measure size. A model's size is typically measured by its number of parameters. Counting parameters gives a single number that describes how much the model has to adjust during training.
Parameters matter because they set how much a model can absorb. In general, a model with more parameters has a greater capacity to learn the behaviors we want. Capacity is the room a model has to learn; a model with more parameters has more room.
Why the Word Large Keeps Moving
The source gives a concrete history that shows how quickly the idea of a large model has shifted. Each point on the timeline below records a model and its parameter count at the time it appeared, following the milestones the source mentions.
The lesson is that large describes a moving reference point, not a fixed size. The same 117 million parameters that counted as large in 2018 was downgraded to small once GPT-2 arrived with 1.5 billion. Any label of large should therefore be read against the models that exist at the time.
Why Bigger Models Need More Text
The source raises a question that is usually taken for granted: why do larger models need more data? Its answer starts with capacity. Larger models have more capacity to learn, and that extra capacity only pays off when there is enough training data to fill it.
Think of a student with a large memory and only a few pages to read. The memory is ready to hold far more than those pages contain, so most of its capacity goes unused. A bigger memory helps only when there is more material to store.
The right-hand column is not a separate rule about one particular model. It follows directly from capacity. The more a model can learn, the more material it needs in order to reach its best performance. When a large model is trained on a small dataset, the training effort is spent without the capacity being put to full use, which is why the source describes the result as wasted compute.
Common Mistakes About Size and Data
Common mistake Assuming more parameters always means a better model
What it looks likeConcluding that any model with more parameters will outperform any model with fewer.
Why it failsThe source says that more parameters generally means greater capacity, but not always.
Do this insteadTreat parameter count as a useful tendency and remember it is a guide, not a guarantee.
Common mistake Treating large as a fixed size
What it looks likeCalling 117 million parameters large without noting when that judgment was made.
Why it failsThe source shows that 117 million was considered large in 2018 and small after GPT-2.
Do this insteadRead large as relative to the models available at the time.
Common mistake Believing self-supervised learning requires labels
What it looks likeAssuming someone must mark the correct next word in every sentence before training can start.
Why it failsThe text sequences supply the learning signal, and no one has to attach a label to each one.
Do this insteadRecognize that the training target can be drawn directly from the raw text.
Common mistake Assuming a bigger model needs no more data
What it looks likeTraining a very large model on a small collection of text and expecting it to reach its best performance.
Why it failsLarger models need more training data to maximize their performance, and training a large model on a small dataset wastes compute.
Do this insteadMatch the amount of training text to the model's capacity.
Predict Before You Read
What do you think happens?
A model with a very large parameter count is trained on only a small amount of text. What do you think happens?
Reveal answer
Its extra capacity has little to learn from, and training compute is wasted.
Larger models have more capacity, and that capacity only pays off when there is enough training data to fill it. Training a large model on a small dataset wastes compute. The parameter count is set by the model and is not reduced by the amount of text.
Take the sentence The dog chased the ball. Write out every input-target pair you could derive from it using only the sentence itself, with no labels added by hand. Then explain in one sentence where each target came from.
Hints
- Start with the first word as the input and the second word as the target.
- Each target is the word that immediately follows the input in the sentence.
- Stop when you reach the last word, which has no word after it to serve as a target.
How the Pieces Fit Together
- 1Text sequences from books, blog posts, articles, and Reddit comments supply training material without any labeling step.
- 2Self-supervised learning uses the text itself to provide the target at each position, so the model learns without an answer sheet.
- 3A model's size is typically measured by its number of parameters, which are variables updated during training.
- 4More parameters generally means greater capacity to learn, though not always.
- 5The label large shifts as newer models appear, so it always describes a moving reference point.
- 6Larger models need more training data to use their capacity; training a large model on a small dataset wastes compute.
Key Takeaways
- Self-supervised learning lets a language model train on raw text sequences because the text itself supplies each target, so no one has to attach a label.
- A parameter is a variable updated during training, and a model's size is typically measured by its number of parameters.
- More parameters generally means greater capacity to learn, but this is a tendency rather than a guarantee.
- The word large is relative: 117 million parameters was large in 2018 and small after GPT-2's 1.5 billion parameters.
- Larger models need more training data to maximize their performance, and training a large model on a small dataset wastes compute.