What Does a Model Actually Learn?

1. A Model Starts With Almost Nothing

Consider a simple model that predicts house prices.

We give it information such as:

• • area
• • number of bedrooms
• • location
• • age of the house

and ask it to predict:

Initially, the model's parameters are usually not useful.

For a linear model:

the weights $w$ and bias $b$ might begin as small random values.

The model therefore starts with a particular mathematical behavior.

Then we show it an example:

The model predicts something else.

Maybe ₹43 lakh.

There is an error.

That error is converted into a numerical signal, and the parameters are adjusted so that the model becomes slightly better at producing the desired output.

Then another example.

And another.

And another.

Millions of parameter updates later, the model behaves very differently from where it started.

That change is what we call learning.

2. Learning Is Not the Same as Memorizing

This distinction is extremely important.

Suppose we train a model to distinguish cats from dogs.

It sees:

Image 1 → Cat
Image 2 → Dog
Image 3 → Cat
Image 4 → Dog
...

What do we want it to learn?

Not:

Image 1 = Cat
Image 2 = Dog
Image 3 = Cat

That would just be memorization.

We want it to discover some structure that allows it to make predictions about images it has never seen before.

Perhaps it learns representations related to:

• • edges
• • textures
• • shapes
• • spatial arrangements
• • ears
• • eyes
• • fur patterns
• • overall structure

But there is an important catch.

We cannot simply open the model and point to one parameter and say:

“This parameter represents a cat.”

The knowledge is distributed.

The model's behavior emerges from interactions between many parameters and representations.

3. So What Is Actually Changing?

Let's look inside a neural network.

A simplified layer can be represented as:

followed by some nonlinear transformation:

During training, the model changes $W$ and $b$.

That's it.

There isn't a tiny database inside the network containing:

cat → animal
Paris → France
2 + 2 → 4

Instead, information becomes encoded into numerical parameters and the relationships between them.

The model gradually develops a mathematical transformation that maps inputs to useful outputs.

So when we say:

“The model learned cats.”

a more precise statement would be:

“The optimization process changed the model's parameters so that its internal representations and output behavior became useful for distinguishing patterns associated with cats.”

Less catchy.

Much more accurate.

4. The Loss Function Defines What “Learning” Means

Here's one of the deepest ideas in machine learning:

A model doesn't decide what to learn.

The training objective determines what behavior gets rewarded.

Suppose we're training a model to predict house prices.

We could use mean squared error:

The model doesn't understand that houses are physical objects.

It doesn't understand money.

It doesn't understand real estate.

It only receives a numerical signal telling it:

“Your prediction was this far from the target.”

Optimization then tries to reduce that number.

This means that what a model learns is deeply connected to the objective we give it.

Change the objective, and you can change what the model considers useful.

5. Gradient Descent: How Learning Happens

Suppose the model has parameters:

and a loss function:

Training repeatedly updates the parameters:

where:

• • $\theta$ = model parameters
• • $\eta$ = learning rate
• • $\nabla_\theta L$ = gradient of the loss with respect to the parameters

The gradient tells us approximately:

“If you change this parameter in this direction, the loss will increase or decrease.”

The optimizer uses that information to move the parameters toward regions producing lower loss.

Repeat this enough times and the model's behavior changes.

That is the machinery underneath the word learning.

6. But Where Does the Knowledge Go?

This is where things become interesting.

Imagine a large language model.

It processes enormous amounts of text.

After training, we might ask:

“What is the capital of France?”

and it can produce:

Paris.

Where is “Paris” stored?

Not necessarily in one location.

The information is encoded across a huge collection of parameters and internal representations.

A useful mental model is to think of the network as constructing a complicated energy landscape.

Different parameter configurations produce different behaviors.

Training reshapes that landscape.

Patterns that repeatedly help minimize the objective become embedded into the model's numerical structure.

The model isn't necessarily storing a sentence.

It is learning a transformation that makes certain outputs more likely given certain inputs.

7. Models Learn Relationships

This becomes especially visible in language models.

Consider:

The cat sat on the ___.

A model might assign high probability to:

mat
floor
chair
...

What has it learned?

Not simply:

cat → mat

It has learned statistical relationships among many pieces of language.

Words interact with:

• • surrounding words
• • syntax
• • semantics
• • context
• • writing patterns
• • concepts
• • other learned representations

The model therefore develops a high-dimensional representation of relationships.

This is one reason modern models can produce behavior that wasn't explicitly programmed.

The rules were not individually written.

They emerged from optimization over enormous numbers of examples.

8. Features Are Not Always Human-Readable

Here's another surprising part.

We often imagine a neural network like this:

Neuron 1 → detects ears
Neuron 2 → detects eyes
Neuron 3 → detects fur
Neuron 4 → detects cats

Reality is usually much messier.

Representations can be:

• • distributed
• • overlapping
• • hierarchical
• • context-dependent
• • highly entangled

A single feature may participate in many behaviors.

A single concept may also be represented across many dimensions.

This makes neural networks difficult to interpret.

We can inspect the numbers.

But understanding what those numbers mean can be much harder.

9. Learning Happens at Different Levels

A model can learn increasingly abstract structure.

Imagine a vision model.

Early layers might become sensitive to relatively simple visual patterns:

edges
↓
textures
↓
shapes
↓
parts
↓
objects

The exact interpretation depends on the architecture and training setup, but the general idea is powerful:

Language models exhibit their own hierarchy of representations.

They may capture patterns involving:

characters / tokens
        ↓
local patterns
        ↓
syntax
        ↓
semantic relationships
        ↓
longer-range structure
        ↓
task-relevant representations

The model isn't necessarily explicitly constructing these concepts one by one.

They emerge as useful internal structure under the training objective.

10. The Dataset Shapes the Mind of the Model

If parameters are the model's machinery, the dataset is one of the strongest forces shaping what that machinery becomes.

Consider two models with identical architectures.

Train one on:

scientific papers

and another on:

movie scripts

Even with the same architecture, they will develop different statistical structures.

The training distribution matters.

So does:

• • data quality
• • data quantity
• • labels
• • preprocessing
• • sampling
• • augmentation
• • objective
• • optimization
• • architecture

A model can only learn patterns that are sufficiently represented in the information and training signal available to it.

11. A Model Can Learn the Wrong Thing

This is where machine learning becomes dangerous—and fascinating.

Suppose we want a model to detect wolves.

Our dataset contains:

Wolf → snowy background
Wolf → snowy background
Wolf → snowy background
Wolf → snowy background
 
Dog → grass
Dog → grass
Dog → grass
Dog → grass

The model might discover:

Snow → Wolf

instead of:

Wolf → Wolf

It achieved a useful training objective by exploiting a shortcut.

From the model's perspective, there was no mistake.

The dataset allowed the shortcut.

This phenomenon is often called spurious correlation.

The model learns whatever statistical structure helps satisfy its objective—not necessarily the concept we intended.

12. Then What Does “Understanding” Mean?

This is where terminology gets philosophical.

If a model can translate a sentence, write code, solve equations, or describe an image, does it understand those things?

There isn't a single universally accepted answer.

From an engineering perspective, we can make a narrower statement:

A model has learned an internal computational structure that allows it to perform certain tasks and generalize to some previously unseen inputs.

Whether that deserves the word understanding depends on what definition of understanding we choose.

And that's an important distinction.

13. Generalization Is the Real Test

Suppose we train a model on:

2 + 2 = 4
3 + 3 = 6
4 + 4 = 8
...

If we ask:

7 + 7 = ?

and it answers correctly, something useful has happened.

The model has produced a correct output for an example that wasn't necessarily present during training.

That's generalization.

But generalization has limits.

A model can perform brilliantly on familiar distributions and fail dramatically when the distribution changes.

This is why:

“Low training error does not automatically mean useful learning.”

A model can memorize.

A model can exploit shortcuts.

A model can overfit.

A model can learn representations that work only within a narrow distribution.

Learning therefore isn't simply:

The deeper goal is:

14. The Strange Part: We Don't Program the Final Behavior

Traditional software often looks like:

if condition:
    do X
else:
    do Y

Machine learning reverses much of this process.

Instead of explicitly writing every rule, we specify:

data
+
objective
+
optimization

and allow the model to discover parameters that produce useful behavior.

We specify the learning process.

The final internal representation is largely discovered through optimization.

This is one of the fundamental shifts from traditional programming to machine learning.

15. So What Does a Model Actually Learn?

We can now answer the original question.

A machine-learning model learns parameters and internal representations that encode statistical structure useful for minimizing its training objective.

Those structures can correspond to things such as:

• • correlations
• • features
• • relationships
• • transformations
• • patterns
• • representations
• • decision boundaries
• • hierarchical structure

But the model does not necessarily learn the human concept we intended.

It learns what the combination of:

makes useful.

And that distinction explains a huge amount of modern machine learning.

16. The Most Important Mental Model

Perhaps the best way to think about learning is this:

That is a subtle difference.

A trained model isn't simply a database of everything it has seen.

It is a transformed computational system.

The training process takes:

initial parameters
        ↓
examples
        ↓
predictions
        ↓
error
        ↓
gradients
        ↓
parameter updates
        ↓
new representations
        ↓
new behavior

Repeat this enormous numbers of times.

Eventually, something interesting emerges:

the model becomes capable of doing things it couldn't reliably do before.

We call that learning.