dataset_upload/metrics/states.py

# -*- 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