No definitions, no formulas dropped from the sky. You start by turning one knob until a number comes out right, and find that this — guess, measure the error, nudge — is the whole of learning. You tilt a line through two kinds of bug; you meet the one arrangement a single line can never split; you watch a cell decide how hard to fire. You wire a few together, find the grid that does all the arithmetic at once, and push a signal through to the far side. Then you run it backwards — split the blame across every wire, feel for the bottom of an unseen valley, take the smallest honest step downhill — and only then, built with your own hands, does it earn the name backpropagation. Every chapter follows one rule: silence every word and the picture alone still teaches it. After Rashid’s Make Your Own Neural Network (ch. 1), in the spirit of Petzold’s CODE. Built for someone who has never met a neuron; honest enough for an engineer.
A box with one dial turns kilometres into miles — but nobody set the dial. Turn it, watch the gap to the answer, and let the size of the gap tell you which way, and how far, to nudge.
Two kinds of garden bug scattered by width and length. Lay one straight line across them and tilt its slope — the bugs caught on the wrong side light up — until every wide one sits below and every long one above.
One line has to pass through two examples at once, and it cannot. Snap it onto either one and the other gap explodes; let both gaps pull at full strength and it whipsaws forever. Take only a sliver of each correction and watch it settle.
Four points at the corners of a square, coloured by a rule. Drop one straight line and tilt it to put the two colours on opposite sides. Two rules give way to a single line — but for the third, every angle leaves a corner stranded.
A cell adds up its inputs and has to answer: dark or lit? A hard threshold snaps from 0 to 1 with nothing in between. Round off that corner and the same input slide lifts the output gently — yet it never quite reaches the ends.
Cells joined by wires. Each wire carries a signal, and each wire has its own strength that scales what it carries. Thicken a wire and the cell it feeds rises; thin it to nothing and that signal stops arriving. Drag the wires and watch every value shift.
A cell adds up two signals, each scaled by its wire — one sum, by hand. Add a cell and the arithmetic piles up. Line the strengths into a grid and the signals into a column, sweep one row across the other, and every sum falls out at once.
A three-layer net with the book’s weights and an input of (0.9, 0.1, 0.8). Push the signal in and watch it fill each column: a weighted total on every cell, then the cell fires — and the fired column becomes the next input, all the way to the far side.
An output node is off by some error, and two wires of different strength fed it. Whose fault is the error? Share it back along the wires — the fatter wire owns more — then add up the shares that land on each feeder. Drag a wire and watch the blame re-split.
A ball sits partway up the wall of a dark valley; the floor is out of sight. Feel which way the ground tilts under it, step down the slope, and let each shrinking step carry the ball to rest at the bottom.
One weight, one smooth bowl of error. A ball rests up the wall. Read the tilt right under it — three plain things multiplied — and step downhill by a slice of it, again and again, until the bowl goes flat.
A nudge can only teach where the soft S-curve still tilts. Drop a total far out on the flat end and the slope dies — there is nothing to push on. Pull it into the steep middle, aim for answers the curve can actually reach, and start every wire small and spread so learning has a slope from the very first step.