persona-artifacts / lu-replication /run-003 /code /worker_geometry_v2.py
Parth4105's picture
Upload lu-replication/run-003/code/worker_geometry_v2.py with huggingface_hub
5964f0e verified
Raw History Blame Contribute Delete
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.")