| """PBD — Persistence Barycenter Drift across layers (Sprint 1, Idea 2). |
| |
| For each layer l in L* = {0, 3, 6, 9, 11}: |
| |
| 1. Compute per-head PD-summary (18 scalars) for all 12 heads on the |
| per-head attention matrix. |
| 2. Approximate the diagram barycenter as the *medoid* head: the one |
| with minimum mean L2 distance (in PD-summary space) to all other |
| heads. |
| 3. Record per-layer: mean head-to-medoid distance, max distance, |
| median distance, and the medoid PD-summary norm. |
| |
| Across consecutive layer pairs: |
| 4. Layer-pair barycenter drift = L2(medoid_l_summary, medoid_{l+1}_summary). |
| 5. Aggregate: cumulative drift, max drift, max-drift layer index, |
| late/early drift ratio. |
| |
| Total: 5 layers * 4 = 20 + 4 inter-layer drifts + 4 aggregate = 28 scalars. |
| """ |
| from __future__ import annotations |
|
|
| import numpy as np |
|
|
| from .pd_hdg import _pd_summary_for_attention |
|
|
|
|
| LAYERS = (0, 3, 6, 9, 11) |
|
|
|
|
| def _columns(): |
| cols = [] |
| for l in LAYERS: |
| cols.extend([ |
| f"pbd_L{l}_mean_to_medoid", |
| f"pbd_L{l}_max_to_medoid", |
| f"pbd_L{l}_med_to_medoid", |
| f"pbd_L{l}_medoid_pd_norm", |
| ]) |
| for i in range(len(LAYERS) - 1): |
| cols.append(f"pbd_drift_L{LAYERS[i]}_to_L{LAYERS[i+1]}") |
| cols.extend([ |
| "pbd_drift_cum", |
| "pbd_drift_max", |
| "pbd_drift_argmax_idx", |
| "pbd_drift_late_over_early", |
| ]) |
| return cols |
|
|
|
|
| COLUMNS = _columns() |
| DIM = len(COLUMNS) |
|
|
|
|
| def extract_pbd(model, input_ids, attention_mask, cache, pred_label=None): |
| """Return (features (B, DIM), columns).""" |
| B = input_ids.shape[0] |
| feats = np.zeros((B, DIM), dtype=np.float32) |
|
|
| medoid_block = 4 * len(LAYERS) |
| drift_block = medoid_block + (len(LAYERS) - 1) |
| agg_block = drift_block |
|
|
| for b in range(B): |
| T_b = int(attention_mask[b].sum().item()) |
| T_b = max(T_b, 3) |
| medoid_summaries = np.zeros((len(LAYERS), 18), dtype=np.float32) |
| for li, l in enumerate(LAYERS): |
| A = cache.attn_weights[l][b].detach().float().cpu().numpy() |
| T_use = min(T_b, A.shape[-1]) |
| H = A.shape[0] |
| pd_vec = np.zeros((H, 18), dtype=np.float32) |
| for h in range(H): |
| pd_vec[h] = _pd_summary_for_attention(A[h, :T_use, :T_use]) |
| mu = pd_vec.mean(axis=0, keepdims=True) |
| sd = pd_vec.std(axis=0, keepdims=True) + 1e-6 |
| Z = (pd_vec - mu) / sd |
| diff = Z[:, None, :] - Z[None, :, :] |
| D = np.sqrt((diff ** 2).sum(axis=-1)) |
| mean_d = D.mean(axis=1) |
| m_idx = int(np.argmin(mean_d)) |
| d_to_m = D[m_idx] |
| d_to_m_others = np.delete(d_to_m, m_idx) |
| feats[b, li * 4 + 0] = d_to_m_others.mean() |
| feats[b, li * 4 + 1] = d_to_m_others.max() |
| feats[b, li * 4 + 2] = float(np.median(d_to_m_others)) |
| feats[b, li * 4 + 3] = float(np.linalg.norm(pd_vec[m_idx])) |
| medoid_summaries[li] = pd_vec[m_idx] |
|
|
| drifts = np.zeros(len(LAYERS) - 1, dtype=np.float32) |
| for i in range(len(LAYERS) - 1): |
| drifts[i] = float(np.linalg.norm(medoid_summaries[i + 1] - medoid_summaries[i])) |
| feats[b, medoid_block : drift_block] = drifts |
|
|
| feats[b, agg_block + 0] = float(drifts.sum()) |
| feats[b, agg_block + 1] = float(drifts.max() if drifts.size else 0.0) |
| feats[b, agg_block + 2] = float(np.argmax(drifts)) if drifts.size else 0.0 |
| half = len(drifts) // 2 |
| early = drifts[:half].sum() if half else 0.0 |
| late = drifts[half:].sum() if half else 0.0 |
| feats[b, agg_block + 3] = float(late / (early + 1e-6)) |
|
|
| return feats, COLUMNS |
|
|
