What Does GPT
Actually Learn?

Two numbers can define a behavior

Imagine a tiny model that receives a number x and produces a prediction ŷ. Its complete behavior is controlled by a weight and a bias.

For x = 2, w = 0.5, and b = 1, the prediction is 2. Increase only the weight to 1.5, and the prediction becomes 4. The model’s behavior changed because one parameter changed.

Experiment 1 · Change the parameters

def tiny_model(x, w, b):
    return w * x + b

x = 2
experiments = [
    {"w": 0.5, "b": 1},
    {"w": 1.5, "b": 1},
    {"w": 1.5, "b": 3},
    {"w": -1.0, "b": 1},
]

for experiment in experiments:
    y_hat = tiny_model(x, experiment["w"], experiment["b"])
    print(experiment, "→", y_hat)

Turn “wrong” into a direction

Suppose the hidden rule is y = 2x + 1, and we observe five examples: (0,1), (1,3), (2,5), (3,7), and (4,9). Our model begins badly at w = −1 and b = 0.

First, measure how wrong it is with mean squared error:

Then calculate the slopes of that loss—its gradients—and take a small step in the opposite direction:

Experiment 2 · Train with gradient descent

import numpy as np

# Training data generated by y = 2x + 1
x = np.array([0, 1, 2, 3, 4], dtype=float)
y = np.array([1, 3, 5, 7, 9], dtype=float)

# Deliberately poor starting guess
w, b = -1.0, 0.0
learning_rate = 0.05

for epoch in range(200):
    y_hat = w * x + b
    error = y_hat - y
    loss = np.mean(error ** 2)

    # Gradients of mean squared error
    dw = 2 * np.mean(error * x)
    db = 2 * np.mean(error)

    # Gradient-descent update
    w -= learning_rate * dw
    b -= learning_rate * db

print(f"learned w={w:.3f}")
print(f"learned b={b:.3f}")
print(f"final loss={loss:.6f}")

GPT learns transformations, not sentences

A language model does not store a little dictionary of answers. It repeatedly transforms numerical representations, using learned matrices and biases.

Where do those learned matrices appear?

Inside a Transformer, parameters are distributed across several components. For example, attention creates query, key, and value representations:

Attention then uses those representations to decide which parts of the context should influence one another:

This is a much richer transformation than \(wx+b\), but the underlying theme is the same: learned numbers control how information is transformed and combined.

After the model produces a score z_i for every possible next token, softmax turns the scores into probabilities:

During language-model training, the correct next token acts as the target. A common training loss is cross-entropy; for the correct token \(y\), the essential term is:

Experiment 3 · A three-token softmax

import numpy as np

tokens = ["west", "east", "banana"]
logits = np.array([1.2, 3.8, 0.2])

shifted = logits - np.max(logits)  # numerical stability
probabilities = np.exp(shifted) / np.exp(shifted).sum()

for token, probability in zip(tokens, probabilities):
    print(f"{token:>6}: {probability:.3f}")

Scale the same principle

Modern language models contain many kinds of learned numbers: token embeddings, attention projections, feed-forward layers, normalization scales, and output weights. The count grows quickly because high-dimensional vectors are repeatedly transformed by large matrices across many layers.

Teaching simplification: the calculator below is intentionally simplified. A real Transformer also includes an attention output projection, many repeated layers, biases, normalization parameters, and architecture-specific choices such as tied or untied embedding/output weights.

vocabulary_size = 10_000
model_dimension = 128
feedforward_dimension = 512

embedding = vocabulary_size * model_dimension
attention = 3 * model_dimension * model_dimension
feedforward = (
    model_dimension * feedforward_dimension
    + feedforward_dimension * model_dimension
)
output = model_dimension * vocabulary_size

total = embedding + attention + feedforward + output
print(f"{total:,} parameters")  # 2,740,224