Concepts / Parameters and Model Capacity

Parameters and Model Capacity

Parameters are the learned numbers that training changes. They are the thing being updated, not the data being read.

  • Programming

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.

Thepredicts: catcatpredicts: satsatpredicts: ononpredicts: thethepredicts: matmatfinal word, no next wordnext positionnext positionnext positionnext positionnext position
For the sentence The cat sat on the mat, each position pairs the word read so far with the word that follows it. The labels come from the text itself, so no one annotated them.
Worked example

Turning one sentence into training pairs

Derive the input and target pairs from the sentence: The cat sat on the mat.

  1. 1
    Step 1: Read the first word

    The word The is the input. The word that follows it, cat, is the target.

  2. 2
    Step 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.

  3. 3
    Step 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.

  4. 4
    Step 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.

Result

Five input-target pairs came from a single sentence, and none of them required a person to mark an answer.

What a Parameter Is

Definition

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.

Key point

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.

2018117 million parameters:largeGPT-21.5 billion parametersAfter GPT-2117 million parameters:smallTime of writing100 billion parameters:largethenthenlater
The same parameter count changes category as newer models appear. A figure that was large in 2018 was later downgraded to small, and what is large at the time of writing may one day be small too.

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.

In the real world

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.

Lower capacityless room to learnHigher capacitymore room to learnModest data needsless text to fill itLarger data needsmore text to maximizeperformanceWasted computewhen trained on a smalldatasetrequiresif data is small
A larger model has more capacity, so it needs more training data to reach its best performance. Training a large model on a small dataset wastes compute.

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 like

    Concluding that any model with more parameters will outperform any model with fewer.

    Why it fails

    The source says that more parameters generally means greater capacity, but not always.

    Do this instead

    Treat 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 like

    Calling 117 million parameters large without noting when that judgment was made.

    Why it fails

    The source shows that 117 million was considered large in 2018 and small after GPT-2.

    Do this instead

    Read large as relative to the models available at the time.

  • Common mistake

    Believing self-supervised learning requires labels

    What it looks like

    Assuming someone must mark the correct next word in every sentence before training can start.

    Why it fails

    The text sequences supply the learning signal, and no one has to attach a label to each one.

    Do this instead

    Recognize 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 like

    Training a very large model on a small collection of text and expecting it to reach its best performance.

    Why it fails

    Larger models need more training data to maximize their performance, and training a large model on a small dataset wastes compute.

    Do this instead

    Match 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?

  • It learns faster than a smaller model and reaches its best performance early.

  • Its extra capacity has little to learn from, and training compute is wasted.

  • The parameter count shrinks to match the amount of text.

Reveal answer
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.

EASY

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

  1. 1
    Text sequences from books, blog posts, articles, and Reddit comments supply training material without any labeling step.
  2. 2
    Self-supervised learning uses the text itself to provide the target at each position, so the model learns without an answer sheet.
  3. 3
    A model's size is typically measured by its number of parameters, which are variables updated during training.
  4. 4
    More parameters generally means greater capacity to learn, though not always.
  5. 5
    The label large shifts as newer models appear, so it always describes a moving reference point.
  6. 6
    Larger 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.

Related concepts

More concepts starting with P