🤖 machine learning

Scalable Circuit Learning for Interpreting Large Language Models

The paper introduces CircuitLasso, a scalable sparse linear regression method that efficiently learns interpretable circuits over sparse autoencoder features in large language models, matching the accuracy of costly intervention-based techniques while enabling effective domain generalization at a fraction of the computational cost.

Original authors: Naiyu Yin, Dennis Wei, Tian Gao, Amit Dhurandhar, Karthikeyan Natesan Ramamurthy, Yue Yu

Published 2026-06-16

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Naiyu Yin, Dennis Wei, Tian Gao, Amit Dhurandhar, Karthikeyan Natesan Ramamurthy, Yue Yu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a Large Language Model (LLM) as a massive, incredibly complex factory. Inside this factory, millions of tiny workers (neurons) pass notes to each other to produce the final output: a sentence or an answer.

For a long time, scientists trying to understand how this factory works have faced a major problem: The workers are confusing. A single worker might be activated by the word "apple," the color "red," and the concept of "health" all at once. Because one worker does so many unrelated things, it's hard to tell exactly which worker is responsible for which part of the final sentence. It's like trying to figure out who baked a cake when every baker in the kitchen is juggling flour, eggs, and paintbrushes simultaneously.

The New Tool: "Feature Detectors"

To fix this, researchers started using a special tool called a Sparse Autoencoder (SAE). Think of this as a translator that sits between the factory workers and the outside world. Instead of looking at the confused workers directly, the translator groups their activity into very specific, single-purpose "features."

Now, instead of a worker juggling everything, we have a dedicated "Sports Fan" feature, a "Grammar Police" feature, or a "Hunger" feature. Each of these features lights up for only one clear concept. This makes the factory's inner workings much easier to read.

The Problem: Too Much Data

Here is the catch: While these "features" are much clearer, there are thousands of them. Trying to map out how thousands of these features talk to each other is like trying to draw a map of every single road in a giant city while driving a car that can only go one mile per hour.

The old methods for mapping these connections required "interventions." Imagine trying to figure out a road map by physically blocking off every single street one by one to see what happens. This is incredibly slow, expensive, and computationally impossible for huge models.

The Solution: CircuitLasso

The authors of this paper introduce a new method called CircuitLasso.

Instead of blocking off streets one by one, CircuitLasso acts like a super-smart detective using a magnifying glass and a statistical shortcut. It looks at the traffic patterns (the data) that are already happening naturally and uses a mathematical technique called "sparse regression" to figure out the connections.

The Analogy: Imagine you want to know which ingredients in a soup are essential.
- The Old Way (Intervention): You taste the soup, then remove one ingredient, taste again, put it back, remove another, taste again... doing this for every single spice. It takes forever.
- CircuitLasso: You look at a list of all the ingredients and the final taste, and you use a smart algorithm to instantly calculate which ingredients are actually doing the heavy lifting. It's much faster and doesn't require messing with the soup.

What They Found

The paper claims three main things:

Speed without Sacrifice: CircuitLasso is dramatically faster than the old "blocking off streets" methods. In their tests, it was 3 times faster on standard benchmarks, yet it found the exact same "circuits" (maps of connections) with the same level of accuracy.
Clearer Stories: Because it works with the clear "features" (like "Hunger" or "Grammar") instead of the confused neurons, the maps it draws are easy for humans to understand. They found "tree-shaped" paths showing how a concept like "hunger" flows through the model layers, eventually leading to the action of "eating." They even spotted "spurious correlations"—false connections where the model thinks "hunger" is related to "self" just because those words often appear together in the training data.
Real-World Utility: They tested this on a task where the model had to guess a person's job from their biography. The model was biased (e.g., assuming all nurses are female). By using CircuitLasso to identify and remove the specific "gender" features that were causing this bias, they were able to fix the model's predictions. They did this much cheaper and faster than previous methods, achieving similar or slightly better results.

The Bottom Line

This paper presents a new, efficient way to reverse-engineer how AI models think. By switching from looking at confused workers to looking at clear, single-purpose features, and by using a fast mathematical shortcut instead of slow, brute-force testing, the authors have created a tool that can map the "brain" of large AI models quickly and clearly. This helps us understand not just what the AI says, but why it says it, and how to fix it when it makes mistakes.

Technical Summary: Scalable Circuit Learning for Interpreting Large Language Models

1. Problem Statement

Mechanistic interpretability aims to uncover the "why" behind Large Language Model (LLM) behaviors by identifying circuits: compact subgraphs connecting key components (e.g., attention heads, neurons) that drive specific capabilities. However, existing circuit learning methods face two primary bottlenecks:

Polysemanticity: Raw neurons in LLMs are polysemantic, meaning a single neuron activates for multiple, unrelated concepts. This results in learned circuits that are dense, noisy, and difficult for humans to interpret.
Scalability: While Sparse Autoencoders (SAEs) offer a solution by decomposing activations into high-dimensional, monosemantic (single-concept) features, existing intervention-based circuit learning methods (e.g., causal tracing, attribution patching) do not scale to the high dimensionality of SAE features. These methods require computationally expensive counterfactual interventions (forward and backward passes) for every component, making them prohibitive for large models and high-dimensional feature spaces.

2. Methodology: CircuitLasso

The authors propose CircuitLasso, a scalable circuit learning approach that replaces costly intervention-based pipelines with a sparse linear regression framework.

Core Formulation

Instead of estimating causal effects via interventions, CircuitLasso treats the LLM's computational graph as a sparse linear Structural Equation Model (SEM). Given $N$ components (neurons or SAE features) and $M$ observations, the method seeks a weighted adjacency matrix $A$ such that:
$X \approx A^\top X$
where $X$ is the matrix of activations. The goal is to learn a Directed Acyclic Graph (DAG) representing dependencies by minimizing reconstruction error subject to sparsity ( $\ell_1$ penalty) and acyclicity constraints:
$\hat{A} = \arg \min_{A} \|X - A^\top X\|_F^2 + \lambda \|A\|_1$

Handling Constraints and Scalability

Acyclicity: Rather than enforcing complex continuous acyclicity constraints (which are computationally heavy), CircuitLasso leverages the known feed-forward architecture of Transformers. It assumes a block upper-triangular structure where layer $i$ depends only on layers $j < i$ . This transforms the problem into a series of independent Lasso (sparse linear regression) subproblems, solvable efficiently via the FISTA algorithm.
Observational Data: The method operates solely on observational data (activations from a forward pass), avoiding the need for the multiple forward/backward passes required by intervention-based methods.
SAE Integration: The framework is extended to operate directly on SAE features ( $z \in \mathbb{R}^D$ , where $D \gg d$ ). It learns layer-wise dependencies between SAE features and can also link final-layer features to downstream prediction targets ( $y$ ).

Complexity Analysis

Theoretical analysis (Proposition 3.2) demonstrates that CircuitLasso offers guaranteed efficiency gains over state-of-the-art intervention-based methods (like EAP-ig) under specific regimes, particularly when the number of component locations ( $L$ ) is moderate relative to sequence length and model dimensions. The cost scales with $O(M L^2 d^2)$ , whereas intervention methods scale with the cost of additional forward/backward passes through the entire model.

3. Key Contributions

CircuitLasso Algorithm: A sparse regression surrogate for circuit discovery that replaces intervention-heavy pipelines with an observational, Lasso-based approach.
Scalability to SAEs: The first method capable of efficiently learning circuits on high-dimensional, monosemantic SAE features, overcoming the computational prohibitions of previous techniques.
Theoretical Efficiency: A formal analysis establishing conditions under which the regression-based approach is provably faster than intervention-based baselines.
Empirical Validation: Demonstrations on model neurons and SAE features showing that CircuitLasso achieves structural accuracy comparable to SOTA baselines at a fraction of the computational cost.

4. Experimental Results

Benchmark Performance (Model Neurons)

Evaluated on InterpBench (86 semi-synthetic transformers and the Indirect Object Identification task):

Accuracy: CircuitLasso (linear variant) achieved a mean Structural Hamming Distance (SHD) of 3.16, statistically indistinguishable from the SOTA intervention-based baseline EAP-ig (2.98) and better than EAP (3.61).
Efficiency: It was 3.0x faster than EAP-ig (16.3s vs. 49.1s per case) and 2.1x faster than EAP.
Nonlinearity: A nonlinear extension of CircuitLasso offered marginal accuracy improvements but at a significantly higher runtime, suggesting the linear surrogate is sufficient for recovering the dependency skeleton.

Interpretability Case Study (SAE Features)

Applied to GPT-2 Small on the CoLA (Corpus of Linguistic Acceptability) dataset:

Monosemantic Circuits: The method recovered tree-shaped circuits where nodes correspond to human-interpretable concepts (e.g., "-self", "hunger/thirst", "ending punctuation").
Semantic Propagation: The circuits revealed how concepts persist across layers, merge (combining concepts from multiple parents), or drop (ignoring certain inputs).
Causal vs. Spurious: The learned graphs captured both causal semantic relationships (e.g., "hunger" leading to "eating") and spurious correlations likely introduced by dataset biases (e.g., co-occurrence of "-self" and "hunger").

Downstream Utility (Domain Generalization)

Evaluated on the Bias-in-Bios task (predicting profession while mitigating gender bias):

Performance: CircuitLasso achieved profession prediction accuracy comparable to, and in some cases slightly better than, the strongest non-Oracle baseline (SHIFT), while maintaining gender leakage near the ideal 50% mark.
Efficiency: As shown in Table 1, CircuitLasso required significantly fewer features and substantially less runtime than SHIFT. For the Gemma-2-9B model, CircuitLasso took 107.4s compared to 908.4s for SHIFT.

5. Significance and Claims

The paper claims that CircuitLasso successfully addresses the scalability bottleneck in mechanistic interpretability. Its primary significance lies in achieving "efficiency at parity of accuracy":

It recovers structural circuits as accurately as the most rigorous intervention-based methods but at a fraction of the computational cost.
It enables the use of monosemantic SAE features for circuit analysis, providing clearer, human-interpretable explanations of how semantic concepts propagate through LLMs.
The insights derived from these circuits are practically useful, enabling effective domain generalization and bias mitigation tasks at a much lower cost than existing methods.

The authors remain modest regarding the nature of the learned weights, noting that the linear coefficients represent a dependency skeleton rather than exact causal effects of the underlying nonlinear computation. They view the method as a first-order surrogate that effectively identifies which components influence others, rather than quantifying the precise magnitude of causal effects.