| """Count per-(feature, token-string) firings for all 13 SAE layers over a large |
| corpus, WITHOUT ever materialising an activation store. |
| |
| Why counting and not storing: at 36.8M read positions the full threshold-free |
| store would hold ~2.8 billion nonzeros (~22 GB per layer). Token-only programs |
| need only a contingency table -- how often each feature fires on each decoded |
| string -- which is four orders of magnitude smaller. So we accumulate that |
| directly in one forward pass. |
| |
| Keys are CANONICAL DECODED STRINGS, not token ids, because 255 GPT-2 ids decode |
| to the same replacement character and a program can only test what it can see. |
| This matches the convention used by the shipped programs exactly. |
| |
| Memory: a running (key -> count) table per layer, flushed and merged when the |
| pending buffer grows. Peak is bounded by the number of DISTINCT (feature, |
| string) pairs per layer, not by the number of firing events. |
| |
| python count_fires.py --limit 5000 # pilot |
| python count_fires.py # full corpus |
| """ |
| from __future__ import annotations |
| import argparse, json, sys, time |
| from pathlib import Path |
| import numpy as np |
| import torch |
|
|
| HERE = Path(__file__).resolve().parent |
| ROOT = HERE.parent |
| for p in (ROOT / "lib", ROOT / "eda_phase0", ROOT): |
| sys.path.insert(0, str(p)) |
| import config as C |
| import sae_synthesis as S |
|
|
| THR = 0.1 |
| FLUSH = 20_000_000 |
| SPILL_PAIRS = 40_000_000 |
|
|
|
|
| class LayerCounter: |
| """Running (feature*NS + string_id) -> count, EXACT, spilled to disk. |
| |
| The full corpus implies ~2.4 billion distinct (feature, string) pairs across |
| 13 layers -- about 28 GB, well past RAM. So each layer keeps a bounded |
| in-memory table and spills a sorted shard to disk whenever it grows past |
| SPILL_PAIRS; the shards are k-way merged at the end. Nothing is pruned or |
| approximated: a pair seen twice in different shards is summed correctly. |
| """ |
|
|
| def __init__(self, n_strings: int, layer: int, tmp: Path): |
| self.ns, self.layer, self.tmp = n_strings, layer, tmp |
| self.keys = np.zeros(0, dtype=np.int64) |
| self.cnt = np.zeros(0, dtype=np.int64) |
| self.buf: list[np.ndarray] = [] |
| self.pending = 0 |
| self.shards: list[Path] = [] |
|
|
| def add(self, feat: np.ndarray, sid: np.ndarray) -> None: |
| self.buf.append(feat.astype(np.int64) * self.ns + sid.astype(np.int64)) |
| self.pending += len(feat) |
| if self.pending >= FLUSH: |
| self.merge() |
| if len(self.keys) >= SPILL_PAIRS: |
| self.spill() |
|
|
| @staticmethod |
| def _combine(k1, c1, k2, c2): |
| allk = np.concatenate([k1, k2]) |
| allc = np.concatenate([c1, c2]) |
| o = np.argsort(allk, kind="stable") |
| allk, allc = allk[o], allc[o] |
| first = np.concatenate([[True], allk[1:] != allk[:-1]]) |
| return allk[first], np.add.reduceat(allc, np.flatnonzero(first)) |
|
|
| def merge(self) -> None: |
| if not self.buf: |
| return |
| k, c = np.unique(np.concatenate(self.buf), return_counts=True) |
| self.buf, self.pending = [], 0 |
| if len(self.keys) == 0: |
| self.keys, self.cnt = k, c.astype(np.int64) |
| else: |
| self.keys, self.cnt = self._combine(self.keys, self.cnt, k, |
| c.astype(np.int64)) |
|
|
| def spill(self) -> None: |
| p = self.tmp / f"L{self.layer:02d}_shard{len(self.shards):03d}.npz" |
| np.savez(p, keys=self.keys, cnt=self.cnt) |
| self.shards.append(p) |
| self.keys = np.zeros(0, dtype=np.int64) |
| self.cnt = np.zeros(0, dtype=np.int64) |
|
|
| def finalize(self, n_features: int, block: int = 2048, min_count: int = 1): |
| """Exact k-way merge, done in FEATURE BLOCKS so memory stays bounded. |
| |
| Keys are feature*NS + string_id, so a feature range is a contiguous key |
| range and every shard's slice for it is found by binary search. A naive |
| whole-table merge of the deepest layer would peak near 16 GB; this peaks |
| at one block's worth. |
| |
| min_count is applied only AFTER every shard has been summed, so it is a |
| decision about what to keep, never an approximation of the count. |
| """ |
| self.merge() |
| if self.keys.size: |
| self.spill() |
| loaded = [np.load(p) for p in self.shards] |
| parts_k, parts_c = [], [] |
| for f0 in range(0, n_features, block): |
| lo, hi = f0 * self.ns, min(f0 + block, n_features) * self.ns |
| bk = np.zeros(0, dtype=np.int64); bc = np.zeros(0, dtype=np.int64) |
| for z in loaded: |
| zk = z["keys"] |
| i0, i1 = np.searchsorted(zk, [lo, hi]) |
| if i1 > i0: |
| bk, bc = self._combine(bk, bc, zk[i0:i1], |
| z["cnt"][i0:i1].astype(np.int64)) |
| if bk.size: |
| if min_count > 1: |
| m = bc >= min_count |
| bk, bc = bk[m], bc[m] |
| parts_k.append(bk); parts_c.append(bc) |
| for z in loaded: |
| z.close() |
| for p in self.shards: |
| p.unlink() |
| self.shards = [] |
| self.keys = np.concatenate(parts_k) if parts_k else np.zeros(0, np.int64) |
| self.cnt = np.concatenate(parts_c) if parts_c else np.zeros(0, np.int64) |
| return self.keys, self.cnt |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--limit", type=int, default=0, help="pilot on N sequences") |
| ap.add_argument("--batch", type=int, default=48) |
| ap.add_argument("--layers", type=int, nargs="*", default=list(range(13))) |
| ap.add_argument("--out", default=None) |
| a = ap.parse_args() |
|
|
| vocab = np.load(ROOT / "layer_plots" / "vocab_strings.npy", allow_pickle=True) |
| uniq, sid_of_id = np.unique(vocab, return_inverse=True) |
| NS = len(uniq) |
| tokens = np.load(HERE / "corpus_300k.npz")["tokens"] |
| if a.limit: |
| tokens = tokens[:a.limit] |
| n_seq, seq_len = tokens.shape |
| first = C.FIRST_READ_POSITION |
| n_read = seq_len - first |
| print(f"{n_seq:,} sequences x {n_read} read positions = " |
| f"{n_seq * n_read:,} positions; {NS:,} distinct strings", flush=True) |
|
|
| dev = "mps" if torch.backends.mps.is_available() else "cpu" |
| from transformer_lens import HookedTransformer |
| from sae_lens import SAE |
| model = HookedTransformer.from_pretrained("gpt2-small", device=dev) |
| model.eval() |
| saes = {} |
| for L in a.layers: |
| sae, _, _ = SAE.from_pretrained(release="gpt2-small-res-jb", |
| sae_id=S.HOOKS[L].replace("blocks.", "blocks."), |
| device=dev) |
| saes[L] = (sae.W_enc.detach().float(), sae.b_enc.detach().float(), |
| sae.b_dec.detach().float()) |
| print(f"device {dev}; {len(saes)} SAEs loaded", flush=True) |
|
|
| tmp = HERE / "shards"; tmp.mkdir(exist_ok=True) |
| counters = {L: LayerCounter(NS, L, tmp) for L in a.layers} |
| occ = np.zeros(NS, dtype=np.int64) |
| hooks = [S.HOOKS[L] for L in a.layers] |
| t0 = time.time() |
| for b0 in range(0, n_seq, a.batch): |
| chunk = tokens[b0:b0 + a.batch] |
| ids = torch.from_numpy(chunk.astype(np.int64)).to(dev) |
| with torch.no_grad(): |
| _, cache = model.run_with_cache(ids, names_filter=hooks, |
| return_type=None) |
| sidx = sid_of_id[chunk[:, first:]].ravel() |
| np.add.at(occ, sidx, 1) |
| for L in a.layers: |
| resid = cache[S.HOOKS[L]][:, first:, :].reshape(-1, model.cfg.d_model) |
| W, be, bd = saes[L] |
| acts = torch.relu((resid - bd) @ W + be) |
| fpos, ffeat = torch.nonzero(acts > THR, as_tuple=True) |
| if len(fpos): |
| counters[L].add(ffeat.cpu().numpy(), sidx[fpos.cpu().numpy()]) |
| del cache |
| done = min(b0 + a.batch, n_seq) |
| if (b0 // a.batch) % 50 == 0 or done == n_seq: |
| el = time.time() - t0 |
| rate = done / max(el, 1e-9) |
| print(f" {done:,}/{n_seq:,} seqs {el/60:.1f} min " |
| f"{rate:.0f} seq/s eta {max(n_seq-done,0)/max(rate,1e-9)/60:.0f} min", |
| flush=True) |
|
|
| out = Path(a.out) if a.out else (HERE / ("counts_pilot.npz" if a.limit |
| else "counts_300k.npz")) |
| saved = {"strings": uniq, "occ": occ, "n_seq": n_seq, "n_read": n_read, |
| "threshold": THR} |
| for L in a.layers: |
| k, c = counters[L].finalize(n_features=24576) |
| saved[f"keys_{L}"] = k |
| saved[f"cnt_{L}"] = c.astype(np.int32) |
| print(f" layer {L}: {len(k):,} distinct (feature,string) pairs, " |
| f"{int(c.sum()):,} firings", flush=True) |
| del counters[L].keys, counters[L].cnt |
| np.savez(out, **saved) |
| print(f"\nwrote {out} ({out.stat().st_size/1e9:.2f} GB) " |
| f"total {(time.time()-t0)/60:.1f} min") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
