#!/usr/bin/env python """ISS: Internal State Stability. (protocol 7, J-Lens spec 10) python src/iss.py --model Llama-3.2-1B --transport raw # ablation python src/iss.py --model Llama-3.2-1B --transport jlens # official The state preparation (transport -> residualise -> whiten -> family centroid) lives in states.py so that ISS and KTS provably score the same vectors. What is here is only the ISS-specific part: S+ same fact, across condition-family pairs S- same relation, different fact, symmetric in the family pair ISS = (S+ - S-) / (1 - S- + eps) Raw-ISS is NOT the official metric (J-Lens spec 11). It exists to prove the data loading, family aggregation and negative sampling are right before the Jacobian transport is layered on top (spec 21, step 1). """ import os, sys, time, argparse import numpy as np import torch sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) import mcommon as mc from states import StateLoader def iss_one_layer(V, mask, by_rel, negatives, eps): """S+, S- and ISS for every fact at one layer.""" F, T, _ = V.shape dev = V.device s_pos = torch.zeros(F, device=dev) s_neg = torch.zeros(F, device=dev) n_pos = torch.zeros(F, device=dev) n_neg = torch.zeros(F, device=dev) zero = torch.zeros(F, device=dev) for t in range(T): for u in range(t + 1, T): both = mask[:, t] & mask[:, u] if not bool(both.any()): continue s_pos += torch.where(both, (V[:, t] * V[:, u]).sum(-1), zero) n_pos += both.float() # Protocol 7.8: same-relation background, symmetrised over the pair # so a family that sits globally closer to everything cannot inflate # the score. Done per relation to keep each similarity block small. for members in by_rel.values(): idx = [i for i in members if bool(both[i])] if len(idx) < 2: continue ii = torch.tensor(idx, device=dev) Sab = V[ii, t] @ V[ii, u].T pos = {f: j for j, f in enumerate(idx)} for f in idx: negs = [pos[g] for g in negatives[f] if g in pos] if not negs: continue jj = torch.tensor(negs, device=dev) j0 = pos[f] s_neg[f] += 0.5 * (Sab[j0, jj].mean() + Sab[jj, j0].mean()) n_neg[f] += 1 sp = s_pos / n_pos.clamp_min(1) sn = s_neg / n_neg.clamp_min(1) return sp, sn, (sp - sn) / (1.0 - sn + eps), (n_pos > 0) & (n_neg > 0) def main(): ap = argparse.ArgumentParser() ap.add_argument("--model", required=True) ap.add_argument("--transport", choices=["raw", "jlens"], default="raw") ap.add_argument("--coverage", choices=["complete_family", "full_set"], default=None) ap.add_argument("--device", default="auto") ap.add_argument("--shuffle-seed", type=int, default=None, help="protocol 18.1 control: destroy fact identity; ISS must collapse") args = ap.parse_args() C = mc.cfg() icfg = C["iss"] eps = float(icfg["eps"]) S = StateLoader(args.model, args.transport, args.coverage, args.device, shuffle_seed=args.shuffle_seed) negatives = mc.negative_sample(S.keep_facts, S.rel_of, icfg["max_negatives"], icfg["negative_seed"]) negatives = {S.fidx[f]: [S.fidx[g] for g in gs] for f, gs in negatives.items()} F = S.n_facts per_layer, t0 = {}, time.time() for l in S.window: V, mask = S.centroids(l) sp, sn, iss, valid = iss_one_layer(V, mask, S.by_rel, negatives, eps) per_layer[l] = {"s_pos": sp.cpu().numpy(), "s_neg": sn.cpu().numpy(), "iss": iss.cpu().numpy(), "valid": valid.cpu().numpy()} print(f" L{l:03d} ISS={float(iss[valid].mean()):+.4f} " f"S+={float(sp[valid].mean()):.4f} S-={float(sn[valid].mean()):.4f}", flush=True) del V, mask if S.dev == "cuda": torch.cuda.empty_cache() # ---- protocol 7.10: window mean, peak, late stack = np.stack([per_layer[l]["iss"] for l in S.window]) vmask = np.stack([per_layer[l]["valid"] for l in S.window]) stack = np.where(vmask, stack, np.nan) late_rows = [i for i, l in enumerate(S.window) if l in S.late] with np.errstate(invalid="ignore"): iss_f = np.nanmean(stack, axis=0) peak_f = np.nanmax(stack, axis=0) late_f = np.nanmean(stack[late_rows], axis=0) if late_rows else np.full(F, np.nan) rows = [{"model": args.model, "transport": args.transport, "fact_id": f, "relation": S.rel_of[f], "iss": float(iss_f[i]), "iss_peak": float(peak_f[i]), "iss_late": float(late_f[i]), "layers_used": S.window} for i, f in enumerate(S.keep_facts) if np.isfinite(iss_f[i])] tag = f"{args.model}.{args.transport}.{S.mode}" if args.shuffle_seed is not None: tag += f".shuffled{args.shuffle_seed}" mc.write_jsonl(mc.out("metrics", "iss", f"{tag}.per_fact.jsonl"), rows) mc.write_jsonl(mc.out("metrics", "iss", f"{tag}.per_fact_layer.jsonl"), [{"model": args.model, "transport": args.transport, "fact_id": f, "layer": l, "iss": float(per_layer[l]["iss"][i]), "s_positive": float(per_layer[l]["s_pos"][i]), "s_background": float(per_layer[l]["s_neg"][i])} for l in S.window for i, f in enumerate(S.keep_facts) if per_layer[l]["valid"][i]]) vals = {r["fact_id"]: r["iss"] for r in rows} boot = mc.relation_clustered_bootstrap( vals, S.rel_of, C["bootstrap"]["n_resamples"], C["bootstrap"]["seed"], C["bootstrap"]["ci"]) summary = { "model": args.model, "transport": args.transport, "coverage_mode": S.mode, "official": args.transport == "jlens" and args.shuffle_seed is None, "shuffle_control": args.shuffle_seed is not None, "n_facts": len(rows), "layers": S.window, "iss": boot["mean"], "iss_ci95": [boot["lo"], boot["hi"]], "iss_peak": float(np.nanmean(peak_f)), "iss_late": float(np.nanmean(late_f)), "s_positive": float(np.nanmean([per_layer[l]["s_pos"] for l in S.window])), "s_background": float(np.nanmean([per_layer[l]["s_neg"] for l in S.window])), "per_layer_iss": {str(l): float(np.nanmean(np.where( per_layer[l]["valid"], per_layer[l]["iss"], np.nan))) for l in S.window}, "seconds": round(time.time() - t0, 1), } mc.write_json(mc.out("metrics", "iss", f"{tag}.summary.json"), summary) print(f"[{args.model}] {args.transport}-ISS = {boot['mean']:+.4f} " f"[{boot['lo']:+.4f},{boot['hi']:+.4f}] n={len(rows)} ISS_DONE", flush=True) if __name__ == "__main__": main()