"""Phase 2 — extract all feature families for one config × all splits. Writes per-family files to: outputs//features/__.npz Each .npz contains: features (N, D) float32 columns (D,) object (feature names) idx (N,) int64 (aligned with predictions_.parquet["idx"]) Families produced (17 total): Single-v1 base: ripser, template, graph, toktopo_pd, toktopo_graph, intra_attn, punct, cls_last, cls_mid, cls_begin PCB-JS extra: js_morepairs (stratified-3 layers {1,6,11}) PCB-Best candidates: ai_morepairs (stratified-3 layers {1,6,11}) ai_s4 (stratified-4 layers {0,4,8,11}) plcross, swpd, cbh1 (last-2 layers {10,11}) toktopo_xbc (4 hand-picked layer pairs) Idempotent: each family file is skipped if it already exists. Use ``--force`` to re-extract everything; ``--families a b c`` to extract a subset only. """ from __future__ import annotations import argparse import sys import time from pathlib import Path from typing import List, Tuple import numpy as np import pandas as pd import torch ROOT = Path(__file__).resolve().parents[1] sys.path.insert(0, str(ROOT)) from src.utils import load_config, seed_everything, device_from_cfg, ensure_dir from src.load_data import load_splits from src.family_specs import ( ALL_FAMILIES, SINGLE_V1, PCB_JS_EXTRA, PCB_BEST_CANDIDATES, PAIR_STRATEGY, file_for, write_family_file, ) # --------------------------------------------------------------------------- # Family extractor implementations # --------------------------------------------------------------------------- def _need(out_dir, cfg_name, split, family_list, force): """Return the subset of families whose file is missing (or force=True).""" missing = [] for f in family_list: p = file_for(out_dir, cfg_name, f, split) if force or not p.exists(): missing.append(f) return missing def _split_topology_arrays(graph_arr, ripser_arr, template_arr, n_samples): """Take the (L, H, ...) arrays returned by recompute_from_attention, flatten the per-head feature axis to per-sample feature vectors, and return three (N, D) feature matrices with proper column names.""" # ripser shape (L, H, N, 14) -> per-sample (L*H*14,) L, H, N, R = ripser_arr.shape assert N == n_samples ripser_flat = np.moveaxis(ripser_arr, 2, 0).reshape(N, L * H * R) ripser_cols = [f"ripser_L{l}H{h}_s{s}" for l in range(L) for h in range(H) for s in range(R)] # template shape (L, H, 7, N) L, H, T, N2 = template_arr.shape assert N2 == n_samples template_flat = np.moveaxis(template_arr, -1, 0).reshape(N2, L * H * T) template_cols = [f"template_L{l}H{h}_t{t}" for l in range(L) for h in range(H) for t in range(T)] # graph shape (L, H, 9, N, 6) L, H, G, N3, K = graph_arr.shape assert N3 == n_samples graph_flat = np.moveaxis(graph_arr, 3, 0).reshape(N3, L * H * G * K) graph_cols = [f"graph_L{l}H{h}_g{g}_k{k}" for l in range(L) for h in range(H) for g in range(G) for k in range(K)] return (ripser_flat, ripser_cols), (template_flat, template_cols), (graph_flat, graph_cols) def _split_by_prefix(features, columns, name_to_prefix): """Split features into multiple per-family groups by column-name prefix matching. Returns {family: (sub_features, sub_columns)}.""" cols_arr = np.array(columns, dtype=object) out = {} for fam, prefix_test in name_to_prefix.items(): mask = np.array([prefix_test(c) for c in cols_arr]) if mask.any(): out[fam] = (features[:, mask], [c for c, k in zip(columns, mask) if k]) else: out[fam] = (np.zeros((features.shape[0], 0), dtype=np.float32), []) return out # --------------------------------------------------------------------------- # Main # --------------------------------------------------------------------------- def main(): ap = argparse.ArgumentParser() ap.add_argument("--config", required=True) ap.add_argument("--splits", nargs="+", default=["train", "validation", "test"]) ap.add_argument("--families", nargs="+", default=None, help="Families to extract. Default: SINGLE_V1, the ten families " "that 03_stage_features.py stages and AttnTopo is built " "from. Pass 'all' for every family in the repository, " "including the 41 exploratory ones nothing consumes.") ap.add_argument("--force", action="store_true", help="Re-extract even if family file already exists") ap.add_argument("--workers", type=int, default=8) args = ap.parse_args() cfg = load_config(args.config); seed_everything(cfg["seed"]) cfg_name = cfg["run_name"] out_dir = ensure_dir(cfg["paths"]["output_dir"]) feat_dir = ensure_dir(out_dir / "features") device = device_from_cfg(cfg) # Default to the families that are actually staged and used. ALL_FAMILIES # carries 41 more -- cross-barcode, pairwise interaction, and other # exploratory groups -- which 03_stage_features.py does not stage and no # module reads. Computing them added roughly 3.5 h per 20-NG configuration # and 13 h per Yelp configuration for output nothing consumes. if args.families == ["all"]: target_families = ALL_FAMILIES else: target_families = args.families or SINGLE_V1 splits_data = load_splits(cfg) print(f"[{cfg_name}] target families={target_families} splits={args.splits}") # ------------------------- M2 topology ----------------------------- M2_FAMS = ["ripser", "template", "graph"] if any(f in target_families for f in M2_FAMS): from src.extract_topological_features import recompute_from_attention rec_dir = ensure_dir(out_dir / "recomputed") for split in args.splits: missing = _need(out_dir, cfg_name, split, [f for f in M2_FAMS if f in target_families], args.force) if not missing: print(f" [skip-m2 {split}] all M2 family files exist"); continue df = pd.read_parquet(out_dir / f"predictions_{split}.parquet") idxs = df["idx"].tolist(); N = len(idxs) attn_dir = out_dir / "attention" / split cache_ripser = rec_dir / f"{split}_ripser.npy" cache_temp = rec_dir / f"{split}_template.npy" cache_graph = rec_dir / f"{split}_s_w_e_v_c_b0b1_m_k_lists_array_6.npy" if cache_ripser.exists() and cache_temp.exists() and cache_graph.exists() and not args.force: ripser_arr = np.load(cache_ripser); template_arr = np.load(cache_temp); graph_arr = np.load(cache_graph) print(f" [m2 {split}] using cached recomputed/*.npy") else: t0 = time.time() print(f" [m2 {split}] recompute from attention ({N} samples, {args.workers}w)") graph_arr, ripser_arr, template_arr = recompute_from_attention( attn_dir, idxs, n_workers=args.workers) np.save(cache_ripser, ripser_arr); np.save(cache_temp, template_arr); np.save(cache_graph, graph_arr) print(f" [m2 {split}] done in {time.time()-t0:.1f}s") (rip, rcols), (tem, tcols), (grp, gcols) = _split_topology_arrays( graph_arr, ripser_arr, template_arr, N) if "ripser" in missing: write_family_file(out_dir, cfg_name, "ripser", split, rip, rcols, idxs) print(f" wrote ripser_{split}.npz {rip.shape}") if "template" in missing: write_family_file(out_dir, cfg_name, "template", split, tem, tcols, idxs) print(f" wrote template_{split}.npz {tem.shape}") if "graph" in missing: write_family_file(out_dir, cfg_name, "graph", split, grp, gcols, idxs) print(f" wrote graph_{split}.npz {grp.shape}") # ------------------------- toktopo (PD + graph + xbc) ---------------- TT_FAMS = ["toktopo_pd", "toktopo_graph", "toktopo_xbc"] if any(f in target_families for f in TT_FAMS): from src.extract_toktopo import compute_toktopo for split in args.splits: missing = _need(out_dir, cfg_name, split, [f for f in TT_FAMS if f in target_families], args.force) if not missing: print(f" [skip-toktopo {split}] all toktopo files exist"); continue df = pd.read_parquet(out_dir / f"predictions_{split}.parquet") idxs = df["idx"].tolist() attn_dir = out_dir / "attention" / split t0 = time.time() print(f" [toktopo {split}] compute ({len(idxs)} samples, {args.workers}w)") arr, cols = compute_toktopo(attn_dir, idxs, n_workers=args.workers, max_dim=1) print(f" [toktopo {split}] done in {time.time()-t0:.1f}s; raw shape={arr.shape}") sub = _split_by_prefix(arr, cols, { "toktopo_pd": lambda c: c.startswith("toktopo_h"), "toktopo_graph": lambda c: (not c.startswith("toktopo_h")) and ("_xbc_" not in c), "toktopo_xbc": lambda c: "_xbc_" in c, }) for fam in missing: f_arr, f_cols = sub[fam] write_family_file(out_dir, cfg_name, fam, split, f_arr, f_cols, idxs) print(f" wrote {fam}_{split}.npz {f_arr.shape}") # ------------------------- intra_attn ------------------------------- if "intra_attn" in target_families: from src.extract_intra_attn_features import compute_intra_attn_features for split in args.splits: if not _need(out_dir, cfg_name, split, ["intra_attn"], args.force): print(f" [skip-intra {split}] exists"); continue df = pd.read_parquet(out_dir / f"predictions_{split}.parquet") idxs = df["idx"].tolist() t0 = time.time() arr, cols = compute_intra_attn_features(out_dir / "attention" / split, idxs, device=device) write_family_file(out_dir, cfg_name, "intra_attn", split, arr, cols, idxs) print(f" [intra_attn {split}] {arr.shape} ({time.time()-t0:.1f}s)") # ------------------------- punct ------------------------------------ if "punct" in target_families: from src.extract_punct_dist import compute_punct_dist from src.load_model import load_classification_model # Need tokenizer _, tokenizer = load_classification_model( cfg["model"]["pretrained_path"], num_labels=cfg["model"].get("num_labels"), base_tokenizer=cfg["model"].get("base_tokenizer"), do_lower_case=cfg["model"].get("do_lower_case"), is_peft=cfg["model"].get("is_peft", False), base_model=cfg["model"].get("base_model"), ) for split in args.splits: if not _need(out_dir, cfg_name, split, ["punct"], args.force): print(f" [skip-punct {split}] exists"); continue df = pd.read_parquet(out_dir / f"predictions_{split}.parquet") idxs = df["idx"].tolist() # punct needs original text; we re-merge with the split df from load_splits raw = splits_data[split].reset_index(drop=True) raw_merged = raw.loc[raw["idx"].isin(idxs)].set_index("idx").loc[idxs].reset_index() t0 = time.time() arr, cols = compute_punct_dist(out_dir / "attention" / split, tokenizer, cfg["model"]["max_length"], raw_merged, cfg["data"]["text_col"], n_workers=args.workers) write_family_file(out_dir, cfg_name, "punct", split, arr, cols, idxs) print(f" [punct {split}] {arr.shape} ({time.time()-t0:.1f}s)") # ------------------------- cls_embed -------------------------------- CLS_FAMS = ["cls_last", "cls_mid", "cls_begin"] if any(f in target_families for f in CLS_FAMS): from src.extract_cls_embeddings import compute_cls_features from src.load_model import load_classification_model, move from src.extract_attention import _build_dataloader # tokenizer + dataloader builder model, tokenizer = load_classification_model( cfg["model"]["pretrained_path"], num_labels=cfg["model"].get("num_labels"), base_tokenizer=cfg["model"].get("base_tokenizer"), do_lower_case=cfg["model"].get("do_lower_case"), is_peft=cfg["model"].get("is_peft", False), base_model=cfg["model"].get("base_model"), ) model = move(model, device) for split in args.splits: missing = _need(out_dir, cfg_name, split, [f for f in CLS_FAMS if f in target_families], args.force) if not missing: print(f" [skip-cls {split}] all cls files exist"); continue df = pd.read_parquet(out_dir / f"predictions_{split}.parquet") idxs = df["idx"].tolist() raw = splits_data[split].reset_index(drop=True) raw_merged = raw.loc[raw["idx"].isin(idxs)].set_index("idx").loc[idxs].reset_index() loader = _build_dataloader(raw_merged, tokenizer, cfg["data"]["text_col"], cfg["data"]["label_col"], cfg["model"]["max_length"], cfg["inference"]["batch_size"]) t0 = time.time() arr, cols = compute_cls_features(model, loader, device=str(device)) print(f" [cls {split}] raw shape={arr.shape} ({time.time()-t0:.1f}s)") sub = _split_by_prefix(arr, cols, { "cls_last": lambda c: c.startswith("cls_last_"), "cls_mid": lambda c: c.startswith("cls_mid_"), "cls_begin": lambda c: c.startswith("cls_begin_"), }) for fam in missing: f_arr, f_cols = sub[fam] write_family_file(out_dir, cfg_name, fam, split, f_arr, f_cols, idxs) print(f" wrote {fam}_{split}.npz {f_arr.shape}") # ------------------------- cross-attention families --------------------- from src.extract_cross_barcode_features import _resolve_pairs CROSS_EXTRACTORS = { "js_morepairs": ("src.extract_js_cross_attn", "compute_js_cross_attn_features"), "ai_morepairs": ("src.extract_attn_interaction_features", "compute_attn_interaction_features"), "ai_s4": ("src.extract_attn_interaction_features", "compute_attn_interaction_features"), "plcross": ("src.extract_pl_cross", "compute_pl_cross"), "swpd": ("src.extract_sw_pd", "compute_sw_pd_features"), "cbh1": ("src.extract_cross_barcode_h1", "compute_h1_cross_features"), } for fam in [f for f in target_families if f in CROSS_EXTRACTORS]: modname, fnname = CROSS_EXTRACTORS[fam] module = __import__(modname, fromlist=[fnname]) fn = getattr(module, fnname) pair_strat = PAIR_STRATEGY[fam] pairs = _resolve_pairs(pair_strat) for split in args.splits: if not _need(out_dir, cfg_name, split, [fam], args.force): print(f" [skip-{fam} {split}] exists"); continue df = pd.read_parquet(out_dir / f"predictions_{split}.parquet") idxs = df["idx"].tolist() attn_dir = out_dir / "attention" / split t0 = time.time() # All cross extractors take (attn_dir, indices, pairs, ...) extra = {} if fam == "plcross": extra = {"n_workers": args.workers} if fam == "swpd": extra = {"device": str(device)} if fam == "cbh1": extra = {} # uses default quantile if fam in {"js_morepairs", "ai_morepairs", "ai_s4"}: extra = {"device": torch.device(str(device))} arr, cols = fn(attn_dir, idxs, pairs, **extra) write_family_file(out_dir, cfg_name, fam, split, arr, cols, idxs) print(f" [{fam} {split}] {arr.shape} ({time.time()-t0:.1f}s) strategy={pair_strat}") print(f"[{cfg_name}] DONE") if __name__ == "__main__": main()