How neural networks actually work

A neuron takes in some numbers, decides how much each one matters, adds them up, and turns that total into a single output. That's the whole idea — every neural network, no matter how huge, is just millions of this same simple step wired together.

• Each input (x1, x2) gets multiplied by a weight — a number saying how much that input should count. A bigger weight means more influence on the result.
• The bias (b) is a small nudge added to the total, letting the neuron lean toward a higher or lower output even before it sees any input.
• The activation function (sigmoid, here) squashes that total into a smooth 0–1 range, so the output reads like a confidence score instead of an unbounded number.

Drag the sliders below and watch each real number move through every step above.

Imagine sliding a small stencil across a photo, checking at every position: does the patch underneath match the pattern this stencil is looking for? That's exactly what a CNN's kernel does — a tiny 3×3 grid of numbers (a real one, below) slides across the image and scores one position at a time, the same small stencil reused everywhere instead of a separate neuron wired to every single pixel.

Different kernels look for different things — one might light up on sharp edges, another on smooth color changes — and stacking layers of them lets the network build up from simple patterns (an edge here, a curve there) to whole recognizable shapes.

Try the presets below, or edit the kernel's numbers directly and watch which patterns light up.

Imagine reading a sentence one word at a time, and after every word you update a short mental summary of everything you've read so far. That running summary is the hidden state — an RNN does exactly this. The same small cell runs at every step, taking in the next input plus its own previous summary, and produces an updated summary to carry forward.

That's the whole idea: what happens at step 3 depends on what happened at steps 1 and 2, not just on that step's input alone — something the plain neuron above can't do, since it only ever looks at whatever inputs you hand it right now.

Step through the sequence below and watch the real hidden-state number change at each step.

Read this: “The trophy didn't fit in the suitcase because it was too big.” To understand what “it” means, you instinctively glance back and weigh which earlier word fits better — trophy, or suitcase? That instinctive glancing-back-and-weighing is exactly what self-attention does: every word looks at every other word in the sentence and scores how relevant it is. High-scoring words shape the result more; low-scoring ones are mostly ignored.

This is the real mechanism behind the live visualizer above — neither CNN nor RNN powers it. Llama (the model behind it) is a Transformer, and self-attention is its core move, repeated across every layer. Type a sentence below: it runs through the same real tokenizer the live tool uses, and real attention scores get computed on the spot for every word pair.

This is the closest we can get to genuine transformer internals without self-hosting a model with direct weight access (Groq's API, like every hosted inference API, never exposes real attention weights) — that's a planned, separate, heavier build, not something any hosted API can provide.