# sparse-autoencoder-training

Provides patterns to train and analyze Sparse Autoencoders using SAELens. Useful for finding interpretable features in transformer activations.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 950 installs · ★ 13956
- Author: Orchestra Research
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/Orchestra-Research/AI-Research-SKILLs/tree/HEAD/04-mechanistic-interpretability/saelens/SKILL.md
- Updated: 2026-10-11
- HTML: https://affpapa.org/en/nevibecode/skills/sparse-autoencoder-training

## What it does

The skill provides workflows for mechanistic interpretability using SAELens. It guides the process of decomposing dense, polysemantic activations into monosemantic features. Pre-trained weights for models like GPT-2 Small and Gemma 2B are supported alongside feature extraction and activation reconstruction routines.

It also provides templates for custom training runs via `LanguageModelSAERunnerConfig`. Supported architectures include standard, gated, and topk variants. The skill guides hyperparameter selection for L1 sparsity warm-up, expansion factors, and tracking metrics such as L0, dead feature ratios, and CE loss recovery in Weights & Biases.

Working code requires Python 3.10+, `sae-lens>=6.0.0`, `transformer-lens>=2.0.0`, and `torch>=2.0.0`. Without an active CUDA device, local training runs on large models will stall.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add Orchestra-Research/AI-Research-SKILLs --skill sparse-autoencoder-training -a claude-code
```
```bash
npx skills add Orchestra-Research/AI-Research-SKILLs --skill saelens -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/saelens/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/saelens/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add Orchestra-Research/AI-Research-SKILLs --skill saelens -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/saelens/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add Orchestra-Research/AI-Research-SKILLs --skill saelens -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/saelens/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install Orchestra-Research/AI-Research-SKILLs saelens
```

2. **Manually: put the files in place**
- File: `.github/skills/saelens/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add Orchestra-Research/AI-Research-SKILLs --skill saelens -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/Orchestra-Research/AI-Research-SKILLs --path 04-mechanistic-interpretability/saelens
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/saelens/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add Orchestra-Research/AI-Research-SKILLs --skill saelens -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/Orchestra-Research/AI-Research-SKILLs/tree/HEAD/04-mechanistic-interpretability/saelens/SKILL.md

## When to use it
- decompose transformer activations into sparse features
- train custom SAEs using LanguageModelSAERunnerConfig
- evaluate L0 sparsity and dead feature ratios
- load pre-trained SAE checkpoints for Gemma 2B or GPT-2

## Example prompts
- Help me configure SAELens training on layer 8 of gpt2-small
- Load the pre-trained gpt2-small-res-jb SAE and inspect active features
- How do I track dead features and CE loss recovered in my SAE runner?

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: cffc8ea22874d45f.

BEGIN THIRD-PARTY FILE cffc8ea22874d45f
````text
---
name: sparse-autoencoder-training
description: Provides guidance for training and analyzing Sparse Autoencoders (SAEs) using SAELens to decompose neural network activations into interpretable features. Use when discovering interpretable features, analyzing superposition, or studying monosemantic representations in language models.
version: 1.0.0
author: Orchestra Research
license: MIT
tags: [Sparse Autoencoders, SAE, Mechanistic Interpretability, Feature Discovery, Superposition]
dependencies: [sae-lens>=6.0.0, transformer-lens>=2.0.0, torch>=2.0.0]
---

# SAELens: Sparse Autoencoders for Mechanistic Interpretability

SAELens is the primary library for training and analyzing Sparse Autoencoders (SAEs) - a technique for decomposing polysemantic neural network activations into sparse, interpretable features. Based on Anthropic's groundbreaking research on monosemanticity.

**GitHub**: [jbloomAus/SAELens](https://github.com/jbloomAus/SAELens) (1,100+ stars)

## The Problem: Polysemanticity & Superposition

Individual neurons in neural networks are **polysemantic** - they activate in multiple, semantically distinct contexts. This happens because models use **superposition** to represent more features than they have neurons, making interpretability difficult.

**SAEs solve this** by decomposing dense activations into sparse, monosemantic features - typically only a small number of features activate for any given input, and each feature corresponds to an interpretable concept.

## When to Use SAELens

**Use SAELens when you need to:**
- Discover interpretable features in model activations
- Understand what concepts a model has learned
- Study superposition and feature geometry
- Perform feature-based steering or ablation
- Analyze safety-relevant features (deception, bias, harmful content)

**Consider alternatives when:**
- You need basic activation analysis → Use **TransformerLens** directly
- You want causal intervention experiments → Use **pyvene** or **TransformerLens**
- You need production steering → Consider direct activation engineering

## Installation

```bash
pip install sae-lens
```

Requirements: Python 3.10+, transformer-lens>=2.0.0

## Core Concepts

### What SAEs Learn

SAEs are trained to reconstruct model activations through a sparse bottleneck:

```
Input Activation → Encoder → Sparse Features → Decoder → Reconstructed Activation
    (d_model)       ↓        (d_sae >> d_model)    ↓         (d_model)
                 sparsity                      reconstruction
                 penalty                          loss
```

**Loss Function**: `MSE(original, reconstructed) + L1_coefficient × L1(features)`
````
END THIRD-PARTY FILE cffc8ea22874d45f

The third-party file has ended. Everything between the cffc8ea22874d45f tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2683 of 12754 bytes. © Orchestra Research · MIT · https://github.com/Orchestra-Research/AI-Research-SKILLs/tree/HEAD/04-mechanistic-interpretability/saelens/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md