File size: 5,730 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 | """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 # local import for spawn-safety
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
|