Visual Learning Resources

Transformer Explainer is a free web page from the Polo Club of Data Science at Georgia Tech. It runs a live GPT-2 (small) model inside your browser. You type a prompt, and the page shows every stage that turns your text into a prediction for the next token.[2][1]

What the page shows

GPT-2 (small) has 124 million parameters. That is tiny next to a modern chat model, but its design is the same: a stack of transformer blocks that predicts one token at a time.[2][3]

Temperature, top-k and top-p, with numbers

The page has sliders for the three sampling settings. Each setting changes the pick from the probability list, not the model itself.

• Temperature T: divide every score by T before softmax. A small T makes the top token even more likely. A large T flattens the list.
• Top-k: keep only the k most likely tokens, then pick among them.
• Top-p: keep the smallest group of tokens whose probabilities add up to at least p, then pick among them.

At T = 0.5 the top token “mat” takes about 76% of the probability. At T = 2.0 it takes about 37%, and the unlikely word “moon” grows from under 0.1% to 6%. This is why a high temperature gives more creative text and also more mistakes.

A 10-minute path through the page

1. Pick an example prompt, or type The cat sat on the. Press Generate.
2. Click a token. Watch the page zoom from the embedding to the attention stage.
3. Open the attention view. Hover over a token and see which earlier tokens it reads.
4. Set temperature to 0.2, generate three times, then set it to 1.5 and generate three times. Compare the answers.
5. Set top-k to 1. The output is now the same every time. This is greedy decoding.

LLM Visualization is a 3D walkthrough of a GPT-style model. Brendan Bycroft built it. Every number inside the model is drawn as a small cube. You fly through the model and read a guided text that explains each step, from the input tokens to the output probabilities.[4][5]

What the page shows

The page includes these four models: nano-GPT, GPT-2 (small), and GPT-2 (XL), and GPT-3. They share one design, so the shapes below are the same kind of object at four sizes. The GPT-3 row uses the sizes from its paper.[5][32]

nano-GPT is the one the guided walkthrough uses. It has a vocabulary of only 3 tokens (the letters A, B and C) and sorts a short string of them. It has about 85,584 parameters, which is small enough that the page can draw every weight. For a minimal GPT in code, read Andrej Karpathy's nanoGPT next.[6]

Why a 3D picture helps

• You see the size of things. A weight matrix of 768 × 2,304 looks very different from a bias vector of 768 numbers. A formula hides this. The 3D scene does not.
• You see the data flow. A cube leaves one stage and enters the next. You can follow one position all the way through.
• You see the same block repeat. GPT-2 (small) has 12 identical blocks. Once you understand one, you understand all of them.
• You can compare sizes. Switch from nano-GPT to GPT-2 (XL). The shape stays the same. Only the numbers get bigger.

A 15-minute path through the page

1. Start the walkthrough on nano-GPT. Read the Embedding step. Find the token embedding and the position embedding. They are added.
2. Move to Self-Attention. Find the three matrices Q, K and V. Find the 11 × 11 attention map and the masked area above the diagonal. That area is the causal mask: a token cannot read the future.
3. Move to the MLP step. Find the 4× wider middle layer. For nano-GPT it is 48 → 192 → 48.
4. Move to the Output step. Find the logits and the softmax. They match the last two steps in section 1.
5. Switch the model to GPT-2 (small). Look at the 12 blocks stacked in a row. Zoom in on one block and check that it is the same as the nano-GPT block, only wider.

3Blue1Brown is Grant Sanderson's math channel. Its Neural networks series explains deep learning with animations. The last three chapters cover transformers, attention, and how an LLM can store facts. This is the best first stop if you want the idea before the code.[7]

The seven chapters

Gradient descent in six lines

Chapter 2 is the key to all training, including the training of an LLM. The idea fits in one loop. Measure the slope of the loss, then move the weight a little in the downhill direction. Repeat.[7]

# Gradient descent on a one-weight "network": loss = (w - 3)**2 + 1
w, lr = 0.0, 0.3
for step in range(5):
    grad = 2 * (w - 3)      # slope of the loss at this w
    w = w - lr * grad       # take a step downhill
    print(step, round(w, 3))
# 0 1.8
# 1 2.52
# 2 2.808
# 3 2.923
# 4 2.969

A real network has billions of weights, not one. The loop is the same. The slope becomes a long list of slopes, one for each weight, and backpropagation (chapters 3 and 4) computes all of them in one pass.

How to watch the series

1. Watch chapters 1 and 2 first, even if you know the words. The pictures of weights and cost fix the vocabulary.
2. Pause before each result and guess what the next picture will show. This is much more effective than watching passively.
3. Watch chapter 5 together with section 1. Switch between the video and Transformer Explainer.
4. Watch chapter 6 together with section 4. Pick the same example sentence in both.
5. Skip chapter 4 on a first pass. Come back to it when you want the proof.

The Illustrated Transformer is a blog post by Jay Alammar from 2018. It walks through the paper Attention Is All You Need with one drawing for each step.[8][3] Many readers still call it the clearest explanation of queries, keys and values (Q, K and V).

Q, K and V in one picture

Every token creates three vectors from its own embedding. The three vectors have three different jobs:

• Query (Q): what this token is looking for.
• Key (K): a label that says what this token offers.
• Value (V): the content that this token hands over when someone picks it.

A token compares its query with the key of every token it may read. A high match gives a high score. Softmax turns the scores into weights that add up to 1. The token then takes a weighted sum of the values. The result is a new vector that holds information from the tokens that matter.[3][8]

A worked example with numbers

Use two tokens, a key size d_k = 2, and these vectors. Token 1 asks the question. Token 1 has query q = [1, 0].

The output is 0.670 × [1, 2] + 0.330 × [3, 4] = [1.66, 2.66]. The output sits closer to the value of token 1, because its key matched the query better.

The size of the original model

The post follows the base model of the paper. Its sizes give a feel for real numbers:[3][8]

What the post covers, in order

1. Embeddings and positional encoding: the model adds a position signal, because attention alone does not know the order.
2. Self-attention: Q, K, V, scores, scaling, softmax, weighted sum.
3. Multi-head attention: eight copies with different weights. The outputs are joined and projected back to 512 numbers.
4. Residual connections and layer normalisation around each sub-layer.
5. The decoder: masked self-attention (no peeking ahead), then encoder-decoder attention, where Q comes from the decoder and K and V come from the encoder.
6. The last linear layer and softmax, which turn the final vector into word probabilities.

What changed since the post

TensorFlow Playground is a tiny neural network that trains in your browser. You pick a dataset, choose the inputs and the layers, press play, and watch the network learn a boundary between two classes.[10][11]

What every control does

Five experiments that teach one idea each

1. A line is not enough. Choose the circle dataset. Use only X1 and X2, with no hidden layers, and press play. The loss stays high. One neuron can only draw a straight line.
2. A good feature can replace depth. On the same data, turn on X1² and X2². The loss drops to near zero within seconds. In the new feature space the ring becomes a straight line (see the figure below).
3. Hidden layers learn their own features. Turn the squared features off again and add a hidden layer with 3 or 4 neurons. The network now finds the circle by itself. Hover over a neuron to see the shape it draws.
4. A linear activation stays linear. Set the activation to Linear and add many layers. The boundary is still a straight line. A stack of linear steps is one linear step.
5. Training can fail. Set the learning rate to 10 and watch the loss jump. Then set noise to 40, make the network large, and compare training loss with test loss. A big gap means the network learned the noise (overfitting).

How this connects to an LLM

The playground uses the same four steps that train an LLM:

1. Forward pass: the inputs flow through the weights to an output.
2. Loss: a number says how wrong the output is.
3. Backward pass: the slope of the loss for every weight is computed (see section 3).
4. Update: every weight takes a small step downhill. The learning rate sets the step size.

An LLM does the same on text. It has billions of weights instead of about 25, and its output is a probability for each token instead of one class.

A Visual Guide to Attention Variants in Modern LLMs is an article by Sebastian Raschka (22 March 2026). It compares the attention designs that open-weight models use today, with a diagram for each.[12] The goal is simple: every variant tries to make attention cheaper for long inputs, in memory, in compute, or in both.

Why there are so many variants

Standard attention (MHA) has two costs that grow with the length of the input. The first is the KV cache: the model stores the keys and values of every earlier token, so it does not recompute them for each new token. The second is the compute of comparing every token with every earlier token, which grows with the square of the length.[12][3]

Each variant attacks one of these costs:

The KV cache, in numbers

Take a model shaped like Llama 3 8B: 32 layers, 32 query heads, head size 128, FP16 (2 bytes per number). For each token and layer, the cache holds one K and one V for each KV head.[13][12]

The formula is 2 × layers × kv_heads × head_size × bytes × tokens. MLA goes further than GQA. The DeepSeek-V2 paper reports a KV cache that is 93.3% smaller than that of its earlier dense model, DeepSeek 67B.[14]

Cheaper attention: fewer pairs, or fewer full layers

• Sliding window: a token reads only the last w tokens. Gemma 3 uses five local layers for each global layer, with a window of 1,024 tokens. The guide notes that its ablation shows only a small loss in quality.[12]
• DeepSeek sparse attention: the window is not fixed. A small indexer scores earlier tokens, and a selector keeps the best ones. The model decides which tokens are worth revisiting.[12]
• Hybrid: most layers use a linear or state-space mixer that costs little at long length. Every few layers, a full-attention layer restores exact lookup. Qwen3-Next uses a 3 : 1 mix. The guide notes a small quality trade-off.[12]

How to use the guide

1. Read part 1 (MHA) quickly, even if you know it. It sets the names used in the other parts.
2. For each later variant, ask two questions: what does it save? and what does it give up?
3. Open a model card of a model you use. Find which variant it has. Compare its context limit with the numbers in the table above.

A Visual Guide to Mixture of Experts (MoE) is an article by Maarten Grootendorst (7 October 2024). It uses more than 50 diagrams to explain the two parts of an MoE layer: the experts and the router.[16]

The idea: a big layer where only a few parts work

In a standard transformer block, a feed-forward network (FFN) refines each token after attention. This FFN holds most of the block's parameters. An MoE block replaces this one FFN with many FFNs, called experts, and adds a small router. For each token, the router picks a few experts. The other experts do no work for that token.[16][17]

The router in four steps

1. Score: multiply the token vector by the router weights W. This gives one score for each expert.
2. Softmax: turn the scores into probabilities G(x).
3. Keep top-k: keep the k largest values (for example 2). Set the others to zero.
4. Combine: run the chosen experts and add their outputs, each multiplied by its router probability.

The router is itself a small FFN that is trained together with the experts. When most tokens go to a few experts, those experts learn faster, and the router sends even more tokens to them. This loop is the main training problem of MoE.[16]

What an expert learns

The word “expert” suggests a specialist in a subject, such as biology or law. The guide shows that this is misleading. In decoder models, experts seem to handle patterns of tokens and syntax, not subjects. The guide shows a Mixtral figure in which each token is coloured by its first expert choice. Experts focus on syntax rather than on one subject.[16][19]

Load balancing: keeping all experts busy

Sparse and active parameters

An MoE model has two sizes. The sparse (total) size counts every expert. The active size counts only the experts that run for one token. The guide uses Mixtral 8x7B as the example.[16][19]

How to use the guide

1. Read the dense-layer part first. MoE only makes sense as a change to the FFN.
2. In the router part, follow the numbers for one token from scores to the final sum.
3. Read load balancing last. It is the part that decides whether an MoE model trains well.
4. Then open a model card and look for the words experts, top-k, active parameters.

The LLM Inference Handbook is a free online guide to everything that happens between your prompt and the answer. Its first chapter, What is LLM inference?, defines the terms. The next chapters cover how inference works and how to make it faster and cheaper.[20]

Four terms the handbook separates

The handbook notes that people often use these words as if they were the same, because one tool often does several of these jobs. The difference matters when you design infrastructure.[20]

What happens to one request

1. Tokenize: the server cuts the prompt into tokens and turns them into ids.
2. Schedule: the scheduler puts the request in a queue and joins it to the batch that is running on the GPU.
3. Prefill: the model reads the whole prompt in one pass. It builds the KV cache, which holds the keys and values of every prompt token (see section 6). The first output token comes out at the end of this step.
4. Decode: the model makes one token per step. It reads the cache, adds the new token to it, and repeats until it makes an end-of-text token or reaches the limit.
5. Stream: the server sends each token to the user as soon as it exists, so the user starts reading early.

Optimizations, and what each one helps

The handbook lists these strategies on its first page and points to a chapter on inference optimization for details.[20]

How to use the handbook

1. Press play on the visualizer. Name each of the four steps to yourself.
2. Read What is an inference server? and the page on serving versus inference. Write one line for each term in your own words.
3. Choose one optimization from the table. Read its chapter. Find the metric it improves: TTFT, TPOT, or throughput.
4. Return to Part 7 of this site and read the section on servers and quantization with the same vocabulary.

Neuronpedia is an open-source platform for interpretability research. You can explore, visualize, and steer the inside of AI models in your browser.[23] It hosts large public sets of features: directions inside a model that stand for ideas such as a place, a language, or a style. The page lists more than five terabytes of activations, explanations, and metadata.[23]

The problem: neurons are hard to read

You might hope that each neuron in a model means one thing. It does not. A model must represent far more ideas than it has neurons, so it packs many ideas into the same neurons, in overlapping ways. This is called superposition. A single neuron then fires for several unrelated things, which makes it hard to read.[26]

The tool: a sparse autoencoder

A sparse autoencoder (SAE) is a small network that is trained on a model's activations. It turns each activation into a very wide vector where only a few entries are active. Each entry is a feature. Then it rebuilds the original activation from those few features. The penalty on active entries pushes each feature toward one clear meaning.[24][26]

Neuronpedia shows the output of such SAEs. One featured release is Gemma Scope, a set of open SAEs that Google DeepMind trained on Gemma 2.[25][23]

How to read a feature page

1. Top activating examples: do all of them share one idea? If yes, the feature is clean.
2. Weak examples: scroll down to the lower activations. Do they show a second meaning?
3. Density: a feature that fires on a tiny share of tokens is usually specific. A feature that fires on many tokens may be broad or noisy.
4. Explanation: an automatic system often writes it. Treat it as a first guess, not as a fact.

Steering: test a feature by pushing it

A feature is a direction in the model's activation space. To test whether it matters, you add a scaled copy of that direction to the activation while the model writes: a' = a + α · d. If the output moves toward the feature's idea, the feature has a causal role. Neuronpedia has a Steer tool for this.[23][26]

Why this matters for engineers

• Safety: researchers look for features that relate to deception, harmful content, or sycophancy, and try to monitor or control them. See Part 11.
• Debugging: a feature view can show why a model gave a strange answer. Circuit tracing goes further and follows how features feed into each other.[27]
• Trust: interpretability gives evidence about how a model works, which is stronger than only testing its outputs.

Embedding Atlas is an open-source tool from Apple. It turns a table of text, images or audio into a map. Similar rows sit close together. You can click, search, and filter the map to understand a dataset that is too big to read.[28][29]

How it works

An embedding is a list of numbers that stands for the meaning of a piece of data. Rows with similar meaning get similar numbers. A table of 100,000 rows becomes 100,000 vectors.[28]

UMAP is a method that keeps nearby points near each other when it moves from many dimensions to two.[30] Embedding Atlas ships a WebAssembly version of UMAP, plus nearest-neighbour search and a density-based clustering step.[28]

What the tool gives you

The feature list follows the project's home page and overview.[28]

Three ways to run it

• In the browser: open the website and use Load Data. Supported files are Parquet, JSONL, and CSV.[28]
• Command line: install the Python package and point it at a file (see below). The default models are all-MiniLM-L6-v2 for text, google/vit-base-patch16-224 for images, and laion/clap-htsat-fused for audio. The docs say these defaults may change.[28]
• In a notebook or an app: the package has a Jupyter widget and a Streamlit component. You can pass a pandas DataFrame directly. A separate npm package has the interface components, for use in your own web app.[28]

# Install, then open a file in your browser
pip install embedding-atlas
embedding-atlas tickets.csv --text message
# The tool embeds the "message" column, runs UMAP,
# and prints a local URL such as http://localhost:5055/

If you already have vectors, pass them with --vector. If you already have a 2D projection, pass it with --x and --y. This makes the map repeatable.[28]

Use it for AI engineering work

• Debug retrieval (RAG): embed your document chunks and your user questions into one map. Questions that fall in an empty region show a gap in your knowledge base. See Part 4.
• Clean a dataset: look for tight groups of near-duplicates and for lone points that may be wrong labels or junk.
• Check evaluation coverage: plot your test questions on top of real traffic. Regions with traffic but no tests are untested.
• Compare embedding models: load the same data with two models. If the clusters change a lot, the choice of model matters for your task.