File size: 4,525 Bytes
2eb3475 | 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 | """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() # (C, D)
W_down = _mlp_w_down(model) # list of (D, 4D)
# Per-layer pre-activation magnitudes at [CLS]
# cache.mlp_pre_act[l] shape (B, T, 4D)
pre_cls = [cache.mlp_pre_act[l][:, 0, :].float() for l in range(L)] # list of (B, 4D)
for b in range(B):
# Per-layer top-K indices into 4D for THIS sample
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())
# Project the selected neurons' value-vectors through W_cls
proj = [] # (n_l × C)
node_layer = []
for l in range(L):
idx = top_idx[l]
V = W_down[l][:, idx].float() # (D, k)
P = (W_cls @ V).T # (k, C)
proj.append(P)
node_layer.extend([l] * idx.size)
Proj = torch.cat(proj, dim=0) # (sum_k, C)
Pn = torch.nn.functional.normalize(Proj, dim=-1)
A = (Pn @ Pn.T).cpu().numpy() # (n, n)
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
|