| """KCS — Key-Concept Similarity (Phase 1, idx 5). |
| |
| For each layer l, find the top-K = 32 MLP neurons by |pre-activation| at |
| [CLS], i.e. ``cache.mlp_pre_act[l][:, 0, :]``. Each selected neuron j |
| corresponds to a value vector v_{l, j} = W_down[l][:, j] (the j-th |
| column of the MLP down-projection); its logit-space contribution is |
| W_cls @ v_{l, j}. |
| |
| Build a (32 L) × (32 L) similarity matrix |
| A[(l1, j1), (l2, j2)] = cos(W_cls @ v_{l1, j1}, W_cls @ v_{l2, j2}) |
| and summarise: |
| |
| * top-10 eigenvalues of the normalised Laplacian of |A| (10) |
| * Ripser persistence on (1 - A) treated as distance (18) |
| * 5 global scalars: mean, std, max, min, median of |A| (5) |
| |
| Output dim = 33. |
| |
| References: Geva et al. EMNLP 2021/2022; Voita et al. ACL 2024. |
| """ |
| from __future__ import annotations |
|
|
| import numpy as np |
| import torch |
|
|
| from .persistence_summary import ripser_summary_from_distance, column_names as pcol |
|
|
|
|
| K = 32 |
| L = 12 |
|
|
|
|
| def _columns(): |
| cols = [f"kcs_lap_eig{i}" for i in range(10)] |
| cols.extend(pcol("kcs_pers")) |
| cols.extend(["kcs_A_mean", "kcs_A_std", "kcs_A_max", "kcs_A_min", "kcs_A_median"]) |
| return cols |
|
|
|
|
| COLUMNS = _columns() |
| DIM = len(COLUMNS) |
|
|
|
|
| def _mlp_w_down(model) -> list: |
| """Return per-layer W_down weight tensors (D, 4D), one per encoder layer.""" |
| if hasattr(model, "roberta"): |
| layers = model.roberta.encoder.layer |
| elif hasattr(model, "electra"): |
| layers = model.electra.encoder.layer |
| else: |
| layers = model.encoder.layer |
| return [l.output.dense.weight.detach() for l in layers] |
|
|
|
|
| def _classifier_out_proj(model) -> torch.Tensor: |
| cls = model.classifier |
| for attr in ("out_proj", "dense", "fc", "linear"): |
| if hasattr(cls, attr): |
| sub = getattr(cls, attr) |
| if isinstance(sub, torch.nn.Linear): |
| return sub.weight.detach() |
| if isinstance(cls, torch.nn.Linear): |
| return cls.weight.detach() |
| raise RuntimeError("Could not locate classifier out_proj weight") |
|
|
|
|
| def _normalised_laplacian_eigs(A: np.ndarray, k: int = 10) -> np.ndarray: |
| n = A.shape[0] |
| A = np.abs(A) |
| np.fill_diagonal(A, 0.0) |
| d = A.sum(axis=1) |
| d_safe = np.where(d > 0, d, 1.0) |
| D_inv_sqrt = 1.0 / np.sqrt(d_safe) |
| L_norm = np.eye(n) - (D_inv_sqrt[:, None] * A * D_inv_sqrt[None, :]) |
| try: |
| ev = np.linalg.eigvalsh(0.5 * (L_norm + L_norm.T)) |
| except np.linalg.LinAlgError: |
| return np.zeros(k, dtype=np.float32) |
| ev = np.sort(ev)[::-1] |
| out = np.zeros(k, dtype=np.float32) |
| out[:min(k, ev.size)] = ev[:min(k, ev.size)] |
| return out |
|
|
|
|
| def extract_kcs(model, input_ids, attention_mask, cache, pred_label=None): |
| """Return (features (B, 33), columns).""" |
| B = input_ids.shape[0] |
| feats = np.zeros((B, DIM), dtype=np.float32) |
| W_cls = _classifier_out_proj(model).float() |
| W_down = _mlp_w_down(model) |
|
|
| |
| |
| pre_cls = [cache.mlp_pre_act[l][:, 0, :].float() for l in range(L)] |
|
|
| for b in range(B): |
| |
| top_idx = [] |
| for l in range(L): |
| mag = pre_cls[l][b].abs() |
| k_eff = min(K, mag.shape[0]) |
| _, idx = torch.topk(mag, k_eff) |
| top_idx.append(idx.cpu().numpy()) |
|
|
| |
| proj = [] |
| node_layer = [] |
| for l in range(L): |
| idx = top_idx[l] |
| V = W_down[l][:, idx].float() |
| P = (W_cls @ V).T |
| proj.append(P) |
| node_layer.extend([l] * idx.size) |
| Proj = torch.cat(proj, dim=0) |
| Pn = torch.nn.functional.normalize(Proj, dim=-1) |
| A = (Pn @ Pn.T).cpu().numpy() |
|
|
| eigs = _normalised_laplacian_eigs(A, k=10) |
| feats[b, 0:10] = eigs |
|
|
| D = 1.0 - A |
| np.fill_diagonal(D, 0.0) |
| pers, _ = ripser_summary_from_distance(D, maxdim=1, prefix="kcs_pers") |
| feats[b, 10 : 28] = pers |
|
|
| off = A.copy() |
| np.fill_diagonal(off, 0.0) |
| v = off[np.triu_indices_from(off, k=1)] |
| feats[b, 28:33] = [ |
| float(v.mean()), float(v.std()), float(v.max()), |
| float(v.min()), float(np.median(v)), |
| ] |
| return feats, COLUMNS |
|
|
