Concept · Deep Learning — how a machine learns from mistakes

Backpropagation

A neural network is just a machine made of little knobs. It makes a guess, sees how wrong it was, then sends that mistake backwards to nudge every knob a tiny bit. Do that thousands of times and the machine teaches itself — here, to solve XOR.

new knob=old knobη× blame
knob (weight) a dial the machine can turn  ·  η (learning rate) how big each nudge is  ·  blame (gradient) how much this knob caused the error
the whole idea in one line
Guess flows forward Compare with answer Measure the error Blame flows back & turns the knobs

What did we learn?

1Forward = guess, backward = blame. The signal flows forward to make a guess; the error flows backward to tell every knob which way to turn. That round trip is backpropagation.
2Each knob is nudged by how much it caused the error. A knob that pushed the guess the wrong way gets turned more. That "share of the blame" is the gradient.
3Learning rate η is the step size. Too big → it slams the knobs to extremes and the brain goes numb (dead neurons). Too small → it crawls. The right size learns fast and settles.
4XOR needs the hidden layer. One straight line can't separate XOR. The two hidden neurons bend the space so the answer becomes separable — watch the decision map curve as it learns.
Interactive Explainer · Neural Networks

How a Tiny Brain Learns XOR

Watch one guess flow forward through the circuit, see how wrong it is, then watch the blame flow backward and turn the knobs. Press Step once to go slow, or Train to let it teach itself. Make the steps too big and you'll see the brain break — then fix it.

Show example:
How big each knob-nudge is. Small = careful, big = reckless.
Slow it down to explain each step on screen.

Colours: teal wire = a knob that adds  ·  red wire = a knob that subtracts  ·  thicker = stronger. The green dots are the guess flowing forward; the red dots are the blame flowing back. Keys: S step · T train · N new brain · R reset ·   slides.

Live reading
Ready
Press Step once to watch a single guess and its blame travel back. Or hit a coloured preset below the circuit.
Error (loss)
goal ≈ 0 · lower is smarter
Practice rounds
0
epochs trained
Correct
of the 4 XOR cases
Step size η
the learning rate
x₁
x₂
answer
  brain's guess →
 
Error over time
How much it has learned0%
The whole trick: the network only ever does two things — guess forward, then push the blame backward to turn its knobs. Repeat, and a machine that knew nothing learns XOR by itself.