Sparse dictionary learning / sparse coding
Sparse Autoencoders Find Highly Interpretable Features in Language Models — inherited
A prior mathematical framework (Olshausen & Field, 1997; Lee et al., 2006), originally developed to model sparse coding in the visual cortex, for expressing data as sparse linear combinations of an overcomplete set of learned basis vectors (a 'dictionary'). This paper's sparse autoencoder is presented as a scalable neural-network implementation of this framework applied to language model activations.
Long before anyone was trying to interpret a neural network, researchers studying the visual cortex faced a related puzzle: how to explain a pile of signals using only a few active causes at a time, drawn from a much larger set of possible ones. That decades-old problem turns out to be exactly the one a modern interpretability method inherits wholesale.
The entry follows that lineage from its origins modeling neurons in the visual cortex, through the shift from solving the problem fresh for every example to training a single function that solves it in one pass, and into a piece of pure theory the paper leans on to explain why some learned directions score higher than others.
A decades-old signal-processing idea inherited wholesale
Sparse dictionary learning, also called sparse coding, is the problem of expressing a set of data vectors as sparse linear combinations of an overcomplete set of learned basis vectors, or dictionary atoms. It originates in Olshausen & Field's (1997) model of simple-cell receptive fields in the visual cortex, later given efficient general algorithms by Lee et al. (2006), and predates and exists entirely independently of language models or interpretability research. This paper inherits the framework directly as its stated technique, titling its method section 'Taking features out of superposition with sparse dictionary learning' and noting that recovering a network's true, superposed features 'is equivalent to the well-known problem of sparse dictionary learning (Olshausen & Field, 1997)' (sparse-autoencoders, §"1 INTRODUCTION", p. 2).
From alternating optimization to a single learned function
Classical sparse coding solves for the dictionary and per-example codes together via alternating optimization, resolving a fresh sparse-coding problem for every new data point. This paper's Sparse autoencoders (SAEs) instead amortize that per-example search into a single trained encoder function, trading the guaranteed-per-example optimum of classical sparse coding for scalability to a language model's full activation dataset. The lineage extends past the empirical technique into pure theory: Qu et al. (2019) prove that sparse dictionary search can be reformulated as L4-norm maximization (sparse dictionary search reformulation), and this paper treats that reformulation as a testable prediction about its own learned features, finding a modest but consistent positive correlation between how heavy-tailed a feature's activations are and how interpretable it scores (see Interpretability-vs-kurtosis/skew correlation analysis).
The math: recovering a sparse code from an overcomplete dictionary
Formally, classical sparse coding seeks a dictionary $D$ and, for each data vector $x_i$, a sparse code $a_i$ minimizing a reconstruction-plus-sparsity objective: $$\min_{D,\, a_1,\ldots,a_n} \sum_i \|x_i - D a_i\|_2^2 + \lambda \|a_i\|_1$$ typically subject to bounding each dictionary atom's norm so the penalty cannot be satisfied merely by shrinking the atoms instead of the codes. The paper's Sparse autoencoders (SAEs) loss (Equation 4) is the same objective in different clothing: reconstruction error plus an $\ell_1$ penalty on the code, with the dictionary rows normalised for the same reason (sparse-autoencoders, §"2 TAKING FEATURES OUT OF SUPERPOSITION WITH SPARSE DICTIONARY LEARNING", p. 3). What changes between the classical and neural-network versions is only how the code (called $c$ in the paper) is produced: an optimization loop in classical sparse coding, a single forward pass through a ReLU encoder here.