Every AI tool you used this week was trained the same way: three steps, repeated billions of times.

By Friday, you'll have done all three by hand.

Each node works out a weighted sum, each input times its weight, added together. Then it adds its bias and applies an activation function.

ReLU turns any negative value into zero.

The nodes in the middle are a hidden layer: their values are never in the data, only worked out on the way.

Hidden layer

Nodes between the inputs and the outputs. Their values are worked out, never given.

Weighted sum

Each value coming into a node times its connection's weight, added together.

Bias

A number added to a node's weighted sum.

Activation function

A function applied to a node's value. Here, ReLU: any negative value becomes zero.

Forward pass

Working out every node's value, layer by layer, from inputs to outputs.

Three inputs, four middle nodes, three outputs. Each road has its own path through a middle node.

1. Click on connections to find each road's path.
2. What do the 0.8 weights mean?

0.8 of green time for each car waiting.

1. Why does the network need a middle layer at all?
2. What did the activation function do in the Birthday Book Predictor?
3. If a network gives the wrong answer, which numbers would you change?

Back propagation sends the error back across each weight. A middle node receives the output's error times the weight connecting them.

A node that feeds several outputs adds up what comes back from each.

The input values never receive an error. Why not?

Error

The output value minus the target value.

Back propagation

Sending the error back across each weight, so every node knows its share of the mistake.

Middle error

The error a middle node receives: each output's error times the weight between them, added up.

Two outputs, wrappers and bottles, so each middle node collects two errors and adds them up.

Write each one as a sum of products before you type it.

Draw the City Park network on paper.

Label every connection with the error that travels back along it in round 1.

Then check your labels against the app.

1. Why does the error travel back across the weights?
2. Why do the input values never receive an error?
3. A City Park middle node got a large error from one output and a small one from the other. Which matters more?

A middle node that the activation function held at zero played no part in the output, so no error reaches it.

Changing a weight into that node wouldn't change the output: it would still be held at zero.

In calculus terms: ReLU's slope is zero there, and the error is multiplied by that slope.

ReLU

A negative value becomes zero, and a positive one passes through unchanged.

Inactive node

A node the activation function holds at zero. It receives no error.

Slope

How much a function's output changes for a small change in its input. ReLU's is 0 below zero, 1 above.

The middle nodes measure the hours of sleep over and the hours short. Only the one above zero receives an error.

The bottom middle node's bias, -20, is more than any day's dogs and cats can make up, so it is held at zero every day.

For each zero, write one sentence saying why that node got no error.

1. Why did one yawn node receive no error in each round?
2. The pet rescue's bottom node never receives an error. What does that mean for its weights?
3. Why is it useful that only the active nodes get an error?

Every connection now knows its share of the error. Now the network uses it to change its weights.

The learning rate keeps each step small. Moving every weight a small step against its error is gradient descent.

Weight update

Subtracting input value × error × learning rate from a weight.

Learning rate

A small number that sets how big each weight update is.

Gradient descent

Training by moving every weight a small step in the direction that makes the error smaller.

Overshoot

Stepping past the best weight, so the error grows instead of shrinking.

2 classes take part. The network predicts 3 bags of cans, but the target is 6. The learning rate is 0.02.

Keep stepping through the 8 drives, and note the output error each time.

Why does it never reach zero?

It shrinks to within about 1 bag and stays there: the bags are never exactly 3 a class.

At a learning rate of 0.2, this network's weights blow up.

1. Watch it train at 0.2. What goes wrong?
2. Try the other learning rates, and record what each one does.
3. Find the one that settles.

What goes wrong above it? And below it?

Sketch the error against the weight as a valley. Draw each learning rate as steps down it.

1. Why multiply by the input value in the update rule?
2. What happens when the learning rate is too large? Too small?
3. Why is it called gradient descent?

This week you did every step by hand. Today the networks do thousands of steps at once, in swift mode.

A network can fit its training data without learning the pattern, like memorizing answers without understanding them. That's overfitting.

So we judge it on testing data it has never seen.

Training data

The examples a network learns from.

Testing data

Examples the network never learned from, used to check whether it really learned.

Overfitting

Fitting the training data so closely that the network does worse on new data.

Swift mode

Running the network's steps quickly, without showing each calculation.

Language model

A network that predicts the next word from the words before it.

The Harbor Predictor learns swimmers and sailboats from sunshine and wind, through a middle layer.

1. Train it in swift mode across all the training days.
2. Switch to the testing data, days it has never seen.
3. Which answer did it learn better?

The sailboats: off by about 0.7 a testing day, against about 1.1 for the swimmers.

Two hidden layers, and 255 steps a round.

1. Train it in swift mode.
2. Switch to the testing data.
3. Did it learn correctly?

A tiny language model that learns from 7 short sentences, like "the dog is cute" and "the sky is blue".

After training, which words does it expect after "is"?

cute, big, blue and hot: the words that followed "is" in its training sentences.

1. Why did the Harbor Predictor learn the sailboats better than the swimmers?
2. The Next Word Predictor only knows 10 words. What would change for a real language model?
3. The Next Word Predictor only says what it saw in training. What does that mean for real AI?

Draw a network of your own: two inputs, two middle nodes, one output. Choose its weights.

1. Run one forward pass.
2. Invent a target and send the error back.
3. Do one weight update at a learning rate of 0.1.

In a paragraph: how does an AI model learn?