scripts/02_extract_features.py

"""Phase 2 — extract all feature families for one config × all splits.

Writes per-family files to:
  outputs/<cfg>/features/<cfg>_<family>_<split>.npz

Each .npz contains:
  features  (N, D)     float32
  columns   (D,)       object  (feature names)
  idx       (N,)       int64   (aligned with predictions_<split>.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()