File size: 5,615 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 135 136 137 138 139 140 141 142 | """TTP — Token-Trajectory Persistence (cross-layer per-token).
For each token t in the active sequence, its hidden-state trajectory
through the encoder is the polyline
v^t = (h_0^t, h_1^t, ..., h_L^t) in R^{(L+1) x D}.
We extract two complementary signal blocks (~21 scalars total):
(A) Cloud-topology block (14 scalars).
Build the T x T distance matrix D_{ij} = mean_l (1 - cos(h_l^i, h_l^j))
(per-layer cosine distance averaged across all L+1 layers).
Run Ripser up to H1 on D and summarise both diagrams by 7 scalars:
bar count, sum/max persistence, top-2 persistence, entropy, mean
bar midpoint.
(B) Per-token shape block (7 scalars).
For each token compute:
- trajectory length L^t = sum_l ||h_{l+1}^t - h_l^t||
- step-to-step cosine s_l^t = cos(h_l^t, h_{l+1}^t) (mean over l)
- net displacement N^t = ||h_L^t - h_0^t||
- curvature k^t = mean_l (1 - cos(h_{l+1}-h_l, h_l-h_{l-1}))
Then aggregate across tokens: mean(L), std(L), mean(s), std(s),
mean(N), mean(k), std(k).
Admissible: pure hidden-state geometry. No W_cls, no logits, no softmax.
Orthogonal axis to ZAP (which uses attention edges, not hidden states).
"""
from __future__ import annotations
import numpy as np
from ripser import ripser
def _pd_stats(pd: np.ndarray) -> np.ndarray:
"""7-scalar persistence-diagram summary."""
if len(pd) == 0:
return np.zeros(7, dtype=np.float32)
finite = pd[np.isfinite(pd[:, 1])]
if len(finite) == 0:
return np.zeros(7, dtype=np.float32)
lengths = finite[:, 1] - finite[:, 0]
if len(lengths) == 0:
return np.zeros(7, dtype=np.float32)
sort_l = np.sort(lengths)[::-1]
n = float(len(lengths))
s = float(lengths.sum())
top1 = float(sort_l[0]) if len(sort_l) >= 1 else 0.0
top2 = float(sort_l[1]) if len(sort_l) >= 2 else 0.0
p = lengths / max(s, 1e-12)
ent = float(-(p[p > 0] * np.log(p[p > 0])).sum())
midpoints = (finite[:, 0] + finite[:, 1]) / 2.0
mid_mean = float(midpoints.mean())
return np.array([n, s, top1, top2, ent, float(sort_l[-1]) if len(sort_l) else 0.0, mid_mean],
dtype=np.float32)
COLUMNS = (
# H_0 block
[f"ttp_h0_{s}" for s in ("count", "sum", "max", "top2", "ent", "min", "mid")]
+ [f"ttp_h1_{s}" for s in ("count", "sum", "max", "top2", "ent", "min", "mid")]
# Shape block
+ ["ttp_len_mean", "ttp_len_std",
"ttp_stepcos_mean", "ttp_stepcos_std",
"ttp_netdisp_mean",
"ttp_curv_mean", "ttp_curv_std"]
)
DIM = len(COLUMNS)
def extract_ttp(model, input_ids, attention_mask, cache, pred_label=None):
"""Return (features (B, DIM), columns).
Reads cache.hidden_states: list of (L+1) tensors each (B, T, D).
"""
B = input_ids.shape[0]
L_total = len(cache.hidden_states)
feats = np.zeros((B, DIM), dtype=np.float32)
for b in range(B):
T_b = int(attention_mask[b].sum().item())
T_max = cache.hidden_states[0].shape[1]
T = max(min(T_b, T_max), 4)
# Stack: (L+1, T, D)
hs = np.stack(
[cache.hidden_states[l][b, :T].detach().float().cpu().numpy()
for l in range(L_total)],
axis=0,
)
# (A) Cloud-topology: T x T distance matrix
# per-layer cosine distance, averaged across layers
norms = np.linalg.norm(hs, axis=-1, keepdims=True) # (L+1, T, 1)
unit = hs / np.maximum(norms, 1e-9) # (L+1, T, D)
# per-layer sim: (L+1, T, T)
sim = np.einsum("ltd,lsd->lts", unit, unit)
dist = (1.0 - sim).mean(axis=0) # (T, T)
dist = 0.5 * (dist + dist.T)
np.fill_diagonal(dist, 0.0)
dist = np.clip(dist, 0.0, None)
try:
res = ripser(dist, distance_matrix=True, maxdim=1)
pds = res["dgms"]
except Exception:
pds = [np.zeros((0, 2), dtype=np.float32),
np.zeros((0, 2), dtype=np.float32)]
h0_feats = _pd_stats(pds[0])
h1_feats = _pd_stats(pds[1]) if len(pds) > 1 else np.zeros(7, dtype=np.float32)
# (B) Per-token shape statistics
# deltas: (L, T, D)
deltas = hs[1:] - hs[:-1]
delta_norms = np.linalg.norm(deltas, axis=-1) # (L, T)
traj_len = delta_norms.sum(axis=0) # (T,)
net_disp = np.linalg.norm(hs[-1] - hs[0], axis=-1) # (T,)
# step-to-step cosine between consecutive hidden states (not deltas)
h_norm = np.linalg.norm(hs, axis=-1, keepdims=True)
h_unit = hs / np.maximum(h_norm, 1e-9)
stepcos = (h_unit[:-1] * h_unit[1:]).sum(axis=-1) # (L, T)
# curvature: angle between consecutive deltas
if deltas.shape[0] >= 2:
d_norm = np.linalg.norm(deltas, axis=-1, keepdims=True)
d_unit = deltas / np.maximum(d_norm, 1e-9)
curv = 1.0 - (d_unit[:-1] * d_unit[1:]).sum(axis=-1) # (L-1, T)
curv_mean = float(curv.mean())
curv_std = float(curv.std())
else:
curv_mean = curv_std = 0.0
shape_feats = np.array([
float(traj_len.mean()), float(traj_len.std()),
float(stepcos.mean()), float(stepcos.std()),
float(net_disp.mean()),
curv_mean, curv_std,
], dtype=np.float32)
feats[b, :7] = h0_feats
feats[b, 7:14] = h1_feats
feats[b, 14:] = shape_feats
return feats, COLUMNS
|