Forge a brain out of tiny math neurons, then teach it to think.

Flip the input switches and slide the two connection weights so the output bulb glows as close as possible to the target. Get within 0.1 to win.

Set the weights and bias so the neuron behaves like the chosen logic gate. It must output near 1 for "true" rows and near 0 for "false" rows on all four input combinations.

Each connection shows its weight; each neuron shows its computed activation once the wave reaches it. Change the inputs and replay to see every number recompute.

Choose how many hidden neurons, set the two inputs, then press Fire signal and watch each layer light up in turn. Goal: make the output neuron cross the firing line (output > 0.5) and the node turns gold when you succeed.

First try with no hidden layer: drag the single line; you'll never split the four points correctly. Then switch on the hidden layer and bend the two cuts until each class sits on its own side. The accuracy meter tells you how close you are.

Press Train all three. The all-zero start is stuck (symmetry never breaks), the too-large start thrashes or stalls, and the balanced start glides down. The loss curves race in real time.

Forward pushes activations left→right (teal). Then we compute the loss. Then the gradient flows right→left (rose), and one highlighted path shows the chain rule multiplying its links.

Slide each class's raw logit. The bars show the softmax probabilities live. Notice they always sum to 100%, and pulling one logit up steals probability from the others. The tallest bar (the argmax) is the predicted class.

Each bar is the gradient size at one layer, layer 1 (deepest from the loss) on the left. Toggle the activation and weight scale, then send the gradient backward and watch it shrink to nothing (sigmoid) or stay alive (ReLU).

Watch three dots roll down the contour bowl. Full-batch takes a clean straight line, mini-batch wobbles a little, and single-example zig-zags wildly, but they all head downhill.

Drag momentum to 0 and the dot stalls on the flat ridge near the saddle ✦. Raise it and the dot builds speed, slips off the ridge, and escapes down the valley.

The input words flow into the encoder (left → right) and collapse into one context vector in the middle. Then the decoder reads that vector and emits the translation one word at a time. Pick a sentence and play it.

Click each stage (or press Step) to light up the data path. Notice the + nodes: those are the residual skips you met above: they're what let a Transformer be dozens of blocks deep. Full attention mechanics live in Transformers & LLMs.

Click cells on the left to draw a shape. Pick a kernel (or hand-tune it), then drag/step the window across the image and watch the right-hand feature map glow where the kernel matches: that's how CNNs detect edges and textures.

After convolution, CNNs pool: slide a small window over the feature map and keep just one number per window: the max (strongest response) or the average. This halves the resolution, keeps the important signal, and makes the network cheaper and a little position-invariant.

Feed the sequence in one step at a time. The hidden state \(h_t\) is a mix of the new input and its own previous value, which is how the network "remembers".

Watch neurons blink off at random each step. Find the dropout rate that best closes the gap between training and validation accuracy: that's the rate that generalizes. Hit the green zone to win.

The raw inputs (left) wander off-center and uneven. With batch norm on, the same values get re-centered to 0 and scaled to a tidy spread (right), exactly what the next layer wants to see.

With the skip off, the pulse must crawl through every layer (and fades). Turn it on and a second pulse leaps over the block on the shortcut and rejoins at the + node, keeping the signal strong even in a deep stack.

Draw on the input grid. The network compresses it to just a few numbers (the bottleneck), then rebuilds it on the right. Shrink the bottleneck and watch detail vanish: the essence survives, the fine detail doesn't.

A network learns to place each word at a point so that related words sit near each other. Press scatter, then watch the words glide into meaning-based clusters: fruit here, animals there, royals over there. Dig deeper in Embeddings & Vector Search.

A generator makes fake samples; a discriminator tries to tell fakes from real. Each pushes the other to improve. Watch the generator's blurry fakes (orange) sharpen toward the real distribution (teal) as the two compete.

A pulse travels down the left arm (each step halves the resolution), across the bottom, and back up the right arm. With skips on, copies of detail leap across the gap (gold arrows) and rejoin the matching decoder level: that's why U-Net outputs stay crisp.

Watch the loop: noise → generator → fake; fake and real → discriminator → a real/fake verdict that trains both. The value bar swings as \(D\) gets sharper, then as \(G\) catches up: the back-and-forth of the minimax game.

Slide the spread \(\sigma\) to widen or tighten the latent cloud, then hit Re-sample: each \(z\) is drawn from that cloud, so the decoder produces a slightly different output every time. A small \(\sigma\) gives a faithful copy; a larger one explores nearby variations.

A round Gaussian cloud (teal) is bent through a few invertible steps into a curved target (a ring / two-moons style shape). Press Forward to warp it, and Reverse to flow it exactly back to the blob: that reversibility is the whole point.

One node starts "lit" (it holds some signal). Press Pass messages: each round, every node sends its value along its edges and blends in what it receives. Watch the signal ripple outward until the whole graph knows.

Send different inputs through. The router in the middle scores all the experts and lights up only the top 2: those run; the others stay dark (and cost nothing). Different inputs route to different experts.