# ============================================================================ # BLOCK 1 - H2 REBUILD. CPU only. Writes *_v2 artifacts; touches nothing published. # # Fixes, in order: # T1 panel halves rebalanced on prompt variant (variant == panel_index % 5, # so the old length-only stratification left half B with 3x the variant-4 # questions of half A). question_ids are UNCHANGED -> no regeneration. # T2 split-half cosine replaced by correlation of role projections, which has # real dynamic range, plus a role-label permutation null that actually moves. # T7 bootstrap and LORO recomputed on the new statistic; H4 compared on a FIXED # role set; per-layer nulls for the whole 32-layer curve. # ============================================================================ CFG = { "OUT_ROOT": "/home/jupyter-ayjp-e788/assistant_axis", "HF_REPO": "Parth4105/persona-artifacts", "RUN_ID": "lu-replication/run-003", "COND": "USER_EXPLICIT", "MID": 16, # T02 may change this; Block 5 re-runs with the new value "MIN_RETAINED": 10, "MIN_PER_HALF": 5, "N_PERM": 2000, # role-label permutation null (per layer) "N_SPLIT": 300, # random variant-balanced 40/40 splits (middle layer) "N_BOOT": 2000, "SEED": 0, "HF_PUSH": True, } import json, collections, hashlib, time, gc, sys from pathlib import Path import numpy as np, torch from safetensors.torch import load_file ROOT = Path(CFG["OUT_ROOT"]); ex, de = ROOT/"extraction", ROOT/"default" MID, SEED = CFG["MID"], CFG["SEED"] rng = np.random.default_rng(SEED) def need(rel): """Local file, else pull it from the Hub.""" p = ROOT / rel if p.exists(): return p from huggingface_hub import hf_hub_download print(f" fetching {rel} from the Hub ...") p.parent.mkdir(parents=True, exist_ok=True) d = hf_hub_download(CFG["HF_REPO"], f"{CFG['RUN_ID']}/{rel}", repo_type="dataset") return Path(d) # ---- 1. inputs ------------------------------------------------------------- panel = json.loads(need("design/panel.json").read_text("utf-8")) PANEL = panel["question_ids"] assert len(PANEL) == 80 meta = {} for l in need("extraction/pooled_meta.jsonl").read_text("utf-8").splitlines(): if l.strip(): m = json.loads(l); meta[m["uid"]] = m scores = {} for l in need("extraction/scores.jsonl").read_text("utf-8").splitlines(): if l.strip(): s = json.loads(l); scores[s["uid"]] = s print(f"{len(meta)} pooled, {len(scores)} scored") # question text for length balance; fall back to id order if the vendor tree is gone try: D = ROOT/"vendor"/"assistant-axis"/"data" QT = {json.loads(l)["id"]: json.loads(l)["question"] for l in (D/"extraction_questions.jsonl").read_text("utf-8").splitlines() if l.strip()} qlen = {q: len(QT[q]) for q in PANEL} except Exception as e: print(f" no vendor questions ({type(e).__name__}); balancing on question_id order") qlen = {q: q for q in PANEL} # ---- 2. variant-balanced halves (T1) -------------------------------------- # prompt_idx was assigned as (index in PANEL) % 5, so variant is a deterministic # function of question position. Split each residue class 8/8, ordered by length, # so both halves get 8 questions of every variant AND matched length spread. variant = {q: i % 5 for i, q in enumerate(PANEL)} HA2, HB2 = [], [] for v in range(5): cls = sorted([q for q in PANEL if variant[q] == v], key=lambda q: qlen[q]) HA2 += cls[0::2]; HB2 += cls[1::2] HA2, HB2 = sorted(HA2), sorted(HB2) assert len(HA2) == len(HB2) == 40 and not set(HA2) & set(HB2) va = collections.Counter(variant[q] for q in HA2) vb = collections.Counter(variant[q] for q in HB2) print(f"panel_v2 variant balance A={dict(sorted(va.items()))} B={dict(sorted(vb.items()))}") assert set(va.values()) == {8} and set(vb.values()) == {8} old_a = collections.Counter(variant[q] for q in panel["half_a_ids"]) print(f" (old half A was {dict(sorted(old_a.items()))} - this is what we are fixing)") FP2 = hashlib.sha256(json.dumps([PANEL, HA2, HB2]).encode()).hexdigest()[:16] panel2 = {"seed": SEED, "n": 80, "question_ids": PANEL, "half_a_ids": HA2, "half_b_ids": HB2, "fingerprint": FP2, "strategy": "halves balanced on prompt variant (index%5), 8 per variant " "per half, ordered by question length within variant. " "question_ids identical to panel.json - no regeneration.", "supersedes": "design/panel.json halves"} (ROOT/"design").mkdir(parents=True, exist_ok=True) (ROOT/"design"/"panel_v2.json").write_text(json.dumps(panel2, indent=2), "utf-8") print(f"panel_v2 fingerprint {FP2}") # ---- 3. retention on the new halves (no tensors needed) -------------------- SA, SB = set(HA2), set(HB2) ret = collections.defaultdict(list); half = collections.defaultdict(lambda: [0, 0]) for uid, m in meta.items(): if m.get("condition") != CFG["COND"]: continue s = scores.get(uid) if not s or not s.get("retained"): continue ret[m["role"]].append(uid) if m["question_id"] in SA: half[m["role"]][0] += 1 elif m["question_id"] in SB: half[m["role"]][1] += 1 FULL = sorted(r for r, u in ret.items() if len(u) >= CFG["MIN_RETAINED"]) SH = sorted(r for r in FULL if min(half[r]) >= CFG["MIN_PER_HALF"]) print(f"retained full-role vectors {len(FULL)} (gate 180) | split-half eligible " f"{len(SH)} (gate 150) | {'PASS' if len(FULL)>=180 and len(SH)>=150 else 'FAIL'}") # how many clear Lu's own min_count=50, and the proportional equivalent 17/80 n50 = sum(1 for r in ret if len(ret[r]) >= 50) n17 = sum(1 for r in ret if len(ret[r]) >= 17) print(f"roles clearing Lu's min_count=50: {n50} | proportional equivalent 17/80: {n17}") # ---- 4. one streaming pass -> per-role means at ALL layers ----------------- FULLS, SHS = set(FULL), set(SH) shards = sorted(ex.glob("pooled_primary_*.safetensors")) if not shards: shards = [need(f"extraction/pooled_primary_{i:02d}.safetensors") for i in range(3)] groups = ("full", "half_a", "half_b", "unfilt") acc, cnt = {g: {} for g in groups}, {g: collections.Counter() for g in groups} NL = H = None t0 = time.time() for sh in shards: st = load_file(str(sh)) for uid, t in st.items(): m = meta.get(uid) if m is None or m.get("condition") != CFG["COND"]: continue r = m["role"] if r not in FULLS: continue # H4 fix: SAME role set, filtered or not if NL is None: NL, H = t.shape v = t.float().numpy() def add(g): a = acc[g].get(r) if a is None: a = acc[g][r] = np.zeros((NL, H), np.float32) a += v; cnt[g][r] += 1 add("unfilt") s = scores.get(uid) if not s or not s.get("retained"): continue add("full") if r in SHS: if m["question_id"] in SA: add("half_a") elif m["question_id"] in SB: add("half_b") del st; gc.collect() print(f" {sh.name} done ({time.time()-t0:.0f}s)") means = {g: {r: acc[g][r]/cnt[g][r] for r in acc[g]} for g in groups} del acc; gc.collect() print(f"{NL} layers, hidden {H}; role means built for {len(means['full'])} roles") dst = de/"pooled_primary_00.safetensors" dst = dst if dst.exists() else need("default/pooled_primary_00.safetensors") dd = load_file(str(dst)) DEF = np.stack([t.float().numpy() for t in dd.values()]).mean(0) # (NL,H) unfiltered print(f"default vector from {len(dd)} unfiltered outputs (Lu's construction)") del dd; gc.collect() # ---- 5. statistics --------------------------------------------------------- def unit(x): return x / (np.linalg.norm(x) + 1e-12) def pearson(a, b): a, b = a - a.mean(), b - b.mean() return float(a @ b / (np.linalg.norm(a)*np.linalg.norm(b) + 1e-12)) def rank(x): o = np.argsort(x, kind="mergesort"); r = np.empty(len(x), float); r[o] = np.arange(len(x)) _, inv, c = np.unique(x, return_inverse=True, return_counts=True) # average ties s = np.zeros(len(c)); np.add.at(s, inv, r); return (s/c)[inv] def spearman(a, b): return pearson(rank(a), rank(b)) def cos(a, b): return float(a @ b / (np.linalg.norm(a)*np.linalg.norm(b) + 1e-12)) R = sorted(means["half_a"]) # roles with both halves MA = np.stack([means["half_a"][r] for r in R]) # (nR, NL, H) MB = np.stack([means["half_b"][r] for r in R]) MF = np.stack([means["full"][r] for r in FULL]) MU = np.stack([means["unfilt"][r] for r in FULL]) print(f"statistic on {len(R)} roles; axes from {len(FULL)} roles") per_layer = [] for L in range(NL): d = DEF[L] ua, ub = unit(d - MA[:, L].mean(0)), unit(d - MB[:, L].mean(0)) uf = unit(d - MF[:, L].mean(0)) pa, pb = MA[:, L] @ ua, MB[:, L] @ ub # independent-axis projections fa, fb = MA[:, L] @ uf, MB[:, L] @ uf # fixed-axis projections r_ind, r_fix, rho = pearson(pa, pb), pearson(fa, fb), spearman(pa, pb) # role-label permutation null: shuffling roles leaves the axis (a grand mean) # untouched but destroys the pairing, so this null has real variance. nul = np.array([pearson(pa, pb[rng.permutation(len(R))]) for _ in range(CFG["N_PERM"])]) per_layer.append({ "layer": L, "r_independent_axes": round(r_ind, 4), "r_fixed_axis": round(r_fix, 4), "spearman": round(rho, 4), "cosine_axes_legacy": round(cos(d - MA[:, L].mean(0), d - MB[:, L].mean(0)), 4), "null_mean": round(float(nul.mean()), 4), "null_sd": round(float(nul.std()), 4), "z": round(float((r_ind - nul.mean())/(nul.std() + 1e-12)), 2), "p_emp": float((nul >= r_ind).mean())}) if L == MID: NUL_MID = nul M = per_layer[MID] print(f"\nMIDDLE LAYER {MID}") print(f" r (independent axes) {M['r_independent_axes']:.4f} " f"null {M['null_mean']:.4f} +- {M['null_sd']:.4f} z={M['z']} p={M['p_emp']:.4g}") print(f" r (fixed full axis) {M['r_fixed_axis']:.4f}") print(f" spearman {M['spearman']:.4f}") print(f" legacy cosine {M['cosine_axes_legacy']:.4f} <- the ceilinged number") # bootstrap + LORO on the new statistic (real dynamic range now) d = DEF[MID] ua, ub = unit(d - MA[:, MID].mean(0)), unit(d - MB[:, MID].mean(0)) pa, pb = MA[:, MID] @ ua, MB[:, MID] @ ub boot = np.array([pearson(pa[i], pb[i]) for i in (rng.integers(0, len(R), len(R)) for _ in range(CFG["N_BOOT"]))]) keep = np.arange(len(R)) loro = np.array([pearson(pa[keep != i], pb[keep != i]) for i in range(len(R))]) print(f" bootstrap CI95 [{np.percentile(boot,2.5):.4f}, {np.percentile(boot,97.5):.4f}]") print(f" LORO min {loro.min():.4f} max {loro.max():.4f} " f"(most influential: {R[int(loro.argmin())]})") # ---- 6. random variant-balanced splits, middle layer (T1 sensitivity) ------ rm = ex/"reduced_rollout_middle.safetensors" rm = rm if rm.exists() else need("extraction/reduced_rollout_middle.safetensors") mid_st = load_file(str(rm)) keep_uids = [u for r in SH for u in ret[r]] V = np.stack([mid_st[u].float().numpy() for u in keep_uids]) # (n, H) ri = np.array([R.index(meta[u]["role"]) for u in keep_uids]) qi = np.array([meta[u]["question_id"] for u in keep_uids]) del mid_st; gc.collect() byv = {v: [q for q in PANEL if variant[q] == v] for v in range(5)} splits = [] for _ in range(CFG["N_SPLIT"]): A = set() for v in range(5): A |= set(rng.choice(byv[v], 8, replace=False)) ma, mb = np.isin(qi, list(A)), ~np.isin(qi, list(A)) ca, cb = np.bincount(ri[ma], minlength=len(R)), np.bincount(ri[mb], minlength=len(R)) ok = (ca >= CFG["MIN_PER_HALF"]) & (cb >= CFG["MIN_PER_HALF"]) if ok.sum() < 50: continue Ia = np.zeros((len(R), len(V)), np.float32); Ia[ri[ma], np.where(ma)[0]] = 1 Ib = np.zeros((len(R), len(V)), np.float32); Ib[ri[mb], np.where(mb)[0]] = 1 A_ = (Ia @ V)[ok] / ca[ok, None]; B_ = (Ib @ V)[ok] / cb[ok, None] dm = DEF[MID] splits.append(pearson(A_ @ unit(dm - A_.mean(0)), B_ @ unit(dm - B_.mean(0)))) splits = np.array(splits) print(f" across {len(splits)} random variant-balanced splits: mean {splits.mean():.4f} " f"CI95 [{np.percentile(splits,2.5):.4f}, {np.percentile(splits,97.5):.4f}]") # ---- 7. H4 on a FIXED role set, and PC1 ----------------------------------- ax_f = DEF[MID] - MF[:, MID].mean(0); ax_u = DEF[MID] - MU[:, MID].mean(0) h4 = {"roles_both": len(FULL), "cosine_filtered_vs_unfiltered": round(cos(ax_f, ax_u), 4), "note": "same 262 roles on both sides; the old comparison used 275 unfiltered " "vs 262 filtered and confounded filtering with role set"} print(f"\nH4 filtered vs unfiltered axis, same {len(FULL)} roles: " f"cosine {h4['cosine_filtered_vs_unfiltered']:.4f}") Mc = MF[:, MID] - MF[:, MID].mean(0) _, S, Vt = np.linalg.svd(Mc, full_matrices=False) var = S**2/(S**2).sum(); pc1 = Vt[0] if pc1 @ ax_f < 0: pc1 = -pc1 proj = Mc @ pc1; dpos = (DEF[MID] - MF[:, MID].mean(0)) @ pc1 beyond = [FULL[i] for i in np.where(proj > dpos)[0]] rel = float((dpos - proj.min())/(proj.max() - proj.min() + 1e-12)) print(f"PC1 var {var[0]:.4f} | axis-PC1 cos {cos(pc1, ax_f):.4f} | default rel pos {rel:.4f}") print(f" roles projecting BEYOND the default on PC1 ({len(beyond)}): {beyond}") # ---- 8. write + push ------------------------------------------------------- out = { "supersedes": "extraction/geometry.json H2_reliability + stability blocks", "panel": "design/panel_v2.json", "panel_fingerprint": FP2, "middle_layer": MID, "n_layers": NL, "condition": CFG["COND"], "gates": {"retained_full_role_vectors": len(FULL), "split_half_eligible_roles": len(SH), "pass": bool(len(FULL) >= 180 and len(SH) >= 150), "min_retained": CFG["MIN_RETAINED"], "roles_clearing_lu_min_count_50": n50, "roles_clearing_proportional_17_of_80": n17, "note": "Lu's 4_vectors.py default is min_count=50 on 240 questions " "(20.8%); 10 of 80 is 12.5%. The proportional equivalent is 17."}, "H2": {"primary": "pearson correlation across roles of projections onto the " "half-specific Axis; the legacy cosine is reported alongside " "because its null sits at 0.96 and it cannot fall below it", "middle": M, "per_layer": per_layer, "bootstrap_ci95": [round(float(np.percentile(boot, 2.5)), 4), round(float(np.percentile(boot, 97.5)), 4)], "loro_min": round(float(loro.min()), 4), "loro_max": round(float(loro.max()), 4), "most_influential_role": R[int(loro.argmin())], "random_split_mean": round(float(splits.mean()), 4), "random_split_ci95": [round(float(np.percentile(splits, 2.5)), 4), round(float(np.percentile(splits, 97.5)), 4)], "n_splits": len(splits), "n_perm": CFG["N_PERM"], "n_roles": len(R)}, "H4": h4, "pc1_descriptive": {"variance_fraction": round(float(var[0]), 4), "components_to_70pct": int(np.searchsorted(np.cumsum(var), 0.70)+1), "axis_to_pc1_cosine": round(cos(pc1, ax_f), 4), "default_relative_position": round(rel, 4), "roles_projecting_beyond_default": beyond, "note": "the position statistic can exceed 1; 0.93 means the default is near, " "not at, the extreme"}, } (ex/"geometry_v2.json").write_text(json.dumps(out, indent=2), "utf-8") np.save(ex/"h2_v2_perm_null_middle.npy", NUL_MID) np.save(ex/"h2_v2_split_distribution.npy", splits) np.save(ex/"h2_v2_bootstrap.npy", boot) print("\nwrote geometry_v2.json + 3 distributions") if CFG["HF_PUSH"]: from huggingface_hub import HfApi api = HfApi() src = ROOT/"worker_geometry_v2.py" try: src.write_text(In[-1], "utf-8") # archive this cell verbatim except Exception: src.write_text("# source not captured\n", "utf-8") for lp, dest in ((ROOT/"design"/"panel_v2.json", "design/panel_v2.json"), (ex/"geometry_v2.json", "extraction/geometry_v2.json"), (ex/"h2_v2_perm_null_middle.npy", "extraction/h2_v2_perm_null_middle.npy"), (ex/"h2_v2_split_distribution.npy", "extraction/h2_v2_split_distribution.npy"), (ex/"h2_v2_bootstrap.npy", "extraction/h2_v2_bootstrap.npy"), (src, "code/worker_geometry_v2.py")): api.upload_file(path_or_fileobj=str(lp), repo_id=CFG["HF_REPO"], repo_type="dataset", path_in_repo=f"{CFG['RUN_ID']}/{dest}") print(f" pushed {dest}") print("\nReport r_independent_axes with its permutation null. Report the legacy " "cosine only next to its 0.96 null, never alone.")