v0.2: sweep retracts the fusion-gap reading (storage-position asymmetry: bert front-loads, t5 back-loads; student concat 0.954 > teacher); sequence entry: all 999 states, control still fails, embedding table byte-arbitrary

proto_frame/proto_v02_gauge.py

@@ -0,0 +1,97 @@
+"""v0.2 sweep gauge: (side x layer x readout) identification against
+the FROZEN v0.1 codebook. Same sites/splits/seed as v0.1; L_id only
+(bridge row notes the protocol delta vs v0.1's id+mse student row).
+Readouts: first, last, concat[first,last] — linear maps only."""
+import json
+import sys
+import zlib
+
+sys.path.insert(0, r"E:\mirel\geolip-bytelex")
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+import numpy as np
+import torch
+import torch.nn.functional as F
+from geolip.bytelex.frame import (apply_whitening, fit_whitening,
+                                  procrustes, split_sites,
+                                  top_k_accuracy)
+
+D = r"E:\mirel\data\bytelex\proto_frame"
+DEV = "cuda"
+SEED = zlib.crc32(b"frame-proto-v01") & 0xFFFFFFFF
+torch.manual_seed(SEED)
+
+dump = np.load(rf"{D}\frame_dump_v2.npz")
+sweep = np.load(rf"{D}\sweep_dump_v02.npz")
+anch = np.load(rf"{D}\frame_anchors_v01.npz")
+states = json.load(open(r"E:\mirel\data\bytelex\words_of_C.json",
+                        encoding="utf-8"))
+CLS = np.array(["digit" if s["text"].isdigit() else
+                ("Name" if s["text"][0].isupper() else "word")
+                for s in states])
+sid = dump["sid"].astype(np.int64)
+KK = dump["KK"]
+ok = KK[:, 0] > 0
+sp = split_sites(sid[ok], seed=SEED)
+gix = {k: np.flatnonzero(ok)[v] for k, v in sp.items()}
+E_C = torch.tensor(anch["E_C"], dtype=torch.float32, device=DEV)
+E_Cn = F.normalize(E_C, dim=-1)
+sT = torch.tensor(float(anch["s"]), device=DEV)
+tsid = torch.tensor(sid, device=DEV)
+
+
+def run_config(H, tag):
+    mu, w = fit_whitening(H[gix["fit"]].astype(np.float64))
+    Z = apply_whitening(H.astype(np.float64), mu, w)
+    m = np.zeros((999, Z.shape[1]))
+    for s in range(999):
+        r = gix["train"][sid[gix["train"]] == s]
+        if len(r):
+            m[s] = Z[r].mean(0)
+    W = torch.nn.Parameter(torch.tensor(
+        procrustes(m, anch["E_C"].astype(np.float64)),
+        dtype=torch.float32, device=DEV))
+    tZ = torch.tensor(Z, dtype=torch.float32, device=DEV)
+    opt = torch.optim.Adam([W], lr=1e-3, weight_decay=0.0)
+    rng = np.random.default_rng(SEED + 7)
+    for ep in range(6):
+        order = rng.permutation(gix["train"])
+        for i in range(0, len(order), 512):
+            b = torch.tensor(order[i:i + 512], device=DEV)
+            opt.zero_grad(set_to_none=True)
+            zf = F.normalize(tZ[b] @ W, dim=-1)
+            lg = sT.clamp(1, 100) * (zf @ E_Cn.T)
+            F.cross_entropy(lg, tsid[b]).backward()
+            opt.step()
+    ev = gix["eval"]
+    with torch.no_grad():
+        zf = F.normalize(tZ[torch.tensor(ev, device=DEV)] @ W, -1)
+        lg = (sT * zf @ E_Cn.T).cpu().numpy()
+    out = {"overall": round(top_k_accuracy(lg, sid[ev]), 4)}
+    for c in ("word", "Name", "digit"):
+        mm = CLS[sid[ev]] == c
+        out[c] = round(top_k_accuracy(lg[mm], sid[ev][mm]), 4)
+    print(f"[v02 {tag}] {json.dumps(out)}", flush=True)
+    return out
+
+
+led = {"_protocol": "L_id only, frozen v0.1 E_C, 6 epochs; v0.1 "
+                    "student row (L6 first) trained id+mse — bridge "
+                    "row re-run here id-only for comparability"}
+LB, LT = sweep["LB"].tolist(), sweep["LT"].tolist()
+for j, l in enumerate(LT):
+    for ri, rname in ((0, "first"), (1, "last")):
+        led[f"student_L{l}_{rname}"] = run_config(
+            sweep["ST"][:, j, ri], f"student L{l} {rname}")
+    led[f"student_L{l}_concat"] = run_config(
+        np.concatenate([sweep["ST"][:, j, 0], sweep["ST"][:, j, 1]],
+                       axis=1), f"student L{l} concat")
+for j, l in enumerate(LB):
+    led[f"teacher_L{l}_first"] = run_config(
+        sweep["SB"][:, j, 0].astype(np.float32), f"teacher L{l} first")
+led["teacher_L8_concat"] = run_config(
+    np.concatenate([sweep["SB"][:, 2, 0], sweep["SB"][:, 2, 1]],
+                   axis=1).astype(np.float32), "teacher L8 concat")
+
+with open(rf"{D}\v02_sweep_ledger.json", "w", encoding="utf-8") as f:
+    json.dump(led, f, indent=1)
+print("[v02] SWEEP COMPLETE", flush=True)