| """Single-attention topological features (ripser / template / graph). |
| |
| v1: load precomputed .npy from paper/drive_folder/ and flatten to (N, F). |
| v2 (TODO): recompute from raw attention dumps using ripser + networkx. |
| """ |
| from __future__ import annotations |
|
|
| from pathlib import Path |
| from typing import Dict, List, Tuple |
|
|
| import numpy as np |
|
|
|
|
| def _load_and_flatten(path: str, sample_axis_last: bool, expected_n: int) -> np.ndarray: |
| """The shipped .npy files have N on different axes depending on the feature type. |
| |
| Observed shapes (paper/drive_folder/): |
| ripser (12, 12, N, 14) |
| template (12, 12, 7, N) |
| graph (12, 12, 9, N, 6) |
| |
| We locate the axis with size == expected_n and move it to the front. |
| """ |
| arr = np.load(path) |
| n_axes = [i for i, s in enumerate(arr.shape) if s == expected_n] |
| if not n_axes: |
| raise ValueError(f"Unexpected shape {arr.shape} for {path}; expected N={expected_n}") |
| moved = np.moveaxis(arr, n_axes[0], 0) |
| return moved.reshape(moved.shape[0], -1).astype(np.float32) |
|
|
|
|
| def load_existing_features( |
| cfg_files: Dict[str, str], split: str, n_samples: int |
| ) -> Tuple[np.ndarray, List[str]]: |
| """Return (N, F_total) feature matrix concatenating ripser+template+graph.""" |
| groups = [ |
| (f"ripser_{split}", "ripser"), |
| (f"template_{split}", "template"), |
| (f"graph_{split}", "graph"), |
| ] |
| arrays, names = [], [] |
| for key, label in groups: |
| path = cfg_files.get(key) |
| if not path or not Path(path).exists(): |
| continue |
| flat = _load_and_flatten(path, sample_axis_last=True, expected_n=n_samples) |
| arrays.append(flat) |
| names.extend([f"{label}_{i}" for i in range(flat.shape[1])]) |
| if not arrays: |
| return np.zeros((n_samples, 0), dtype=np.float32), [] |
| return np.concatenate(arrays, axis=1), names |
|
|
|
|
| def load_recomputed_features( |
| recomputed_dir: str | Path, split: str, n_samples: int |
| ) -> Tuple[np.ndarray, List[str]]: |
| """Load features that were produced by ``scripts/07_recompute_topology.py``. |
| |
| Expected files under ``recomputed_dir``: |
| - ``{split}_ripser.npy`` — (L, H, N, 14) |
| - ``{split}_template.npy`` — (L, H, 7, N) |
| - ``{split}_s_w_e_v_c_b0b1_m_k_lists_array_6.npy`` — (L, H, 9, N, 6) |
| """ |
| rd = Path(recomputed_dir) |
| mapping = { |
| f"ripser_{split}": ("ripser", rd / f"{split}_ripser.npy"), |
| f"template_{split}": ("template", rd / f"{split}_template.npy"), |
| f"graph_{split}": ("graph", rd / f"{split}_s_w_e_v_c_b0b1_m_k_lists_array_6.npy"), |
| } |
| cfg_files = {key: str(path) for key, (_, path) in mapping.items()} |
| return load_existing_features(cfg_files, split=split, n_samples=n_samples) |
|
|
|
|
| def _process_one_sample(args): |
| """Worker: load one sample's attention .npz and compute its features.""" |
| idx, attn_dir_str = args |
| from .topology_features import extract_all_features |
| from pathlib import Path as _Path |
| with np.load(_Path(attn_dir_str) / f"{idx:06d}.npz") as data: |
| attn = data["attn"].astype(np.float32) |
| return idx, extract_all_features(attn) |
|
|
|
|
| def recompute_from_attention( |
| attn_dir: Path, indices: List[int], n_workers: int = 1 |
| ) -> Tuple[np.ndarray, np.ndarray, np.ndarray]: |
| """Recompute the three SingleAttention feature families from on-disk attention dumps. |
| |
| For each sample idx in ``indices``, loads ``attn_dir/{idx:06d}.npz`` (shape |
| (L, H, T, T)) and computes graph/ripser/template features per (layer, head). |
| |
| Returns three arrays matching the schema of paper/drive_folder/*.npy: |
| - graph : (L, H, N_graph=9, N, N_thresholds=6) |
| - ripser : (L, H, N, N_ripser=14) |
| - template : (L, H, N_template=7, N) |
| |
| Use ``n_workers > 1`` to parallelize across samples via multiprocessing |
| (networkx is pure-Python so this is CPU-bound and benefits from many cores). |
| |
| Graph and Ripser features are validated against the precomputed arrays by |
| 06_parity_test.py (max abs error ≈ 1 unit for graph counts due to float16 |
| storage; ≈ 1e-3 for Ripser longest deaths). Template features use a |
| best-effort definition (max abs error ≈ 0.1; see topology_features.py). |
| """ |
| from .topology_features import ( |
| extract_all_features, THRESHOLDS, N_RIPSER, N_TEMPLATE, N_GRAPH, |
| ) |
| from tqdm import tqdm |
|
|
| N = len(indices) |
| probe = np.load(attn_dir / f"{indices[0]:06d}.npz")["attn"] |
| L, H = probe.shape[:2] |
|
|
| graph_arr = np.zeros((L, H, N_GRAPH, N, len(THRESHOLDS)), dtype=np.float32) |
| ripser_arr = np.zeros((L, H, N, N_RIPSER), dtype=np.float32) |
| template_arr = np.zeros((L, H, N_TEMPLATE, N), dtype=np.float32) |
|
|
| pos_of = {idx: n for n, idx in enumerate(indices)} |
| args = [(idx, str(attn_dir)) for idx in indices] |
|
|
| if n_workers <= 1: |
| for n, idx in enumerate(tqdm(indices, desc="recompute features")): |
| _, feats = _process_one_sample(args[n]) |
| graph_arr[:, :, :, n, :] = feats["graph"] |
| ripser_arr[:, :, n, :] = feats["ripser"] |
| template_arr[:, :, :, n] = feats["template"] |
| return graph_arr, ripser_arr, template_arr |
|
|
| from multiprocessing import Pool |
| with Pool(processes=n_workers) as pool: |
| for idx, feats in tqdm( |
| pool.imap_unordered(_process_one_sample, args, chunksize=4), |
| total=N, desc=f"recompute features [{n_workers}w]", |
| ): |
| n = pos_of[idx] |
| graph_arr[:, :, :, n, :] = feats["graph"] |
| ripser_arr[:, :, n, :] = feats["ripser"] |
| template_arr[:, :, :, n] = feats["template"] |
| return graph_arr, ripser_arr, template_arr |
|
|
