Sparse Autoencoders: A Dictionary of Features

The idea: undo the packing

If superposition packs many features into few dimensions, the natural fix is to unpack them into many dimensions where each axis means one thing. That is exactly what a sparse autoencoder (SAE, 稀疏自編碼器) does. It takes a residual-stream activation, encodes it into a much wider hidden layer, and decodes back to the original — but with a sparsity penalty forcing almost all of the wide units to be zero on any given token. The few that stay active are the features actually present.

The result is a learned dictionary: thousands to millions of SAE features, each ideally monosemantic — firing for one human-meaningful concept. Where a raw neuron mixed DNA and legal text and HTML, the SAE splits them into three clean features. This is the most direct attack we have on the polysemanticity that made features and circuits hard to read.

How an SAE is built

An SAE is trained after the language model is frozen. You collect activations at one site (say, the residual stream at layer 12), then fit the autoencoder to reconstruct them under sparsity. The encoder's columns become candidate feature directions; the decoder's columns are how each feature writes back into the model's space.

Pick a site and run the model over a large corpus, caching activations there.
Train: encode to a wide hidden layer, decode back, minimise (reconstruction error + sparsity penalty).
Read each feature by collecting the inputs that make it fire most strongly — its top activating examples.
Name and audit features; discard dead ones (never fire) and uninterpretable ones.

\begin{aligned} f &= \mathrm{ReLU}\!\left(W_e\,(x-b_d)+b_e\right) \\ \hat{x} &= W_d\,f + b_d \\ \mathcal{L} &= \lVert x-\hat{x}\rVert_2^2 + \lambda\,\lVert f\rVert_1 \end{aligned}

The SAE objective: reconstruct the activations while an L1 penalty (λ‖f‖₁) forces the feature code f to stay sparse — the very tension between reconstruction and sparsity above.

Steering: turning a feature up or down

A dictionary is most convincing when you can use it. SAE feature steering (SAE 特徵操控) does exactly that: at inference time you add a feature's decoder direction to the residual stream — or subtract it — to amplify or suppress that concept. Clamp a 'formal tone' feature high and the model writes stiffly; clamp a 'this text mentions the Golden Gate Bridge' feature high and the model starts working the bridge into every reply. That the edit has the predicted effect is strong evidence the feature really is what we labelled it.

x' = x + \alpha\, d_i

Feature steering: add α times feature i's decoder direction dᵢ to the residual stream to turn that concept up — or down, with α<0.

# Steer with one SAE feature at a chosen layer
act = residual[layer]                  # activation we intercept
act = act + alpha * sae.decoder[:, j]   # push feature j by strength alpha
# alpha > 0 amplifies the concept; alpha < 0 suppresses it

Feature steering: add (or subtract) a feature's decoder direction to change the model's behaviour predictably.

From features to representation engineering

Steering with an SAE is one instance of a broader toolkit, activation steering (激活操控) and the surrounding field of representation engineering (表徵工程): controlling a model by editing its internal vectors rather than its prompt or its weights. SAEs make this principled — you steer named, audited features instead of opaque directions — which matters when steering is proposed for safety uses like turning down a deception feature. We pick the causal thread back up in Guide 5; for now, the lesson is that a good feature dictionary turns interpretability from a microscope into a set of dials.