Download lu-replication/run-003/code/worker_geometry_v2.py from Parth4105/persona-artifacts: direct link, hf CLI and curl.
- Browser
- Download file 16.7 kB
-
https://huggingface.co/datasets/Parth4105/persona-artifacts/resolve/main/lu-replication/run-003/code/worker_geometry_v2.py
- Command line
-
hf download hf://datasets/Parth4105/persona-artifacts/lu-replication/run-003/code/worker_geometry_v2.py
-
curl -L -o worker_geometry_v2.py https://huggingface.co/datasets/Parth4105/persona-artifacts/resolve/main/lu-replication/run-003/code/worker_geometry_v2.py
16.7 kB
| # ============================================================================ | |
| # 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.") |