| |
| """Query-end residual states for the main-forward queries. [GPU] |
| |
| python src/extract_hidden.py --model Llama-3.2-1B |
| |
| Protocol 2.4 fixes the probe position: |
| |
| the last valid input token -- the model has read the question but has not |
| yet emitted an answer token |
| |
| which is exactly the prefill position that produces the first generated token |
| in eval_run.py. The prompt string is therefore built by importing eval_run's own |
| `build_prompt`, not by re-deriving it here: if the two ever diverged, ISS would |
| be measured on a different question than BCS/BES, and nothing downstream would |
| notice. |
| |
| Only decoder blocks inside the J-Lens analysis window (protocol 7.10, |
| d_l = l/(L-1) >= 0.4) are stored. Layer `l` is the OUTPUT of block l, so the |
| last stored layer, l = L-1, is the final residual stream that J-Lens transports |
| into. |
| |
| Output, per model: |
| |
| outputs/hidden/<model>/L###.npy float16 [n_queries, d] |
| outputs/hidden/<model>/index.json query order + layer list + checksums |
| """ |
| import os, sys, json, time, argparse, hashlib |
|
|
| import numpy as np |
| import torch |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| import mcommon as mc |
|
|
| |
| sys.path.insert(0, mc.runner_dir()) |
| from eval_run import build_prompt |
|
|
|
|
| def decoder_layers(model): |
| """The block list, across Llama / Qwen2 / Mistral / Gemma2 / OLMo2.""" |
| for attr in ("model.layers", "model.decoder.layers", "transformer.h"): |
| obj = model |
| try: |
| for part in attr.split("."): |
| obj = getattr(obj, part) |
| if isinstance(obj, torch.nn.ModuleList) and len(obj): |
| return obj |
| except AttributeError: |
| continue |
| raise SystemExit(f"cannot locate decoder blocks on {type(model).__name__}") |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--model", required=True) |
| ap.add_argument("--batch", type=int, default=0) |
| ap.add_argument("--limit", type=int, default=0, help="debug: first N queries") |
| ap.add_argument("--force", action="store_true") |
| args = ap.parse_args() |
|
|
| conf = mc.cfg()["extraction"] |
| entry = mc.model_entry(args.model) |
| dest = mc.out("hidden", args.model) |
| os.makedirs(dest, exist_ok=True) |
| index_path = os.path.join(dest, "index.json") |
| if os.path.exists(index_path) and not args.force: |
| if json.load(open(index_path)).get("complete"): |
| print(f"[{args.model}] already extracted; --force to redo") |
| return |
|
|
| rows = mc.main_forward_queries() |
| if args.limit: |
| rows = rows[:args.limit] |
| N = len(rows) |
|
|
| path = mc.model_path(args.model) |
| tok = AutoTokenizer.from_pretrained(path) |
| if tok.pad_token is None: |
| tok.pad_token = tok.eos_token |
| |
| |
| tok.padding_side = "left" |
| tok.truncation_side = "left" |
| model = AutoModelForCausalLM.from_pretrained( |
| path, dtype=torch.bfloat16, device_map={"": 0}).eval() |
|
|
| blocks = decoder_layers(model) |
| L = len(blocks) |
| if L != entry.get("n_layers", L): |
| raise SystemExit(f"{args.model}: config.json has {L} layers but " |
| f"models.yaml says {entry['n_layers']}") |
| d = int(model.config.hidden_size) |
| window = mc.layer_window(L) |
| if len(window) != entry.get("jlens_window", len(window)): |
| raise SystemExit(f"{args.model}: computed window {len(window)} layers " |
| f"but models.yaml says {entry['jlens_window']}") |
| print(f"[{args.model}] L={L} d={d} window={window[0]}..{window[-1]} " |
| f"({len(window)} layers) N={N}", flush=True) |
|
|
| stores = {l: np.lib.format.open_memmap( |
| os.path.join(dest, f"L{l:03d}.npy"), mode="w+", |
| dtype=np.float16, shape=(N, d)) for l in window} |
|
|
| grabbed = {} |
|
|
| def make_hook(l): |
| def hook(_module, _inp, output): |
| h = output[0] if isinstance(output, tuple) else output |
| |
| |
| grabbed[l] = h[:, -1, :].detach().float() |
| return hook |
|
|
| handles = [blocks[l].register_forward_hook(make_hook(l)) for l in window] |
|
|
| prompts = [build_prompt(r) for r in rows] |
| B = args.batch or conf["batch_size"] |
| max_len = conf["max_prompt_len"] |
| |
| order = sorted(range(N), key=lambda i: len(prompts[i])) |
| t0 = time.time() |
| with torch.no_grad(): |
| for b in range(0, N, B): |
| idx = order[b:b + B] |
| enc = tok([prompts[i] for i in idx], return_tensors="pt", padding=True, |
| truncation=True, max_length=max_len).to(0) |
| grabbed.clear() |
| model(**enc, use_cache=False) |
| for l in window: |
| stores[l][idx] = grabbed[l].to(torch.float16).cpu().numpy() |
| if b % (B * 40) == 0: |
| done = b + len(idx) |
| print(f" {done}/{N} {done / max(time.time() - t0, 1e-9):.1f}/s", |
| flush=True) |
| for h in handles: |
| h.remove() |
| for l in window: |
| stores[l].flush() |
|
|
| meta = { |
| "model": args.model, |
| "complete": True, |
| "n_queries": N, |
| "n_layers": L, |
| "d_model": d, |
| "window": window, |
| "window_depths": [round(l / max(L - 1, 1), 4) for l in window], |
| "late_window": mc.late_window(L), |
| "position": conf["position"], |
| "dtype": "float16", |
| "max_prompt_len": max_len, |
| "batch_size": B, |
| "seconds": round(time.time() - t0, 1), |
| |
| |
| "query_ids": [r["query_id"] for r in rows], |
| "fact_ids": [r["fact_id"] for r in rows], |
| "families": [r["condition_family"] for r in rows], |
| "query_order_sha256": hashlib.sha256( |
| "\n".join(r["query_id"] for r in rows).encode()).hexdigest(), |
| } |
| mc.write_json(index_path, meta) |
| gb = N * len(window) * d * 2 / 1e9 |
| print(f"[{args.model}] wrote {len(window)} layers x {N} x {d} " |
| f"({gb:.1f} GB) {meta['seconds']}s EXTRACT_DONE", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
