The Output Projection: How 64 Attention Heads Become One Thought

Sixty-four attention heads have just finished work. Each produced 128 numbers, and not one of them knows what the other sixty-three found. The output projection, the matrix written W_O, is the operation that fixes that. It is also the least explained matrix in the block, usually waved through as “concatenate the heads and project”.

This article does two things. First it works a complete output projection by hand, on a toy small enough to check with a pen: 3 heads of 2 numbers each, and a 6 x 6 grid of weights. Every number below is checkable. Second it follows the result out of the block and into the residual stream, and shows why one addition sign fixes the width of the model at 8,192 for all 80 layers.

The running model is the one used throughout the series and in the previous part on why 64 heads beat one: 80 layers, d_model 8,192, 64 query heads, 8 key/value heads, head_dim 128.

Where we are: 64 sealed boxes

Attention has run and each of the 64 heads produced 128 numbers. Lay them side by side and you have 8,192 numbers again, one vector, the same width as the thing that went in.

It is not one vector in any useful sense. Numbers 0 to 127 came from head 1, numbers 128 to 255 came from head 2, and they are neighbours in memory that have never influenced each other, not once. Adjacency is not communication, which is a distinction worth internalising well beyond transformers if you spend time reading memory layouts for a living.

Here is why that matters. Say head 1 found “this is a definition question” and head 23 found “the important noun is equation”. Both findings are real, both are correct, and neither is worth much alone. The thought the model actually needs is “define the word equation”, and that thought is a combination of the two. Right now it cannot form, because the two findings sit in different compartments and nothing connects the compartments.

The multiply, worked by hand

The toy: 3 heads, 2 numbers each

Three heads have just finished. Head 1 returned 3, 1. Head 2 returned 0, 2. Head 3 returned 5, 4. Concatenated, that is the 6-number vector [3, 1, 0, 2, 5, 4], in three sealed groups of two. The real model is 64 heads of 128 numbers, giving 8,192. Same structure, bigger numbers, and no additional ideas.

W_O is a grid of weights, one column per output

Six numbers in, six numbers out, so W_O here is a 6 x 6 grid. Read it by column, because each column is the complete recipe for one output number: how much of each of the six inputs to use. Column 1 is the recipe for output 1, column 2 is a different recipe for output 2, and so on for six independent recipes over the same six inputs. In the running model there are 8,192 columns over 8,192 inputs, which is 67 million learned weights per layer.

Output number 1, every step

Take the input vector and column 1. Multiply matching positions, then add the six results. The six products are 3(0.5) = 1.5, then 1(0.0) = 0.0, then 0(0.2) = 0.0, then 2(0.0) = 0.0, then 5(0.8) = 4.0, then 4(0.1) = 0.4. Add them: 1.5 + 0.0 + 0.0 + 0.0 + 4.0 + 0.4 = 5.9.

Now group those products by which head they came from. Head 1 contributed 1.5, head 2 contributed 0.0, head 3 contributed 4.4. One output number, built from two heads at once.

The other five outputs

Repeat with each remaining column. Same six inputs every time, different recipe every time, so no two outputs are built the same way.

Head 3 dominates output 1 and is nearly absent from output 3. Head 2 is silent in outputs 1, 3 and 6. All three heads land in outputs 2 and 4. Nothing in the input said any of that, and it is entirely the grid’s doing.

The three jobs in one multiply

Job one: combining findings across head boundaries

Look again at where 5.9 came from. Part of it was head 1’s work and part of it was head 3’s, and the plus sign between them did not know or care that a compartment wall sat there. That is the whole of what mixing means. There is no separate merge step, the addition simply runs across the boundaries, and the boundaries mean nothing to it.

Translate that back to the real thing. Head 1 found “this is a question”. Head 3 found “the topic is equations”. Neither is actionable alone, the conjunction is, and after the multiply a single number carries something neither head knew.

The three inputs that survived their weights in that second example came from heads 1, 3 and 4. Three heads, one number, one addition.

Job two: routing, or where a finding lands

The weights do not only combine. They also decide where the result gets written, because the residual stream is not undifferentiated. Different directions in those 8,192 numbers end up carrying different kinds of information, since later blocks learn to read particular directions for particular things.

So the division of labour is clean. Heads decide what to look for, and the output projection decides what to do with what they found, including which part of the stream to file it in. A head that studies nouns can have its output written into whichever positions carry noun information, and it never has to know that.

Job three: a zero is a decision too

Go back to the grid and count the zeros. A zero is not an absence of a weight. It is a learned instruction to exclude one input from one output.

Output 1 is the cleanest case. Head 2’s two numbers are 0 and 2. The zero contributes nothing whatever its weight, and the 2 is switched off by a learned 0.0 in column 1. Head 2 is deliberately not heard in output 1, and that decision is made independently for all 8,192 outputs. A head can be loud in some places and silent in others, in the same layer, on the same token.

Reading the grid two ways, and why heads specialise

Read a column and you get “which heads feed this output?”. Read a row and you get “where does this head’s information go?”. The row view is the one interpretability researchers use, because a row block shows which directions of the residual stream a given head is able to write into. That is how a claim like “this head writes to the topic subspace” gets established in the first place.

The row view has a practical consequence. Because W_O multiplies a concatenation, you can slice it into 64 blocks of 128 rows, one block per head, and the block’s output is exactly the sum of the 64 per-head products. Concatenate-then-project and project-per-head-then-add are the same arithmetic. That equivalence is why it is legitimate to talk about “head 12’s contribution to the residual stream” as a thing that exists.

Now take W_O away and see what breaks. Each head’s 128 numbers would go straight onto the residual stream and stay in their own slice forever, so head 12 would occupy positions 1408 to 1535 in every block, in every layer, permanently. Nothing could ever combine two heads.

The deeper point follows from that. A head is only useful if its finding can be used, and the output projection is the only route by which it can be. During training, a head that discovers something valuable is rewarded only when W_O has learned to carry that output somewhere the rest of the model benefits from. The two co-adapt from the same gradient, so specialisation and routing develop together and neither is worth anything without the other.

The four attention matrices, by size

Put the numbers for the running model side by side, per layer, in bf16, with 64 query heads and 8 key/value heads under grouped-query attention.

Two things stand out. The output projection is exactly the same size as W_Q, and it is four times the size of W_K and W_V combined. It accounts for 44 percent of the attention block’s parameters.

W_K and W_V are small for a reason that has nothing to do with importance: grouped-query attention gives them 8 heads instead of 64, to shrink the KV cache. W_O is large for a reason that has everything to do with its job. It holds 8,192 separate recipes, each drawing on all 64 heads, plus the routing decision for every head into every region. That is a lot of decisions to store.

So the three jobs are combine, select and route, and they are not three steps. They are one multiply, and the same weights do all three at once.

Replace or add: the choice that fixes everything

The output projection has produced 8,192 numbers. The block now has to hand something to the next block, and there are exactly two options. Replace means throw away what came in and pass on the new numbers. Add means keep what came in and add the new numbers to it. Transformers add, and almost everything else about the architecture follows from that one choice, as the earlier walk through a single block set up.

What replacing would cost

Follow three blocks under replace. Block 1 notices something important, block 2 produces its own output and hands that on instead, and block 1’s finding is now unrecoverable. Not buried, not hard to reach, gone. Any block that needed block 1’s finding would have to be block 2, because block 2 is the last one that ever sees it. Eighty blocks under replacement would be eighty strangers, each able to cooperate only with its immediate neighbour.

What adding buys

The same three blocks under add. Each block’s contribution lands on a running total, nothing is destroyed, so block 30 can still read what block 3 wrote and block 71 can still read both.

Why the width can never change, and why 80 layers train

You cannot add two lists of different lengths. Every block adds its result to what came in, so every block must produce exactly as many numbers as it received. That is why d_model is 8,192 at every layer boundary in the model. It is not a preference, and addition demands it.

Say plainly what that rules out. You cannot taper a transformer the way you taper a convolutional network, narrowing as it goes deep. You cannot widen the later layers because they are doing harder work. You cannot insert a block that outputs 12,288 numbers between two blocks that expect 8,192. Every architectural change to the stream width has to be made once, globally, for all 80 layers, or it has to be paired with a projection that puts the width back.

The feed-forward network is the clean illustration. It widens to 28,672 and then comes back down to 8,192 before anything is added, so the wide part exists only inside the branch and never touches the page. The next part in this seriescoming 14 Aug works through what happens up there.

One more consequence, easier to feel than to prove. During training a correction signal has to travel from the output all the way back to block 1. Under replacement it passes through 80 transformations and gets scaled at every one, and multiplying 80 small numbers together gives a result indistinguishable from zero, so block 1 learns nothing. Under addition there is a direct path down the running total that the signal travels untouched.

What the residual stream makes visible

Key takeaways

• Concatenated head outputs are 64 sealed lists. Nothing has crossed between them, and the attention output projection is the only thing that ever will.
• The mechanism is one matrix multiply. Each output number is a weighted sum of every input number, and the sum runs straight across the head boundaries because the arithmetic has no idea they are there.
• W_O does three jobs in that one multiply: it combines findings, it excludes specific heads from specific outputs via learned zeros, and it routes each finding into a particular region of the residual stream.
• Read a column for “which heads feed this output”. Read a row for “where does this head’s output land”. Slicing the rows into 64 blocks gives you per-head contributions, which is the same arithmetic written differently.
• W_O is the same size as W_Q, four times the size of W_K and W_V together, and 44 percent of the attention block. That is proportionate to the number of decisions it stores.
• Blocks add to the residual stream rather than replacing it, so nothing written early is ever erased and block 71 can still read block 3.
• Addition requires matching widths, which is the real reason d_model is constant across all 80 layers, and it also provides the clean gradient path that makes 80 layers trainable.

Frequently asked questions

What does the output projection (W_O) actually do in multi-head attention?

It takes the concatenated outputs of all the heads and produces one vector of d_model numbers to add to the residual stream. In doing so it combines findings across head boundaries, excludes chosen heads from chosen outputs using learned zeros, and decides which region of the stream each finding is written into.

Why is W_O the same size as W_Q and so much bigger than W_K and W_V?

W_Q and W_O are both 8,192 x 8,192 because 64 heads times 128 dimensions equals d_model. W_K and W_V are 8,192 x 1,024 because grouped-query attention gives them 8 heads rather than 64, which shrinks the KV cache. The size of W_O is proportionate to its job: 8,192 recipes, each drawing on all 64 heads.

What would happen if you removed the output projection?

Each head’s output would land in its own fixed slice of the residual stream and stay there permanently. No two heads could ever be combined, and multi-head attention would degenerate into 64 unrelated operations sharing one container.

Is W_O applied to the concatenated heads or per head?

Both descriptions give identical results. Because it multiplies a concatenation, you can slice W_O into 64 blocks of 128 rows, multiply each head by its own block, and add the 64 results. That equivalence is what makes “this head’s contribution to the residual stream” a well defined quantity.

Why does d_model stay the same in every transformer layer?

Because each block adds its output to its input, and addition requires both sides to have the same number of elements. Every sublayer must therefore return exactly d_model numbers, which is why the feed-forward network widens to 28,672 internally and projects back down to 8,192 before the addition.

Does W_O have a bias term?

It depends on the family. Llama-class models omit biases on all four attention projections, while the original 2017 architecture and several other families include them. The bias makes no difference to the argument here, since it is a constant added after the mixing has already happened.

Sources and further reading

• Attention Is All You Need, the paper that defines multi-head attention and the output projection W^O.
• Deep Residual Learning for Image Recognition, He et al 2015, the origin of the additive skip connection.
• GQA: Training Generalized Multi-Query Transformer Models, which explains the 64 query heads and 8 key/value heads split.
• A Mathematical Framework for Transformer Circuits, which develops the residual stream and per-head output view formally.
• Locating and Editing Factual Associations in GPT, the causal tracing work behind activation patching.