File size: 6,952 Bytes
6f2ed01 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | # -*- coding: utf-8 -*-
"""Per-layer family centroids -- the single input both ISS and KTS consume.
Protocol 7.4-7.6 and 8.2 describe one preparation, then branch. Keeping it in
one place means ISS and KTS cannot silently disagree about what a fact's
representation under a condition family IS, which would make the joint
interpretation table (protocol 12) meaningless.
z = transport(h) raw: identity; jlens: y = B h
zbar = z - mu_r - mu_t + mu relation and family main effects removed
zt = L2(PCA-whiten(zbar)) one transform per (model, layer)
v = L2(mean of zt within a family) -> [F, T, D], plus a mask
"""
import os, json
import numpy as np
import torch
import mcommon as mc
def l2n(X, eps=1e-12):
return X / X.norm(dim=-1, keepdim=True).clamp_min(eps)
def whiten(Z, dim, shrinkage, eps):
"""PCA whitening fitted once on the pooled matrix (protocol 7.5).
Fitting per condition family is forbidden: it would absorb exactly the
cross-condition differences these metrics exist to detect.
"""
mu = Z.mean(0, keepdim=True)
Zc = Z - mu
n, d = Zc.shape
k = min(dim, d)
# d <= 5120 while n ~ 39k, so the d x d covariance route is far cheaper
# than an SVD of the tall matrix and numerically equivalent.
C = (Zc.T @ Zc).double() / max(n - 1, 1)
evals, evecs = torch.linalg.eigh(C)
evals = evals.flip(0)[:k].clamp_min(0).float()
evecs = evecs.flip(1)[:, :k].float()
lam = shrinkage * float(evals.mean())
return (Zc @ evecs) / torch.sqrt(evals + lam + eps)
class StateLoader:
"""Streams (layer -> family centroids) for one model."""
def __init__(self, model, transport="raw", coverage=None, device="auto",
shuffle_seed=None):
C = mc.cfg()
self.C = C
self.model = model
self.transport = transport
# Protocol 18.1: with fact identity destroyed, ISS must collapse,
# KTS-ID must fall to chance and KTS-Geo to ~0. If they do not, the
# metric is measuring something other than the fact.
self.shuffle_seed = shuffle_seed
self.mode = coverage or C["headline_coverage"]
self.dev = ("cuda" if torch.cuda.is_available() else "cpu") \
if device == "auto" else device
self.hdir = mc.out("hidden", model)
self.meta = json.load(open(os.path.join(self.hdir, "index.json")))
if not self.meta.get("complete"):
raise SystemExit(f"{model}: hidden states incomplete; run extract_hidden.py")
self.families = C["main_families"]
fam_id = {t: i for i, t in enumerate(self.families)}
self.keep_facts = mc.eval_fact_set(self.mode)
self.fidx = {f: i for i, f in enumerate(self.keep_facts)}
self.rel_of = mc.fact_relation()
self.sel = np.array([i for i, f in enumerate(self.meta["fact_ids"])
if f in self.fidx], dtype=np.int64)
self.fact_idx = torch.tensor(
[self.fidx[self.meta["fact_ids"][i]] for i in self.sel], device=self.dev)
self.fam_idx = torch.tensor(
[fam_id[self.meta["families"][i]] for i in self.sel], device=self.dev)
self.by_rel = {}
for f in self.keep_facts:
self.by_rel.setdefault(self.rel_of[f], []).append(self.fidx[f])
rel_pos = {r: i for i, r in enumerate(self.by_rel)}
self.rel_idx = torch.tensor(
[rel_pos[self.rel_of[self.meta["fact_ids"][i]]] for i in self.sel],
device=self.dev)
self.n_rel = len(self.by_rel)
self.window = self.meta["window"]
self.late = set(self.meta["late_window"])
self.B = None
if transport == "jlens":
self.B = {}
for l in self.window:
p = mc.out("jlens", model, f"L{l:03d}", "B.npy")
if not os.path.exists(p):
raise SystemExit(
f"{model} L{l}: no J-Lens factor at {p}. Run src/jlens.py "
"first, or use --transport raw for the ablation.")
self.B[l] = torch.from_numpy(np.load(p)).to(self.dev).float()
@property
def n_facts(self):
return len(self.keep_facts)
def centroids(self, layer):
"""-> V [F, T, D] (zero where absent), mask [F, T]."""
icfg = self.C["iss"]
eps = float(icfg["eps"])
H = np.load(os.path.join(self.hdir, f"L{layer:03d}.npy"), mmap_mode="r")
Z = torch.from_numpy(np.ascontiguousarray(H[self.sel])).to(self.dev).float()
if self.B is not None:
Z = Z @ self.B[layer].T # y = B h (J-Lens spec 6.4)
# ---- protocol 7.4 double residualisation
mu = Z.mean(0, keepdim=True)
D = Z.shape[1]
mu_r = torch.zeros(self.n_rel, D, device=self.dev)
cr = torch.zeros(self.n_rel, device=self.dev)
mu_r.index_add_(0, self.rel_idx, Z)
cr.index_add_(0, self.rel_idx, torch.ones_like(self.rel_idx, dtype=torch.float))
mu_r /= cr.clamp_min(1).unsqueeze(-1)
mu_t = torch.zeros(len(self.families), D, device=self.dev)
ct = torch.zeros(len(self.families), device=self.dev)
mu_t.index_add_(0, self.fam_idx, Z)
ct.index_add_(0, self.fam_idx, torch.ones_like(self.fam_idx, dtype=torch.float))
mu_t /= ct.clamp_min(1).unsqueeze(-1)
Z = Z - mu_r[self.rel_idx] - mu_t[self.fam_idx] + mu
Z = l2n(whiten(Z, icfg["pca_dim"], icfg["shrinkage"], eps))
# ---- protocol 7.6 family centroid: average inside the family FIRST, so
# paraphrase (10,053 queries) cannot outweigh anchor (2,592) in one fact
F, T, Dn = self.n_facts, len(self.families), Z.shape[1]
V = torch.zeros(F, T, Dn, device=self.dev)
cnt = torch.zeros(F, T, device=self.dev)
flat = self.fact_idx * T + self.fam_idx
V.view(-1, Dn).index_add_(0, flat, Z)
cnt.view(-1).index_add_(0, flat, torch.ones_like(flat, dtype=torch.float))
mask = cnt > 0
V = V / cnt.clamp_min(1).unsqueeze(-1)
V = l2n(V) * mask.unsqueeze(-1)
if self.shuffle_seed is not None:
# Permute the fact axis INDEPENDENTLY per family, and permute within
# a relation so the shuffled control keeps the same relation
# composition -- otherwise a drop could just mean facts got matched
# against a different relation, which is not the null being tested.
g = torch.Generator().manual_seed(self.shuffle_seed + 1000 * layer)
for t in range(T):
for members in self.by_rel.values():
idx = torch.tensor(members)
perm = idx[torch.randperm(len(members), generator=g)]
V[idx, t] = V[perm.to(V.device), t].clone()
mask[idx, t] = mask[perm.to(mask.device), t].clone()
return V, mask
|