selection/count_fires.py

"""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          # merge pending keys once the buffer reaches this
SPILL_PAIRS = 40_000_000    # spill a layer to disk once its table exceeds this


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()