How an LLM Works: A Measured Tour in Eight Parts

This is the map for a series of eight guides on how a large language model works, written for readers who have heard the terms (neural network, attention, embedding) and want to see them as arithmetic. The series starts from one artificial neuron and ends at the geometry that lets a transformer store more ideas than it has dimensions.

Its one rule is that every idea comes with something I ran myself. The measurements are small, mostly NumPy on a laptop, and they say what they are and are not. Where a result contradicted what I expected, or what a source said, the guide says so, and four of those are listed below.

The path

flowchart LR
A["1 Network"] --> B["2 Learning"] --> C["3 Backprop"] --> D["4 Practice"]
D --> E["5 Ends"] --> F["6 Attention"] --> G["7 MLP"] --> H["8 Superposition"]

Read them in order the first time. Each part is written to stand alone when you look something up later, but the later ones lean on vocabulary introduced earlier: gradient in part 2, the weighted sum in part 1, softmax and the dot product in part 5.

The eight parts

What the numbers add up to

The parameter ledger of GPT-3, built a piece at a time across parts 5 to 7 from the published configuration, comes out as:

Two thirds of the model is the block that part 7 describes as a table of rules, and a third is the attention that part 6 builds.

Four things that did not go the way I expected

• ReLU lost to sigmoid at first. On the shallow digit network, ReLU hidden neurons scored 85.5% against sigmoid’s 94.4% until I paired them with a cross-entropy cost, where they became the best of four combinations. Dead neurons were not the cause. (Part 4)
• Almost-perpendicular has a hard limit. In 100 dimensions, at most about 103 vectors can sit within 1 degree of perpendicular to each other, and no optimizer can fix the typical pair, which stays about 5.6 degrees off. (Part 8)
• A trained attention head was untidy. It solved its task perfectly while putting nearly half its weight on the query position itself. (Part 6)
• Trained feed-forward neurons were not sparse. In the hand-built block, at most 1 neuron in 12 was on. In the trained blocks, 40% to 50% were. (Part 7)

What this series did not do

No part measured the weights of a real transformer. I could not download any on the machine I used, so every statement about GPT-3 or similar models is arithmetic from a published table or a cited paper, never an inspection. The embeddings in part 5 are count-based, from the text8 corpus, not a neural model’s. The networks are small, each result is mostly one random start, and the guides repeat these limits where they matter. Treat the experiments as demonstrations of mechanisms.

For the inference side of the story, which is what happens between pressing send and reading the first word, there is a separate guide with timing measurements: How an LLM Answers One Prompt.

Rerunning everything

Each guide ends with a methodology footnote and links to its script. They are single files that need only NumPy (plus SciPy for part 5). I ran them on Python 3.12 and NumPy 2.5. Each script’s docstring lists its arguments, and most can run one experiment at a time with --only=. Parts 1 to 4 download the MNIST digits (about 11 MB) the first time, and part 5 needs the 31 MB text8 corpus, which you fetch yourself. The two long ones are part 2 (about 17 minutes for everything in my run) and part 4 (more than 10 minutes).

Parts 1 and 5 read this site’s Markdown as their text corpus, so their exact counts change whenever I publish, and they say so.

Watch alongside

The structure of the series follows 3Blue1Brown’s deep learning videos,¹ which I link as companions in each part. They explain with animation what the guides explain with measurements, and the guides do not require them.

References