Sparse Autoencoders & Dictionary Learning

Module 3.3 left you with a diagnosis and no cure. Models pack more features than they have dimensions, each feature living along its own direction, all of them interfering slightly. The consequence is that individual neurons are polysemantic: in the one-layer model Anthropic studied, a single neuron fires on academic citations, English dialogue, HTTP requests, and Korean text. Reading the model neuron by neuron is reading it in the wrong basis.

That is not just an aesthetic complaint. If you want to answer “is this model about to deceive the user?” you need a handle on the concept “deception” inside the model. If deception is smeared across four thousand neurons that each also do nine other things, you have no handle.

Why is this solvable at all? Because of sparsity. If a token's activation is a mixture of five features out of a hundred thousand, the mixture is heavily constrained, and — exactly as in compressed sensing — the sparse decomposition is essentially unique. Sparsity is what makes superposition possible and what makes it reversible.

A sparse autoencoder (SAE) is the crudest possible approximation to dictionary learning, and it works. Take activations $x \in \mathbb{R}^{d}$ harvested from one site in the model — a residual stream layer, or an MLP's hidden activations. Encode them into a much wider vector, then decode back:

Term by term: $W_{\text{enc}}$ is $h \times d$ with $h \gg d$ — the expansion factor $h/d$ is typically 8× to 256×. The ReLU forces every feature activation to be zero or positive, which is what lets you say “this feature is off here.” The columns of $W_{\text{dec}}$ are the dictionary: each one is the direction the model writes when that feature fires.

An ordinary autoencoder with a wider middle layer would learn the identity map and tell you nothing. The sparsity penalty is what makes it informative:

The second term is an L1 penalty on feature activations. L1 is a convex stand-in for what you actually want, which is L0 — the raw count of nonzero features — and L0 is not differentiable. Scaling each term by the decoder column norm stops the network from cheating by shrinking activations and growing the corresponding dictionary vector.

Two later variants matter. TopK SAEs (Gao et al., OpenAI, 2024) throw out the L1 penalty and simply keep the $k$ largest pre-activations, zeroing the rest. This fixes L0 exactly to $k$, removes the tuning problem, and sidesteps shrinkage — see below. Gated and JumpReLU SAEs (DeepMind, 2024) separate the decision whether a feature is active from the estimate of how active, for the same reason.

Towards Monosemanticity (Bricken et al., 2023) was the existence proof. One-layer transformer, 512-neuron MLP, sparse autoencoders from 512 up to 131,072 features trained on 8 billion activation samples, with detailed analysis of a 4,096-feature run they call A/1. They found features that are specific in a way no neuron was: an Arabic-script feature that fires on 0.13%-of-corpus Arabic text and accounts for 81% of that text's tokens; base64 features; DNA features. Crucially, the features have causal downstream effects consistent with their interpretation, which is what separates a feature from a correlation.

Scaling Monosemanticity (Templeton et al., 2024) answered the question everyone had: does this survive contact with a real production model? They trained SAEs on the residual stream halfway through Claude 3 Sonnet at three sizes — roughly 1M, 4M and 34M features — using scaling laws to allocate compute. Under 300 features fired per token, and reconstruction explained at least 65% of activation variance.

The features are also abstract in ways that a shallow “this fires on this word” story cannot explain. They are multilingual (the same feature for the same concept across languages), multimodal (text and images), and they bridge concrete and abstract — one feature covers both actual code containing a security vulnerability and English prose discussing security vulnerabilities.

Then they turned the demo into a public one. Clamping the Golden Gate Bridge feature (34M/31164353) to ten times its maximum observed activation produced Golden Gate Claude, a model that steers every conversation toward the bridge and at times identifies itself as the bridge. It ran as a public demo for a day in May 2024. As a party trick it is delightful; as evidence it is the cleanest available demonstration that these dictionary directions are the real causal handles the model uses, not a post-hoc story about correlations. Module 5.1 picks up steering as a technique in its own right.

SAEs are the most productive idea in interpretability since attention heads, and it is entirely possible they are the wrong abstraction. Hold both.

Two more you should know. Cross-layer superposition: gradient descent does not care which layer a feature lives in, so features get smeared across layers, and an SAE fitted to one layer can only ever see a slice. Anthropic call this “very fundamental” and do not claim to have solved it — it is exactly what the cross-layer transcoders of Module 4.1 are built to attack. Completeness: they do not believe they found anything near all the features in Sonnet, and estimate they may be orders of magnitude short.

Two toys. The first is a working sparse-coding solve on a synthetic activation whose true features you know, so you can catch the SAE being wrong. The second lets you walk a coarse feature down into its fragments as the dictionary widens.

The solver minimizes $\tfrac{1}{2}\lVert x - Df \rVert^2 + \lambda \lVert f \rVert_1$ with $f \ge 0$ — the same objective an SAE's training loss asks its encoder to approximate — so what you see is the real tradeoff, not a mock-up.

Things to try: (1) Drive $\lambda$ to 0 on Token D and count the active features — seven light up where only four are real, reconstruction is perfect, and the code is no more readable than the neurons were. That is the failure mode a plain autoencoder has, and it is what the sparsity penalty exists to prevent. (2) Now walk $\lambda$ up on Token D: at around 0.9 the weakest true feature dies and reconstruction error passes 60%. Rare, weak features are the first thing sparsity costs you. (3) Switch to Token C and look for the orange bar — the solver reports a Golden Gate Bridge feature that is not there, because that direction happens to patch the residual cheaply. False positives are not a bug in this toy; they are what interference looks like from the inside. (4) Watch the “recovered magnitude” readout as you raise $\lambda$: that is shrinkage, and it is why a feature's activation value is a much less trustworthy number than its identity. (5) In the tree, click ducks, geese & migration and note it has two parents — splitting produces a graph, not a tree, exactly as Bricken et al. report.