| |
| """Extract attention features without ever storing the full attention set. |
| |
| Stages 01 and 02 are split: 01 dumps one (L, H, T, T) tensor per sample to |
| disk, 02 reads them back. That costs ~50 GB per configuration and ~60 GB for |
| a Yelp-sized split, and it is what makes substantially longer sequence lengths |
| impractical. |
| |
| This script fuses them. Samples are processed in chunks: a chunk's attention |
| is materialised, every family is computed from it, and the tensors are |
| discarded before the next chunk. Peak attention on disk is CHUNK samples |
| rather than the whole split, so the cost is bounded by --chunk and not by |
| the dataset. |
| |
| The family extractors are called unmodified, on the same inputs in the same |
| order, so the output files are identical to the two-stage pipeline. Verify |
| with --verify-against, which compares against an existing extraction. |
| |
| python extraction/scripts/05_extract_streaming.py --config <cfg.yaml> |
| python extraction/scripts/05_extract_streaming.py --config <cfg.yaml> \ |
| --chunk 128 --scratch /dev/shm/attn |
| """ |
| from __future__ import annotations |
| import argparse |
| import shutil |
| import sys |
| import time |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
| import torch |
|
|
| ROOT = Path(__file__).resolve().parents[1] |
| sys.path.insert(0, str(ROOT)) |
| sys.path.insert(0, str(ROOT.parent)) |
|
|
| from src.utils import load_config, seed_everything, device_from_cfg, ensure_dir |
| from src.load_data import load_splits |
| from src.load_model import load_classification_model, move |
| from src.extract_attention import _build_dataloader |
| from src.family_specs import write_family_file |
|
|
| M2 = ("graph", "ripser", "template") |
| TOKTOPO = ("toktopo_pd", "toktopo_graph") |
|
|
|
|
| def _dump_chunk(model, batch_texts, tokenizer, cfg, device, scratch: Path, |
| idxs: list[int]) -> None: |
| """Run the encoder over one chunk and write its attention to scratch.""" |
| scratch.mkdir(parents=True, exist_ok=True) |
| loader = _build_dataloader(batch_texts, tokenizer, cfg["data"]["text_col"], |
| cfg["data"]["label_col"], cfg["model"]["max_length"], |
| cfg["inference"]["batch_size"]) |
| pos = 0 |
| with torch.no_grad(): |
| for batch in loader: |
| out = model(input_ids=batch["input_ids"].to(device), |
| attention_mask=batch["attention_mask"].to(device), |
| output_attentions=True) |
| attn = torch.stack(out.attentions, dim=1).cpu().numpy().astype(np.float16) |
| for b in range(attn.shape[0]): |
| seq = int(batch["attention_mask"][b].sum().item()) |
| np.savez_compressed(scratch / f"{idxs[pos]:06d}.npz", |
| attn=attn[b, :, :, :seq, :seq], seq_len=seq) |
| pos += 1 |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--config", required=True) |
| ap.add_argument("--splits", nargs="+", default=["train", "validation", "test"]) |
| ap.add_argument("--chunk", type=int, default=512, |
| help="samples whose attention is on disk at once") |
| ap.add_argument("--workers", type=int, default=8) |
| ap.add_argument("--scratch", type=Path, default=None, |
| help="where chunk attention goes (default: <output_dir>/_chunk)") |
| ap.add_argument("--verify-against", type=Path, default=None, |
| help="an existing outputs/<cfg> dir; compare features and exit") |
| 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"]) |
| ensure_dir(out_dir / "features") |
| device = device_from_cfg(cfg) |
| scratch = args.scratch or (out_dir / "_chunk") |
|
|
| splits_data = load_splits(cfg) |
| 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).eval() |
|
|
| from src.extract_topological_features import recompute_from_attention |
| |
| from importlib.util import spec_from_file_location, module_from_spec |
| _sp = spec_from_file_location("_s02", Path(__file__).parent / "02_extract_features.py") |
| _s02 = module_from_spec(_sp); _sp.loader.exec_module(_s02) |
| _split_topology_arrays = _s02._split_topology_arrays |
| from src.extract_toktopo import compute_toktopo |
| from src.extract_intra_attn_features import compute_intra_attn_features |
| from src.extract_punct_dist import compute_punct_dist |
|
|
| for split in args.splits: |
| preds = pd.read_parquet(out_dir / f"predictions_{split}.parquet") |
| idxs = preds["idx"].tolist() |
| raw = splits_data[split].reset_index(drop=True) |
| raw_m = raw.loc[raw["idx"].isin(idxs)].set_index("idx").loc[idxs].reset_index() |
| N = len(idxs) |
| acc: dict[str, list] = {} |
| cols: dict[str, list] = {} |
| t0 = time.time() |
|
|
| for s in range(0, N, args.chunk): |
| e = min(s + args.chunk, N) |
| sub_idx = idxs[s:e] |
| shutil.rmtree(scratch, ignore_errors=True) |
| _dump_chunk(model, raw_m.iloc[s:e], tokenizer, cfg, device, scratch, sub_idx) |
|
|
| g, r, t = recompute_from_attention(scratch, sub_idx, n_workers=args.workers) |
| (rip, rc), (tem, tc), (grp, gc) = _split_topology_arrays(g, r, t, len(sub_idx)) |
| for fam, arr, c in (("ripser", rip, rc), ("template", tem, tc), ("graph", grp, gc)): |
| acc.setdefault(fam, []).append(arr); cols[fam] = c |
|
|
| tt, tcols = compute_toktopo(scratch, sub_idx, n_workers=args.workers, max_dim=1) |
| acc.setdefault("_toktopo", []).append(tt); cols["_toktopo"] = tcols |
|
|
| ia, iac = compute_intra_attn_features(scratch, sub_idx, device=device) |
| acc.setdefault("intra_attn", []).append(ia); cols["intra_attn"] = iac |
|
|
| pu, puc = compute_punct_dist(scratch, tokenizer, cfg["model"]["max_length"], |
| raw_m.iloc[s:e].reset_index(drop=True), |
| cfg["data"]["text_col"], n_workers=args.workers) |
| acc.setdefault("punct", []).append(pu); cols["punct"] = puc |
|
|
| shutil.rmtree(scratch, ignore_errors=True) |
| print(f" [{split}] {e}/{N} ({time.time()-t0:.0f}s)", flush=True) |
|
|
| |
| tt = np.concatenate(acc.pop("_toktopo"), axis=0); tcols = cols.pop("_toktopo") |
| pd_cols = [i for i, c in enumerate(tcols) if c.startswith("toktopo_h")] |
| gr_cols = [i for i, c in enumerate(tcols) |
| if not c.startswith("toktopo_h") and "_xbc_" not in c] |
| write_family_file(out_dir, cfg_name, "toktopo_pd", split, |
| tt[:, pd_cols], [tcols[i] for i in pd_cols], idxs) |
| write_family_file(out_dir, cfg_name, "toktopo_graph", split, |
| tt[:, gr_cols], [tcols[i] for i in gr_cols], idxs) |
| for fam, parts in acc.items(): |
| write_family_file(out_dir, cfg_name, fam, split, |
| np.concatenate(parts, axis=0), cols[fam], idxs) |
| print(f"[{split}] {N} samples, peak attention on disk = {args.chunk} " |
| f"({time.time()-t0:.0f}s)", flush=True) |
|
|
| if args.verify_against: |
| ok = True |
| for split in args.splits: |
| for fam in list(M2) + list(TOKTOPO) + ["intra_attn", "punct"]: |
| a = out_dir / "features" / f"{cfg_name}_{fam}_{split}.npz" |
| b = args.verify_against / "features" / f"{cfg_name}_{fam}_{split}.npz" |
| if not b.exists(): |
| continue |
| x = np.load(a, allow_pickle=True)["features"] |
| y = np.load(b, allow_pickle=True)["features"] |
| same = x.shape == y.shape and np.allclose(x, y, rtol=1e-5, atol=1e-6, |
| equal_nan=True) |
| ok &= same |
| print(f" {'OK ' if same else 'DIFF'} {fam}_{split} {x.shape}") |
| print("VERIFY", "PASS" if ok else "FAIL") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
