| """Fit token-only programs from the 300k-sequence contingency tables and score |
| them on the UNCHANGED test split. |
| |
| Design decisions that make this comparable to the shipped run: |
| * Same selection pipeline (S.select_tokens): resolve_min_fires -> best_k(50) |
| -> expand_roots -> prune_tail_families. Nothing is retuned for scale. |
| * Same test split, untouched: owt_test_tokens.npz, 1,270,000 read positions. |
| Only the FITTING corpus changes, so every delta is attributable to data. |
| * Same scorer: S.score_batch runs the emitted programs over the corpus, which |
| is what produced the shipped numbers. |
| |
| The two rate-based constants carry over correctly by construction: |
| resolve_min_fires gates on firings/positions, and TAIL_SHARE is a share, so |
| both mean the same thing at 36.8M positions as at 1.27M. MIN_FIRES_IN_SET |
| stays absolute on purpose -- two observations is thin evidence however long you |
| looked, and a string seen once at 1.27M positions is seen ~29 times here and |
| stops being thin, which is the intended behaviour. |
| |
| python fit_programs.py --layer 6 --emit |
| """ |
| from __future__ import annotations |
| import argparse, csv, json, sys, time |
| from pathlib import Path |
| import numpy as np |
|
|
| 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, CAP, MIN_POS = 0.1, 50, 5 |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--layer", type=int, required=True) |
| ap.add_argument("--emit", action="store_true") |
| ap.add_argument("--jobs", type=int, default=8) |
| ap.add_argument("--counts", default=str(HERE / "counts_300k.npz")) |
| a = ap.parse_args() |
| L = a.layer |
|
|
| z = np.load(a.counts, allow_pickle=True) |
| strings = z["strings"] |
| occ_tr = z["occ"] |
| NS = len(strings) |
| n_seq, n_read = int(z["n_seq"]), int(z["n_read"]) |
| n_positions = n_seq * n_read |
| keys, cnt = z[f"keys_{L}"], z[f"cnt_{L}"] |
| feat = (keys // NS).astype(np.int64) |
| sid = (keys % NS).astype(np.int64) |
| print(f"[layer {L}] fitting corpus {n_seq:,} seqs = {n_positions:,} positions " |
| f"({n_positions/1_270_000:.1f}x shipped); {len(keys):,} (feature,string) pairs", |
| flush=True) |
|
|
| bounds = np.searchsorted(feat, np.arange(24577)) |
| occ_lookup = {int(i): int(occ_tr[i]) for i in np.unique(sid)} |
|
|
| out_dir = HERE / f"layer{L}_thr0p1" / "capped50" |
| (out_dir / "programs").mkdir(parents=True, exist_ok=True) |
| rows, items, meta = [], [], {} |
| t0 = time.time() |
| for f in range(24576): |
| i0, i1 = int(bounds[f]), int(bounds[f + 1]) |
| n_pos = int(cnt[i0:i1].sum()) |
| if i1 <= i0 or n_pos < MIN_POS: |
| rows.append({"layer": L, "feature": f, "status": "too_rare", |
| "f1": 0.0, "precision": 0.0, "recall": 0.0, |
| "n_pos_train": n_pos}) |
| continue |
| s_ids, fires = sid[i0:i1], cnt[i0:i1].astype(np.int64) |
| order = np.argsort(-fires) |
| cum = 0 |
| rws = [] |
| for j in order: |
| t = str(strings[s_ids[j]]) |
| fr = int(fires[j]) |
| ap_ = max(occ_lookup.get(int(s_ids[j]), fr), fr) |
| cum += fr |
| rws.append({"token": t, "token_ids": [int(s_ids[j])], "fires": fr, |
| "appears": ap_, "p_fire": fr / ap_, |
| "lift": (fr / ap_) / (n_pos / n_positions), |
| "cum_recall": cum / n_pos}) |
| opt_f1, opt_toks = S.token_optimum(rws, n_pos) |
| ct = S.Contingency(L, f, THR, n_positions, n_pos, rws, [t["token"] for t in rws[:50]], |
| opt_f1, opt_toks) |
| code = S.grouped_token_program(L, f, ct, cap=CAP) |
| if code is None: |
| rows.append({"layer": L, "feature": f, "status": "no_tokens", |
| "f1": 0.0, "precision": 0.0, "recall": 0.0, |
| "n_pos_train": n_pos}) |
| continue |
| toks = S.select_tokens(ct, cap=CAP) |
| items.append((f, code, S.prog_name(L, f))) |
| meta[f] = {"layer": L, "feature": f, "status": "ok", "regime": ct.regime, |
| "token_optimum": round(opt_f1, 4), "n_tokens": len(toks), |
| "n_families": len({S.word_root(t) for t in toks}), |
| "n_tokens_uncapped": len(opt_toks), "n_pos_train": n_pos} |
| if a.emit: |
| d = out_dir / "programs" / f"{f // 1000:02d}" |
| d.mkdir(parents=True, exist_ok=True) |
| (d / f"{S.feature_key(L, f)}.py").write_text(code) |
| if (f + 1) % 5000 == 0: |
| print(f" select {f+1:,}/24,576 {(time.time()-t0)/60:.1f} min", flush=True) |
|
|
| print(f"[emit] {len(items):,} programs in {(time.time()-t0)/60:.1f} min; scoring " |
| f"on the UNCHANGED test split...", flush=True) |
| scores = S.score_batch(ROOT / f"synthesis/layer{L}_thr0p1/stores/store_L{L:02d}_test.npz", |
| C.CACHE / "owt_test_tokens.npz", |
| ROOT / "layer_plots" / "vocab_strings.npy", |
| items, THR, C.FIRST_READ_POSITION, workers=a.jobs) |
| for f, _, _ in items: |
| sc = dict(scores[f]); sc.update(meta[f]); rows.append(sc) |
|
|
| cols = ["layer", "feature", "status", "regime", "token_optimum", "n_tokens", |
| "n_families", "n_tokens_uncapped", "n_pos_train", "precision", |
| "recall", "f1", "tp", "fp", "fn", "tn", "errors", "n_positions"] |
| out = out_dir / "scores_test.csv" |
| with open(out, "w", newline="") as fh: |
| w = csv.DictWriter(fh, fieldnames=cols, extrasaction="ignore") |
| w.writeheader(); w.writerows(rows) |
| ok = [r for r in rows if r.get("status") == "ok"] |
| f1 = np.array([r["f1"] for r in ok]) |
| nt = np.array([r["n_tokens"] for r in ok]) |
| print(f"\n=== layer {L}: {len(rows):,} features, {len(ok):,} scored, " |
| f"{(time.time()-t0)/60:.1f} min ===") |
| print(f"TEST F1 median {np.median(f1):.4f} mean {f1.mean():.4f} max {f1.max():.4f}") |
| print(f"program size: median {np.median(nt):.0f} strings") |
| print(f"above 0.8: {(f1>0.8).mean():.1%}") |
| print(f"wrote {out}", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
