| """ |
| Stage 01 (v8b): Capture hidden states from CONTRASTIVE CoT pairs (dense). |
| |
| Reads each pair (problem, high_reflection_cot, low_reflection_cot) from |
| RAW_COTS_PATH. For each CoT: |
| - Forward pass with output_hidden_states=True. |
| - Sample SAMPLES_PER_COT positions uniformly across the sequence. |
| - Label sampled positions 1 for high-reflection, 0 for low. |
| |
| Qwen3-8B is dense, so there is no expert routing to capture. |
| |
| Saves per-layer tensors to p.ACTIVATIONS. Resume: skip if it exists. |
| """ |
| import argparse, os, sys |
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) |
|
|
| import torch |
| from configs import get_config |
| from configs.paths import RAW_COTS_PATH, LOG_DIR, dim_paths, ensure_dirs |
| from src.contrastive_capture import collect_contrastive_activations |
| from src.utils import ( |
| get_device, load_model_and_tokenizer, read_jsonl, setup_logger, |
| ) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--dimension", default="monitoring") |
| ap.add_argument("--n-train", type=int, default=None) |
| ap.add_argument("--samples-per-cot", type=int, default=None) |
| ap.add_argument("--max-seq-len", type=int, default=None) |
| ap.add_argument("--force", action="store_true") |
| args = ap.parse_args() |
|
|
| ensure_dirs(args.dimension) |
| cfg = get_config(args.dimension) |
| p = dim_paths(args.dimension) |
| n_train = args.n_train or cfg.N_TRAIN_COTS |
| samples_per_cot = args.samples_per_cot or cfg.SAMPLES_PER_COT |
| max_seq_len = args.max_seq_len or cfg.MAX_SEQ_LEN_FOR_CAPTURE |
|
|
| log = setup_logger("01_capture", os.path.join(LOG_DIR, f"01_capture_{cfg.NAME}.log")) |
| log.info("=" * 70) |
| log.info(f"Stage 01 [{cfg.NAME}] (v8b dense capture)") |
| log.info(f" RAW_COTS_PATH = {RAW_COTS_PATH}") |
| log.info(f" n_train = {n_train}") |
| log.info(f" samples_per_cot = {samples_per_cot}") |
| log.info(f" max_seq_len = {max_seq_len}") |
| log.info(f" TARGET_LAYERS = {cfg.TARGET_LAYERS}") |
| log.info("=" * 70) |
|
|
| if os.path.exists(p.ACTIVATIONS) and not args.force: |
| try: |
| blob = torch.load(p.ACTIVATIONS, map_location="cpu", weights_only=False) |
| log.info(f" [resume] {p.ACTIVATIONS} exists " |
| f"({len(blob.get('per_layer', {}))} layers) — SKIP. " |
| f"Use --force to recompute.") |
| return |
| except Exception as e: |
| log.warning(f" [resume] unreadable ({e}); recomputing") |
|
|
| if not os.path.exists(RAW_COTS_PATH): |
| log.error(f"raw_cots not found: {RAW_COTS_PATH}. Run stage 00 first.") |
| sys.exit(1) |
|
|
| raw = read_jsonl(RAW_COTS_PATH) |
| pairs = [r for r in raw |
| if r.get("high_reflection_cot") and r.get("low_reflection_cot")][:n_train] |
| log.info(f" loaded {len(pairs)} contrastive pairs") |
| if len(pairs) < 10: |
| log.error("Too few pairs to learn a stable direction; aborting.") |
| sys.exit(2) |
|
|
| device = get_device() |
| log.info("Loading model...") |
| model, tokenizer = load_model_and_tokenizer(device=device) |
|
|
| log.info("Capturing contrastive activations...") |
| per_layer, stats = collect_contrastive_activations( |
| model, tokenizer, pairs, cfg.TARGET_LAYERS, device, |
| samples_per_cot=samples_per_cot, |
| max_seq_len=max_seq_len, |
| skip_head=16, logger=log, |
| ) |
| log.info(f" pos={stats['pos']}, neg={stats['neg']}") |
| if stats["pos"] < 100 or stats["neg"] < 100: |
| log.warning("Very few captured positions; signal may be weak.") |
|
|
| save = { |
| "dimension": cfg.NAME, |
| "stats": stats, |
| "n_pairs": len(pairs), |
| "target_layers": cfg.TARGET_LAYERS, |
| "samples_per_cot": samples_per_cot, |
| "per_layer": { |
| int(L): { |
| "acts": per_layer[L]["acts"], |
| "labels": per_layer[L]["labels"], |
| } |
| for L in per_layer |
| }, |
| } |
| tmp = p.ACTIVATIONS + ".tmp" |
| torch.save(save, tmp) |
| os.replace(tmp, p.ACTIVATIONS) |
| log.info(f"Saved {p.ACTIVATIONS}. Done.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
