Five visual resources to understand neural networks

You can explore the first four without writing code. The final resource connects the pictures to Python. Start with the question you're most curious about, then use the experiments below to get a result you can describe in your own words.

Your first ten minutes

Open TensorFlow Playground and find the small orange and blue data points. The background of its output chart represents the model's predictions across that space.

Before changing anything, identify three things: the inputs, the network in the middle and the output chart. Press play, pause it, and describe what moved. You now have a concrete question to bring to the first lesson: how do the adjustable connections create that output?

The learning pages and browser demos are public. You don't need a paid course subscription to read them. The larger demos can take time to load, and a capable desktop browser is more comfortable than a phone. The Python lesson requires its own setup; following it doesn't require paying for a hosted GPU.

1. 3Blue1Brown: connect a neuron to its calculation

Open But what is a Neural Network? by Grant Sanderson. It uses digit recognition to introduce the network picture, weights and activations. Pause when the calculation for a neuron appears, and identify the input numbers before moving on.

Try this original example alongside the lesson. Two inputs are 2 and 1. Their weights are 0.5 and -1, and the bias is 0.2. The weighted sum is:

z = 0.5 × 2 + (-1) × 1 + 0.2 = 0.2

If you apply a sigmoid activation, 1 / (1 + exp(-z)), the output is approximately 0.550. Change the first input from 2 to 0 and the weighted sum becomes -0.8, giving a sigmoid output of approximately 0.310.

These are teaching numbers, not measurements from the digit model. The useful connection is that a line represents a weight and a neuron's output depends on a calculation. Different architectures and layers can use different activation functions.

Your checkpoint: explain what changed when the input changed. You should be able to separate the example's inputs from the weights the model learns.

2. TensorFlow Playground: see how a network learns a boundary

Return to TensorFlow Playground. Select the circle dataset, keep x1 and x2 as inputs, and begin with one hidden layer containing one neuron. Use a nonlinear activation such as tanh. Keep the remaining settings fixed for your first comparison.

Run it for a short period and inspect the decision boundary. Reset, increase the hidden layer to a few neurons, and run again. A single hidden unit with these raw inputs gives the model a limited way to separate an inner group from an outer group. More units can combine several transformations, although a particular run still depends on its settings and starting values.

Look at both training loss and test loss. Training loss describes the examples used for learning; test loss describes held-out examples. A low training loss alone doesn't tell you that the model will handle new points well.

Your experiment: hold the dataset and other settings constant, change only the number of hidden neurons, and record what you actually see. Repeat if results differ. Don't treat one run as proof that a larger network always wins.

Your checkpoint: explain the output background and distinguish it from the labelled data points. The interface's colours encode values, rather than acting as decoration.

3. CNN Explainer: follow an image through its layers

Open CNN Explainer. The official project repository explains the interactive visualisation if the demo is slow to load.

Choose an available input image and follow the first convolution layer. Select an output in the visualisation to inspect how a small region of the input contributes to it. A convolution applies a learned filter across locations, producing a feature map. Later operations combine and transform those responses.

Your experiment: compare the original image with two feature maps from the same layer. Look for differences in where the maps respond strongly. Describe the visible pattern, but don't assume every map has one neat human label such as “eyes” or “edges”.

Then follow the flow towards the model's output classes. Identify the step where a spatial collection of responses becomes the information used for classification.

Your checkpoint: explain the difference between the original image and a feature map. This resource teaches a convolutional image-classification model; it doesn't describe every modern vision architecture.

4. Transformer Explainer: see text become next-token probabilities

Open Transformer Explainer. It uses a small GPT-2 model and shows tokenisation, attention and output probabilities. The model is useful for studying the mechanism, but it isn't Claude and it doesn't expose Claude's internal architecture.

Enter a short unfinished sentence, such as “The easiest way to organise my notes is”. Inspect the tokens, which may be whole words or parts of words. Follow a token into an attention view, then find the next-token probability display.

Your experiment: keep the same input and sampling filters, then compare a lower and higher positive temperature. Temperature changes how sharply the model's scores become probabilities. Lower values concentrate probability more strongly on high-scoring options; higher values spread it out. You haven't retrained the model by moving this control.

If top-k or top-p filtering is enabled, those controls also affect which candidates remain available. Keep them unchanged while comparing temperature so you know what caused the difference. Record the actual probabilities you see rather than assuming an example answer.

Your checkpoint: explain how a token differs from a word and why a temperature change can alter sampling without changing the learned weights. Attention values are a view into a computation, not a full human-readable explanation of the model's reasoning.

5. Karpathy's micrograd lesson: connect the picture to code

Open Neural Networks: Zero to Hero and choose the first micrograd lesson. You can also inspect the micrograd repository, including its computation-graph example. Basic Python and some calculus help here.

Follow one short graph from inputs to output. Then trace the derivatives backwards. Micrograd is an educational automatic-differentiation engine: it keeps track of a calculation so it can compute gradients.

Use this original expression as a warm-up: y = (2x + 1)² at x = 1. The forward value is 9. The derivative at that point is 12, because the outside square contributes 2 × 3 and the inner expression contributes 2.

A backward call calculates gradients through an existing graph. It doesn't, by itself, perform every part of training. The example still needs a loss, parameter updates and repeated runs.

Your checkpoint: explain why the forward value is 9 while the derivative is 12. They answer different questions: what the output is, and how sensitive it is to x at this point.

Get an explanation of the thing you're looking at

Take your own screenshot from one of the demos, attach it to Claude, and use this prompt. Include the settings or numbers in text if the screenshot is difficult to read.

Help me understand this neural-network visualisation.

Resource: [3Blue1Brown / TensorFlow Playground / CNN Explainer / Transformer Explainer / micrograd]
My screenshot or copied values: [attach or paste]
What I changed: [one control or input, or say nothing yet]
What confused me: [one sentence]

Explain the visible input, the transformation being shown and the output. Define each technical term when first used. Refer only to values and controls you can actually read; ask for an unclear number instead of inventing it.

Then create one small numerical example that demonstrates the same concept, show every calculation and check the arithmetic. Keep example numbers clearly separate from the screenshot's measured values.

Give me one controlled experiment to try in this exact resource: what to hold fixed, what to change, what to observe and what the result could or could not establish. End with a short explanation I could use to teach the concept to a friend. Do not claim you interacted with the demo or ran its model unless you actually did.

If the visual still feels confusing

Make the example smaller. One neuron is enough to understand a weighted sum. One convolution is enough to understand how a filter uses a local region. One unfinished sentence is enough to explore next-token probabilities.

If a browser demo won't load, use its explanatory text or official repository while troubleshooting the browser. If an experiment gives an unexpected result, record the settings before changing anything else. That unexpected result is often the most useful part to investigate.