How Machines Learn

Why this matters

Every modern AI system, from a spam filter to a chatbot, was made the same basic way: by showing a program many examples and letting it adjust itself until its answers improve. Once you understand that loop, a lot of AI behaviour, good and bad, stops being mysterious.

Data and features

Machine learning starts with data: a collection of examples. For a house-price predictor, each example is one house sold in the past.

A feature is a measurable property of an example that the model can use, such as floor area, number of bedrooms, or postcode. The thing we want to predict, here the sale price, is called the label or target.

In older machine learning, people chose features by hand. In deep learning, the model largely discovers useful features on its own from raw data such as pixels or text.

Training vs inference

There are two distinct phases in a model's life:

• Training is the learning phase. The model sees examples, makes guesses, measures how wrong they are, and adjusts itself. For large models this takes enormous amounts of computing power and can run for weeks.
• Inference is the using phase. The trained model is frozen and simply produces answers for new inputs. When you type into a chat assistant, you are running inference. The model is not learning from your conversation in that moment.

Neural networks and parameters

A neural network is a mathematical function built from layers of simple units, loosely inspired by brain cells. Each unit receives numbers from the previous layer, multiplies each by a weight (how much that input matters), adds them up, and passes the result through a simple rule to the next layer.

The weights, together with a few related numbers, are called the model's parameters. They are the settings that training adjusts. A small network might have thousands of parameters; large language models have billions. Everything a model "knows" is stored in these numbers, not as a list of facts but as a pattern spread across all of them.

Loss: measuring how wrong you are

To improve, the model needs a score for its mistakes. That score is the loss: a single number that is large when predictions are bad and small when they are good.

A worked example, deliberately simplified to a model with one parameter. Suppose we predict price as w times floor area, and we have three past sales:

Start with a guess of w = 150 dollars per square foot. Predictions are $150,000, $225,000 and $300,000, so the errors are $50,000, $75,000 and $100,000 too low, an average error of $75,000. Every prediction is too low, so w should go up. Try w = 180: errors shrink to $20,000, $30,000 and $40,000, average $30,000. Try w = 200: every prediction is exact and the loss is zero.

Real models do exactly this, but with billions of parameters at once, so they need an automatic way to know which direction to move each one.

Gradient descent: walking downhill in fog

Picture yourself on a hillside in thick fog, trying to reach the valley floor. You can't see the valley, but you can feel which way the ground slopes under your feet. So you take a small step downhill, feel again, and take another step. Eventually you reach low ground.

That is gradient descent. The height of the land is the loss. Your position is the current set of parameters. The gradient is the slope: it tells the model, for every parameter, which direction would reduce the loss and how steeply. The learning rate is your step size: too big and you overshoot the valley; too small and you take forever.

A method called backpropagation calculates the gradient efficiently for every parameter in a network by working backwards from the error at the output. Training is simply this loop repeated millions of times: predict, measure loss, compute gradient, nudge parameters.

One honest caveat: the real landscape has billions of dimensions and many dips, and the model usually ends up in a good low spot rather than the single lowest one. In practice that is usually good enough.

Overfitting: memorising instead of learning

A model can get very good at its training data without learning anything general. Imagine a student who memorises last year's exam answers: perfect on that paper, lost on a new one. That is overfitting.

To catch it, practitioners hold back some data the model never trains on, often called a test set, and check performance there. If the model scores well on training data but poorly on the test set, it has overfitted. Remedies include more varied data, smaller or simpler models, and stopping training earlier.

Why data quality matters

A model can only learn patterns that are present in its data. If the examples are wrong, out of date, or unrepresentative, the model learns those flaws faithfully. A skin-condition classifier trained mostly on light skin tends to perform worse on darker skin. A chatbot trained on text full of a common misconception will repeat it. "Garbage in, garbage out" is a long-standing rule in computing, and it applies with full force here.

Three styles of learning

Large language models mix these. Their main training predicts the next piece of text, a form often called self-supervised learning because the labels come from the data itself. Later stages use human-labelled examples and reinforcement learning, which the next lesson explains.

Going deeper

This section redoes the house-price example with the actual formulas that training uses. To keep the numbers readable, measure floor area $x$ in thousands of square feet and price $y$ in thousands of dollars, so the three houses become $x = (1, 1.5, 2)$ and $y = (200, 300, 400)$. The model is $\hat{y} = w x$, where $\hat{y}$ ("y-hat") is the prediction and $w$ is the single parameter.

The loss as a formula

The earlier walkthrough used the average size of the errors. Most regression models instead use the mean squared error (MSE):

$L(w) = \frac{1}{n} \sum_{i=1}^{n} \left( w x_i - y_i \right)^2$

where $n = 3$ is the number of examples and $w x_i - y_i$ is the error (the residual) on example $i$. Squaring does two useful things: it makes every error count as positive, and it punishes large errors much more than small ones. It also gives a smooth curve, which makes the slope easy to compute.

At $w = 150$ the residuals are $-50$, $-75$ and $-100$, so

$L(150) = \frac{2500 + 5625 + 10000}{3} = 6041.67$

Deriving the gradient

The slope of the loss with respect to $w$ comes from ordinary calculus (the chain rule):

$\frac{dL}{dw} = \frac{2}{n} \sum_{i=1}^{n} x_i \left( w x_i - y_i \right)$

At $w = 150$: $1 \times (-50) + 1.5 \times (-75) + 2 \times (-100) = -50 - 112.5 - 200 = -362.5$, and $\tfrac{2}{3} \times (-362.5) = -241.67$. The slope is negative, which means increasing $w$ lowers the loss, exactly what the intuition said.

Gradient descent moves against the slope by a step of size $\eta$ (the learning rate):

$w \leftarrow w - \eta \, \frac{dL}{dw}$

With $\eta = 0.1$: $w = 150 - 0.1 \times (-241.67) = 174.17$. Repeating:

The parameter closes in on 200 and the loss heads to zero.

How big a step is safe?

For this model we can see exactly what the learning rate does. Expanding the gradient with $\sum x_i^2 = 7.25$ and $\sum x_i y_i = 1450$ gives

$\frac{dL}{dw} = \frac{2}{3}\left(7.25\,w - 1450\right) \approx 4.833\,(w - 200)$

So the distance from the best value, $e = w - 200$, changes each step by a fixed factor: $e \leftarrow (1 - 4.833\,\eta)\, e$. Training converges only if that factor lies between $-1$ and $1$, which means $0 < \eta < 2 / 4.833 \approx 0.41$. With $\eta = 0.1$ the factor is $0.52$, so the error roughly halves each step (as in the table). With $\eta = 0.5$ the factor is $-1.42$: the parameter overshoots, lands further away on the other side, and the loss explodes. Large networks have no tidy formula like this, but the same thing happens: a learning rate that is too large makes the loss jump around or blow up, and one that is too small makes progress painfully slow.

Many parameters at once

A real network has a vector of parameters $\theta$ (theta), and the gradient $\nabla L(\theta)$ is the vector of slopes, one per parameter. The update has the same shape: $\theta \leftarrow \theta - \eta \, \nabla L(\theta)$. Computing the loss over the whole dataset at every step would be far too slow, so training uses stochastic gradient descent: estimate the gradient from a small random mini-batch of examples, take a step, draw another batch. The estimate is noisy but cheap. Backpropagation computes every entry of the gradient at a cost of a small constant multiple of one forward pass through the network, which is what makes models with billions of parameters trainable at all.

The same loop in Python

import numpy as np
x = np.array([1.0, 1.5, 2.0])      # floor area, thousands of sq ft
y = np.array([200., 300., 400.])   # price, thousands of dollars
w, lr = 150.0, 0.1
for step in range(1, 11):
    pred = w * x
    loss = np.mean((pred - y) ** 2)          # mean squared error
    grad = np.mean(2 * x * (pred - y))       # dL/dw
    w = w - lr * grad
    print(f"step {step:2d}  loss {loss:9.2f}  new w {w:8.3f}")

Each pass computes predictions, the MSE loss, the gradient and the update. The printed numbers match the table above, and after 10 steps $w$ is 199.93. Try changing lr to 0.5 to watch it diverge.

Measuring generalisation properly

Practitioners usually split data three ways. The training set is used to fit parameters. The validation set is used to make choices such as the learning rate, the model size or when to stop. The test set is touched once, at the end, to estimate performance on new data. If you make choices by looking at the test set, it quietly becomes part of training and your final score will be too optimistic. The difference between test loss and training loss is the generalisation gap; a large gap is the numerical signature of overfitting.

Common pitfalls

• Data leakage. Information from outside the training data slips in: duplicate records shared between training and test sets, a feature that is only known after the outcome, or scaling the data using statistics from the full dataset. Scores look excellent and collapse in real use.
• Tuning on the test set. Every decision made by looking at test results makes them less trustworthy. Use a validation set for choices.
• Never looking at the loss curve. A learning rate that is too high shows up as a jumpy or exploding loss; too low shows up as a nearly flat line.
• Unscaled features. If one feature is in millions and another in single digits, gradient descent zigzags and converges slowly. Standardising features is routine.
• Trusting accuracy on unbalanced data. If 99% of transactions are legitimate, a model that always says "legitimate" is 99% accurate and useless.
• Assuming bigger is always better. More parameters can fit noise; size must be matched to data and checked on validation data.

In practice

• When an AI tool behaves oddly, ask what data it was likely trained on; gaps and biases there usually explain the behaviour.
• Remember that chatting with a model is inference: it is not learning from you in real time unless the product explicitly stores and reuses your data.
• Be wary of any system evaluated only on the data it was trained on. Ask how it performs on new, unseen examples.