#!/usr/bin/env python3 """ extract_models.py — Standardized Hidden State Extraction ========================================================= Extracts last-token hidden states from any model in models.yaml. Produces a standardized cache (.npz) with identical schema across all models. Features: - Per-model chat template handling via tokenizer.apply_chat_template() - Saves lm_head + layer_norm weights for logit lens - Incremental checkpointing every 500 samples - Skip if cache already exists (--skip_if_cached) - Reuse existing Qwen2.5 cache with field remapping Usage: # Extract Qwen2.5 (reuses existing cache) python extract_models.py --model qwen25 --skip_if_cached # Extract LLaMA-3.1 (fresh extraction, ~2-3h on 1 GPU) CUDA_VISIBLE_DEVICES=0 python extract_models.py --model llama31 # Extract all models sequentially python extract_models.py --all --skip_if_cached # Migrate existing Qwen2.5 cache to v4 format python extract_models.py --model qwen25 --migrate_from data/experiments/v3/qwen25/cached_qwen25.npz """ import argparse import json import logging import os import sys import time import warnings from datetime import datetime from pathlib import Path import numpy as np import torch import yaml warnings.filterwarnings("ignore") logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", handlers=[logging.StreamHandler()]) logger = logging.getLogger(__name__) # ───────────────────────────────────────────────────────────────────────────── # CONFIG # ───────────────────────────────────────────────────────────────────────────── def load_config(config_path="models.yaml"): with open(config_path) as f: cfg = yaml.safe_load(f) return cfg def get_model_cfg(cfg, model_key): if model_key not in cfg["models"]: raise ValueError(f"Unknown model '{model_key}'. " f"Available: {list(cfg['models'].keys())}") mcfg = cfg["models"][model_key] mcfg["key"] = model_key return mcfg # ───────────────────────────────────────────────────────────────────────────── # DATASET LOADING # ───────────────────────────────────────────────────────────────────────────── def load_dataset(dataset_path, model_key, drift_key): """Load and prepare dataset with model-specific drift labels.""" logger.info(f"Loading dataset: {dataset_path}") with open(dataset_path) as f: raw = json.load(f) samples = raw.get("samples", raw) # Assign is_drifted from model-specific column for s in samples: val = s.get(drift_key, s.get("is_drifted", False)) if isinstance(val, str): s["is_drifted"] = val.lower() in ("true", "1", "yes") else: s["is_drifted"] = bool(val) n_d = sum(1 for s in samples if s["is_drifted"]) n_s = len(samples) - n_d logger.info(f" Total={len(samples)} Drifted={n_d} Stable={n_s}") if n_d == 0: logger.error(f"No drifted samples for drift_key='{drift_key}'. Aborting.") sys.exit(1) return samples # ───────────────────────────────────────────────────────────────────────────── # MODEL LOADING # ───────────────────────────────────────────────────────────────────────────── def load_model(model_name, device="auto"): from transformers import AutoModelForCausalLM, AutoTokenizer logger.info(f"Loading model: {model_name}") tok = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True) if tok.pad_token is None: tok.pad_token = tok.eos_token mdl = AutoModelForCausalLM.from_pretrained( model_name, device_map=device, trust_remote_code=True, output_hidden_states=True, torch_dtype=torch.float16, ) mdl.eval() n_layers = mdl.config.num_hidden_layers h_dim = mdl.config.hidden_size logger.info(f" Loaded: L={n_layers} D={h_dim}") return mdl, tok # ───────────────────────────────────────────────────────────────────────────── # LM HEAD EXTRACTION (for logit lens) # ───────────────────────────────────────────────────────────────────────────── def save_lm_head(model, out_dir, model_key): """Save lm_head weight + final layernorm for logit lens analysis.""" lm_path = Path(out_dir) / f"lm_head_{model_key}.npz" if lm_path.exists(): logger.info(f" lm_head already saved: {lm_path}") return lm_w = model.lm_head.weight.detach().float().cpu().numpy() # Find final layer norm — different names across architectures ln = None for attr in ["norm", "final_layernorm", "model.norm", "model.final_layernorm", "ln_f"]: parts = attr.split(".") obj = model try: for p in parts: obj = getattr(obj, p) ln = obj break except AttributeError: continue if ln is not None and hasattr(ln, "weight"): ln_w = ln.weight.detach().float().cpu().numpy() ln_b = (ln.bias.detach().float().cpu().numpy() if hasattr(ln, "bias") and ln.bias is not None else np.zeros_like(ln_w)) else: logger.warning(" Could not find final layernorm — using identity") ln_w = np.ones(model.config.hidden_size, dtype=np.float32) ln_b = np.zeros(model.config.hidden_size, dtype=np.float32) np.savez_compressed(str(lm_path), lm_head=lm_w, ln_weight=ln_w, ln_bias=ln_b) logger.info(f" lm_head saved: {lm_path} (shape={lm_w.shape})") # ───────────────────────────────────────────────────────────────────────────── # TOKENIZATION (handles chat templates properly) # ───────────────────────────────────────────────────────────────────────────── def tokenize_query(tokenizer, query, model_cfg, max_length=512): """Tokenize query using proper chat template for each model.""" is_instruct = model_cfg.get("is_instruct", True) if is_instruct and hasattr(tokenizer, "apply_chat_template"): try: messages = [{"role": "user", "content": query}] input_ids = tokenizer.apply_chat_template( messages, tokenize=True, add_generation_prompt=True, return_tensors="pt", max_length=max_length, truncation=True) attention_mask = torch.ones_like(input_ids) return {"input_ids": input_ids, "attention_mask": attention_mask} except Exception: pass # Fall through to raw tokenization # Raw tokenization for base models or if chat template fails return tokenizer(query, return_tensors="pt", truncation=True, max_length=max_length) # ───────────────────────────────────────────────────────────────────────────── # EXTRACTION # ───────────────────────────────────────────────────────────────────────────── def extract_single(model, tokenizer, sample, model_cfg, max_length=512): """Extract hidden states + logit info for a single sample.""" query = sample.get("query", sample.get("question", "")) answer = sample.get("expected_answer", sample.get("answer", "")) inp = tokenize_query(tokenizer, query, model_cfg, max_length) inp = {k: v.to(model.device) for k, v in inp.items()} with torch.no_grad(): out = model(**inp) n_layers = model.config.num_hidden_layers # Last-token hidden states at every layer hidden_states = {} for l in range(n_layers): h = out.hidden_states[l + 1][0, -1, :].float().cpu() h = torch.clamp(h, -1e6, 1e6) h[torch.isnan(h)] = 0.0 hidden_states[l] = h.numpy() # Output logits logits = out.logits[0, -1, :].float().cpu() logits = torch.clamp(logits, -1e4, 1e4) logits[torch.isnan(logits)] = 0.0 probs = torch.softmax(logits, dim=-1) top_prob = probs.max().item() top_idx = probs.argmax().item() top_token = tokenizer.decode([top_idx]).strip() entropy = -(probs * torch.log(probs + 1e-12)).sum().item() # Correctness: fuzzy match ans_lower = answer.lower().strip() tok_lower = top_token.lower().strip() correct = (ans_lower in tok_lower or tok_lower in ans_lower or any(w in tok_lower for w in ans_lower.split()[:3] if len(w) > 3)) return { "hidden_states": hidden_states, "top_prob": top_prob, "top_token": top_token, "entropy": entropy, "correct": correct, } def run_extraction(model, tokenizer, samples, model_cfg, out_dir, model_key, max_length=512, checkpoint_every=500): """Full extraction loop with incremental checkpointing.""" out_dir = Path(out_dir) n_layers = model.config.num_hidden_layers t0 = time.time() # Save lm_head for logit lens save_lm_head(model, out_dir, model_key) results = [] for idx, s in enumerate(samples): try: ext = extract_single(model, tokenizer, s, model_cfg, max_length) except Exception as e: logger.error(f" Sample {idx} error: {e}") continue result = { "idx": idx, "sample_id": s.get("sample_id", f"s_{idx}"), "query": s.get("query", ""), "expected_answer": s.get("expected_answer", ""), "is_drifted": s["is_drifted"], "relation": s.get("relation", "unknown"), "category": s.get("category", "unknown"), "entity": s.get("entity", ""), "knowledge_type": s.get("knowledge_type", ""), "drift_date": s.get("drift_date", ""), "year": s.get("year", ""), "dataset_source": s.get("dataset_source", ""), "hidden_states": ext["hidden_states"], "top_prob": ext["top_prob"], "top_token": ext["top_token"], "entropy": ext["entropy"], "correct": ext["correct"], } results.append(result) if (idx + 1) % 100 == 0: elapsed = time.time() - t0 rate = (idx + 1) / elapsed eta = (len(samples) - idx - 1) / rate / 60 logger.info(f" {idx+1}/{len(samples)} " f"({rate:.1f} samp/s, ETA {eta:.0f}m)") if (idx + 1) % checkpoint_every == 0: ckpt = out_dir / f"checkpoint_{model_key}_{idx+1}.npz" np.savez_compressed(str(ckpt), results=np.array(results, dtype=object)) logger.info(f" Checkpoint: {ckpt}") # Final save cache_path = out_dir / f"cached_{model_key}.npz" logger.info(f"Saving final cache ({len(results)} samples)...") np.savez_compressed(str(cache_path), results=np.array(results, dtype=object)) elapsed = time.time() - t0 logger.info(f"Done: {cache_path} ({elapsed/60:.1f}m)") # Clean up checkpoints for ckpt in out_dir.glob(f"checkpoint_{model_key}_*.npz"): ckpt.unlink() logger.info(f" Removed checkpoint: {ckpt.name}") # Print summary n_correct = sum(1 for r in results if r["correct"]) n_drifted = sum(1 for r in results if r["is_drifted"]) logger.info(f"\n Summary for {model_key}:") logger.info(f" Samples: {len(results)}") logger.info(f" Drifted: {n_drifted}") logger.info(f" Stable: {len(results) - n_drifted}") logger.info(f" Correct: {n_correct} ({n_correct/len(results):.1%})") logger.info(f" Layers: {n_layers}") logger.info(f" H-dim: {model.config.hidden_size}") # Free GPU del model if torch.cuda.is_available(): torch.cuda.empty_cache() return results # ───────────────────────────────────────────────────────────────────────────── # CACHE MIGRATION (reuse existing caches) # ───────────────────────────────────────────────────────────────────────────── def migrate_cache(src_path, dst_dir, model_key, dataset_path, drift_key): """ Migrate an existing cache to v4 format. Adds missing fields (correct, drift_date, entity, etc.) by joining from the unified dataset. """ logger.info(f"Migrating cache: {src_path} -> v4 format") # Load existing cache d = np.load(src_path, allow_pickle=True) results = d["results"].tolist() logger.info(f" Loaded {len(results)} cached samples") logger.info(f" Fields: {list(results[0].keys())}") # Load dataset for enrichment with open(dataset_path) as f: raw = json.load(f) samples = raw.get("samples", raw) lookup = {s.get("query", ""): s for s in samples} logger.info(f" Dataset: {len(samples)} samples, {len(lookup)} unique queries") # Fields to ensure exist required = ["correct", "is_drifted", "relation", "category", "entity", "knowledge_type", "drift_date", "year", "dataset_source", "sample_id", "expected_answer"] enriched = 0 for r in results: # Fix correct field if "correct" not in r: r["correct"] = r.get("top_answer_matches", False) # Fix is_drifted from model-specific key src = lookup.get(r.get("query", "")) if src is not None: # Use model-specific drift label val = src.get(drift_key, src.get("is_drifted", False)) if isinstance(val, str): r["is_drifted"] = val.lower() in ("true", "1", "yes") else: r["is_drifted"] = bool(val) # Enrich missing fields for field in required: if r.get(field) in (None, "", "None") and field in src: r[field] = src[field] enriched += 1 logger.info(f" Enriched {enriched} field values") # Verify has_correct = sum(1 for r in results if "correct" in r) has_drift_date = sum(1 for r in results if r.get("drift_date") not in (None, "", "None")) n_drifted = sum(1 for r in results if r.get("is_drifted")) n_correct = sum(1 for r in results if r.get("correct")) logger.info(f" After migration:") logger.info(f" has_correct: {has_correct}/{len(results)}") logger.info(f" has_drift_date: {has_drift_date}/{len(results)}") logger.info(f" n_drifted: {n_drifted}") logger.info(f" n_correct: {n_correct}") # Save dst_dir = Path(dst_dir) dst_dir.mkdir(parents=True, exist_ok=True) dst_path = dst_dir / f"cached_{model_key}.npz" logger.info(f" Saving to {dst_path}...") np.savez_compressed(str(dst_path), results=np.array(results, dtype=object)) logger.info(f" Done.") return results # ───────────────────────────────────────────────────────────────────────────── # MAIN # ───────────────────────────────────────────────────────────────────────────── def main(): p = argparse.ArgumentParser( description="Extract hidden states from LLMs for drift detection", formatter_class=argparse.ArgumentDefaultsHelpFormatter) p.add_argument("--model", default="qwen25", help="Model key from models.yaml") p.add_argument("--config", default="models.yaml", help="Path to models.yaml config") p.add_argument("--dataset", default=None, help="Override dataset path from config") p.add_argument("--output_dir", default=None, help="Override output dir from config") p.add_argument("--device", default="auto", help="Device for model loading") p.add_argument("--skip_if_cached", action="store_true", help="Skip extraction if cache already exists") p.add_argument("--migrate_from", default=None, help="Migrate existing cache to v4 format") p.add_argument("--all", action="store_true", help="Extract all models sequentially") args = p.parse_args() cfg = load_config(args.config) defaults = cfg.get("defaults", {}) dataset_path = args.dataset or defaults.get("dataset", "data/knowledge_drift_unified_tier1.json") output_base = args.output_dir or defaults.get("output_dir", "data/experiments/v4") models_to_run = (list(cfg["models"].keys()) if args.all else [args.model]) for model_key in models_to_run: mcfg = get_model_cfg(cfg, model_key) drift_key = mcfg["drift_key"] model_out = Path(output_base) / model_key model_out.mkdir(parents=True, exist_ok=True) cache_path = model_out / f"cached_{model_key}.npz" # Migration mode if args.migrate_from and model_key == args.model: migrate_cache(args.migrate_from, str(model_out), model_key, dataset_path, drift_key) continue # Skip if cached if args.skip_if_cached and cache_path.exists(): logger.info(f"[{model_key}] Cache exists: {cache_path} — skipping") continue # Load dataset samples = load_dataset(dataset_path, model_key, drift_key) # Load model and extract logger.info(f"\n{'='*60}") logger.info(f" Extracting: {model_key} ({mcfg['name']})") logger.info(f"{'='*60}") mdl, tok = load_model(mcfg["name"], args.device) max_length = defaults.get("max_length", 512) run_extraction(mdl, tok, samples, mcfg, str(model_out), model_key, max_length=max_length) logger.info("\nAll extractions complete.") if __name__ == "__main__": main()