| |
| """KTS: Knowledge Topology Stability. (protocol 8-11) |
| |
| python src/kts.py --model Llama-3.2-1B --transport raw |
| python src/kts.py --model Llama-3.2-1B --transport jlens |
| |
| Two components, both computed per relation and then macro-averaged so that the |
| largest relations cannot dominate (protocol 9.1): |
| |
| KTS-Geo Spearman correlation between the within-relation pairwise distance |
| matrices under the two condition families. Rotation, translation and |
| isotropic scaling are all invisible to it -- protocol 8.1 says that |
| is intended: different phrasings may use different internal |
| implementations as long as relative structure survives. |
| |
| KTS-ID Cross-condition nearest-neighbour retrieval of the fact itself, |
| among same-relation facts, both directions, chance-corrected. |
| Global geometry can look preserved while individual identities swap, |
| which is exactly what this catches. |
| |
| composite = harmonic mean of the two, so a model cannot buy a high KTS with one |
| component alone (protocol 11). |
| """ |
| import os, sys, json, time, argparse, itertools |
|
|
| import numpy as np |
| import torch |
| from scipy.stats import spearmanr |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| import mcommon as mc |
| from states import StateLoader |
|
|
|
|
| def geo_pair(Va, Vb, members, eps): |
| """Spearman between within-relation distance matrices (protocol 9.1-9.2).""" |
| idx = torch.tensor(members, device=Va.device) |
| A, B = Va[idx], Vb[idx] |
| Da = 1.0 - (A @ A.T) |
| Db = 1.0 - (B @ B.T) |
| iu = torch.triu_indices(len(members), len(members), offset=1) |
| da = Da[iu[0], iu[1]].cpu().numpy() |
| db = Db[iu[0], iu[1]].cpu().numpy() |
| if da.size < 2 or np.std(da) < eps or np.std(db) < eps: |
| return None |
| rho = spearmanr(da, db).statistic |
| return None if not np.isfinite(rho) else float(rho) |
|
|
|
|
| def id_pair(Va, Vb, members): |
| """Symmetric chance-corrected top-1 identity, plus top-5 and MRR. |
| |
| Retrieval is restricted to same-relation facts (protocol 10.1): matching |
| "the capital of France" against a manufacturer fact would be trivial and |
| would inflate the score. |
| """ |
| idx = torch.tensor(members, device=Va.device) |
| A, B = Va[idx], Vb[idx] |
| n = len(members) |
| gold = torch.arange(n, device=A.device) |
|
|
| def side(X, Y): |
| S = X @ Y.T |
| rank = (S > S.gather(1, gold[:, None])).sum(1) |
| top1 = (rank == 0).float().mean().item() |
| top5 = (rank < 5).float().mean().item() |
| mrr = (1.0 / (rank.float() + 1)).mean().item() |
| return top1, top5, mrr |
|
|
| a = side(A, B) |
| b = side(B, A) |
| top1 = 0.5 * (a[0] + b[0]) |
| chance = 1.0 / n |
| adj = (top1 - chance) / max(1.0 - chance, 1e-12) |
| return {"top1_symmetric": top1, "top5_symmetric": 0.5 * (a[1] + b[1]), |
| "mrr_symmetric": 0.5 * (a[2] + b[2]), "chance": chance, |
| "chance_corrected": float(np.clip(adj, 0.0, 1.0)), "n": n} |
|
|
|
|
| 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: KTS-ID must fall to chance, KTS-Geo to ~0") |
| args = ap.parse_args() |
|
|
| C = mc.cfg() |
| kcfg = C["kts"] |
| eps = float(kcfg["eps"]) |
| min_facts = kcfg["min_facts_per_relation"] |
|
|
| S = StateLoader(args.model, args.transport, args.coverage, args.device, |
| shuffle_seed=args.shuffle_seed) |
| fams = S.families |
| pairs = list(itertools.combinations(range(len(fams)), 2)) |
|
|
| t0 = time.time() |
| per_layer_pair = [] |
| for l in S.window: |
| V, mask = S.centroids(l) |
| for (a, b) in pairs: |
| both = mask[:, a] & mask[:, b] |
| geos, ids, shared = [], [], int(both.sum()) |
| for rel, members in S.by_rel.items(): |
| m = [i for i in members if bool(both[i])] |
| if len(m) < min_facts: |
| continue |
| g = geo_pair(V[:, a], V[:, b], m, eps) |
| if g is not None: |
| geos.append(g) |
| ids.append(id_pair(V[:, a], V[:, b], m)) |
| if not geos or not ids: |
| continue |
| geo = float(np.mean(geos)) |
| geo01 = (geo + 1.0) / 2.0 |
| idv = float(np.mean([x["chance_corrected"] for x in ids])) |
| per_layer_pair.append({ |
| "model": args.model, "transport": args.transport, "layer": l, |
| "pair": f"{fams[a]}__{fams[b]}", "shared_facts": shared, |
| "relations_used": len(ids), |
| "kts_geo_raw": geo, "kts_geo": geo01, "kts_id": idv, |
| "kts": 2 * geo01 * idv / (geo01 + idv + eps), |
| "top1": float(np.mean([x["top1_symmetric"] for x in ids])), |
| "top5": float(np.mean([x["top5_symmetric"] for x in ids])), |
| "mrr": float(np.mean([x["mrr_symmetric"] for x in ids])), |
| }) |
| del V, mask |
| if S.dev == "cuda": |
| torch.cuda.empty_cache() |
| lay = [r for r in per_layer_pair if r["layer"] == l] |
| print(f" L{l:03d} geo={np.mean([r['kts_geo'] for r in lay]):.4f} " |
| f"id={np.mean([r['kts_id'] for r in lay]):.4f} " |
| f"kts={np.mean([r['kts'] for r in lay]):.4f}", flush=True) |
|
|
| 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", "kts", f"{tag}.per_pair_layer.jsonl"), per_layer_pair) |
|
|
| |
| |
| def agg(rows, key): |
| by_layer = {} |
| for r in rows: |
| by_layer.setdefault(r["layer"], []).append(r[key]) |
| return float(np.mean([np.mean(v) for v in by_layer.values()])) |
|
|
| pair_summary = {} |
| for p in sorted({r["pair"] for r in per_layer_pair}): |
| rows = [r for r in per_layer_pair if r["pair"] == p] |
| pair_summary[p] = { |
| "shared_facts": rows[0]["shared_facts"], |
| "kts_geo": float(np.mean([r["kts_geo"] for r in rows])), |
| "kts_geo_raw": float(np.mean([r["kts_geo_raw"] for r in rows])), |
| "kts_id": float(np.mean([r["kts_id"] for r in rows])), |
| "kts": float(np.mean([r["kts"] for r in rows])), |
| "top1": float(np.mean([r["top1"] for r in rows])), |
| "top5": float(np.mean([r["top5"] for r in rows])), |
| "mrr": float(np.mean([r["mrr"] for r in rows])), |
| } |
|
|
| summary = { |
| "model": args.model, "transport": args.transport, |
| "official": args.transport == "jlens" and args.shuffle_seed is None, |
| "shuffle_control": args.shuffle_seed is not None, "coverage_mode": S.mode, |
| "layers": S.window, "n_facts": S.n_facts, |
| "kts_geo": agg(per_layer_pair, "kts_geo"), |
| "kts_geo_raw_spearman": agg(per_layer_pair, "kts_geo_raw"), |
| "kts_id": agg(per_layer_pair, "kts_id"), |
| "kts": agg(per_layer_pair, "kts"), |
| "top1": agg(per_layer_pair, "top1"), |
| "top5": agg(per_layer_pair, "top5"), |
| "mrr": agg(per_layer_pair, "mrr"), |
| "family_pairs": pair_summary, |
| "per_layer_kts": {str(l): float(np.mean([r["kts"] for r in per_layer_pair |
| if r["layer"] == l])) |
| for l in S.window}, |
| "seconds": round(time.time() - t0, 1), |
| } |
| mc.write_json(mc.out("metrics", "kts", f"{tag}.summary.json"), summary) |
| print(f"[{args.model}] {args.transport} KTS-Geo={summary['kts_geo']:.4f} " |
| f"KTS-ID={summary['kts_id']:.4f} KTS={summary['kts']:.4f} KTS_DONE", |
| flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
