scripts/04_infer_aime25.py

"""
Stage 04 (v8b): AIME25 inference at 4 alphas with ground-truth grading.

Take the 03b layer set, apply a UNIFORM global alpha to all selected
layers, sweep alpha in {1.0, 0.7, 0.3, 0.0}, run ONE seed (default 0)
over the 30 AIME25 problems, and grade against the integer answer key.

Per (problem, alpha) we record: prediction, correctness, thinking-token
count, reflection-marker count (BehaviorDetector), repetition/collapse.

Resume: per-record JSONL cache (one line per (problem, alpha)).
"""
import argparse, json, os, re, sys, time
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

import torch
from tqdm import tqdm
from configs import get_config
from configs.paths import AIME25_PATH, AIME25_ANSWERS_PATH, LOG_DIR, dim_paths, ensure_dirs
from src.detectors import BehaviorDetector
from src.interventions import generate_plain, generate_with_alpha
from src.utils import (
    build_chat_prompt, get_device, load_model_and_tokenizer,
    read_json, read_jsonl, setup_logger, write_json, think_segment,
)

CREST_SYSTEM = ("Answer the following questions. You should think step-by-step "
                "and put your final answer within \\boxed{}.")


def extract_boxed_int(text):
    """LAST \\boxed{...} content (nested-brace aware), parsed as int."""
    if not text:
        return None
    matches, idx = [], 0
    while True:
        i = text.find("\\boxed", idx)
        if i < 0:
            break
        j = text.find("{", i)
        if j < 0:
            break
        depth, end = 0, -1
        for k in range(j, len(text)):
            if text[k] == "{":
                depth += 1
            elif text[k] == "}":
                depth -= 1
                if depth == 0:
                    end = k
                    break
        if end > j:
            matches.append(text[j + 1:end])
            idx = end + 1
        else:
            break
    if not matches:
        return None
    s = matches[-1].strip()
    for ch in ("$", ",", " "):
        s = s.replace(ch, "")
    s = re.sub(r"\\[,!;:]", "", s)
    s = re.sub(r"\\text\{[^}]*\}", "", s)
    s = s.replace("\\\\", "")
    try:
        return int(s)
    except ValueError:
        pass
    m = re.search(r"-?\d+", s)
    if m:
        try:
            return int(m.group())
        except ValueError:
            pass
    return None


def repetition_score(text, tail_chars=400, ngram=30):
    tail = text[-tail_chars:] if len(text) > tail_chars else text
    if len(tail) < ngram * 2:
        return 0.0
    seen, repeated, total = {}, 0, 0
    for i in range(len(tail) - ngram):
        chunk = tail[i:i + ngram]
        total += 1
        if chunk in seen:
            repeated += 1
        else:
            seen[chunk] = 1
    return repeated / total if total else 0.0


def load_aime25():
    items = read_jsonl(AIME25_PATH)
    probs = []
    for it in items:
        for k in ("problem", "question", "query", "Problem"):
            if k in it and it[k]:
                probs.append(it[k]); break
    return probs


def load_gt():
    gt = {}
    if not os.path.exists(AIME25_ANSWERS_PATH):
        return gt
    with open(AIME25_ANSWERS_PATH) as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            d = json.loads(line)
            try:
                gt[int(d["idx"])] = int(str(d["answer"]).strip())
            except (ValueError, TypeError, KeyError):
                pass
    return gt


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--dimension", default="monitoring")
    ap.add_argument("--alphas", type=float, nargs="+", default=[1.0, 0.7, 0.3, 0.0])
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--gen-max-tokens", 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)
    gen_max = args.gen_max_tokens or cfg.GEN_MAX_NEW_TOKENS
    temperature = getattr(cfg, "DEFAULT_TEMPERATURE", 0.6)
    top_p = getattr(cfg, "DEFAULT_TOP_P", 0.95)

    log = setup_logger("04_infer_aime25",
                       os.path.join(LOG_DIR, f"04_infer_aime25_seed{args.seed}.log"))
    log.info("=" * 72)
    log.info(f"Stage 04 AIME25  alphas={args.alphas}  seed={args.seed}")
    log.info(f"  gen_max={gen_max}  temp={temperature}  top_p={top_p}")
    log.info("=" * 72)

    if not os.path.exists(p.DIRECTIONS):
        log.error(f"missing {p.DIRECTIONS} — run stage 02 first"); sys.exit(1)
    if not os.path.exists(p.SELECTED_LAYERS):
        log.error(f"missing {p.SELECTED_LAYERS} — run stage 03b first"); sys.exit(1)

    dblob = torch.load(p.DIRECTIONS, map_location="cpu", weights_only=False)
    directions_all = {int(L): v for L, v in dblob["directions"].items()}
    sel = read_json(p.SELECTED_LAYERS)
    selected = [int(L) for L in sel["selected_layers"]]
    directions = {L: directions_all[L] for L in selected if L in directions_all}
    log.info(f"  selected layers ({len(directions)}): {sorted(directions.keys())}")
    if not directions:
        log.error("No directions for selected layers."); sys.exit(2)

    problems = load_aime25()
    gt = load_gt()
    log.info(f"  AIME25 problems: {len(problems)}   GT entries: "
             f"{sum(1 for v in gt.values() if v is not None)}")

    out_path = os.path.join(p.RESULTS_DIR, f"aime25_seed{args.seed}_4alpha.jsonl")
    sum_path = os.path.join(p.RESULTS_DIR, f"aime25_seed{args.seed}_4alpha_summary.json")

    if args.force and os.path.exists(out_path):
        os.remove(out_path)
    seen = set()
    if os.path.exists(out_path):
        for line in open(out_path):
            line = line.strip()
            if line:
                try:
                    seen.add(json.loads(line)["_key"])
                except Exception:
                    pass
        log.info(f"  [resume] {len(seen)} records cached")

    todo = [(pi, prob, a, f"P{pi}_A{a:.2f}")
            for pi, prob in enumerate(problems)
            for a in args.alphas
            if f"P{pi}_A{a:.2f}" not in seen]
    log.info(f"  records to compute: {len(todo)} / {len(problems) * len(args.alphas)}")

    detector = BehaviorDetector(cfg)
    device = get_device()
    model = tokenizer = None
    if todo:
        log.info("Loading model...")
        model, tokenizer = load_model_and_tokenizer(device=device)

    fh = open(out_path, "a", encoding="utf-8") if todo else None
    pbar = tqdm(todo, desc=" AIME25 infer", unit="gen", dynamic_ncols=True)
    n_done = n_ok = 0
    for pi, prob, a, key in pbar:
        prompt = build_chat_prompt(tokenizer, prob, enable_thinking=True,
                                   system=CREST_SYSTEM)
        gen_seed = args.seed * 1000 + pi
        t0 = time.time()
        if a >= 1.0 - 1e-6:
            cot = generate_plain(model, tokenizer, prompt, device,
                                 max_new_tokens=gen_max, do_sample=True,
                                 temperature=temperature, top_p=top_p, seed=gen_seed)
            eff = {int(L): 1.0 for L in directions}
        else:
            eff = {int(L): float(a) for L in directions}   # UNIFORM global alpha
            cot = generate_with_alpha(model, tokenizer, prompt, directions, eff,
                                      device, max_new_tokens=gen_max, do_sample=True,
                                      temperature=temperature, top_p=top_p, seed=gen_seed)
        elapsed = time.time() - t0

        # Grading uses the FULL output (boxed answer lives after </think>).
        pred = extract_boxed_int(cot)
        gtv = gt.get(pi)
        correct = (pred is not None and gtv is not None and pred == gtv)

        # Every behavioral metric is measured ONLY inside <think>...</think>,
        # the same object the steering direction was learned on.
        think = think_segment(cot)
        det = detector.detect(think)
        rep = repetition_score(think)
        ttok = len(tokenizer(think, add_special_tokens=False)["input_ids"])

        rec = {
            "_key": key, "problem_idx": pi, "alpha": a, "seed": args.seed,
            "problem": prob, "cot": cot,
            "pred": pred, "gt": gtv, "correct": correct,
            "has_boxed": pred is not None,
            "think_tokens": ttok, "n_chars": len(think),
            "mon_total": det["total"], "repetition_score": rep,
            "collapse": rep > 0.5, "elapsed_s": elapsed,
        }
        if fh:
            fh.write(json.dumps(rec, ensure_ascii=False) + "\n"); fh.flush()
        n_done += 1
        n_ok += int(correct)
        pbar.set_postfix(acc=f"{100.0 * n_ok / n_done:.0f}%",
                         a=f"{a:.2f}", tok=ttok, t=f"{elapsed:.0f}s")
        log.info(f"  {key}: pred={pred} gt={gtv} {'OK' if correct else 'x'}  "
                 f"think_tok={ttok} mon={det['total']} rep={rep:.2f} t={elapsed:.0f}s")
    pbar.close()
    if fh:
        fh.close()

    recs = []
    for line in open(out_path):
        line = line.strip()
        if line:
            try:
                recs.append(json.loads(line))
            except Exception:
                pass

    avg = lambda xs: sum(xs) / len(xs) if xs else 0.0
    summary = {}
    log.info("\n=== SUMMARY (AIME25, ground-truth grading, seed %d) ===" % args.seed)
    log.info(f"{'alpha':>6} {'n':>3} {'acc':>8} {'correct':>8} {'noBox':>6} "
             f"{'think_tok':>10} {'mon':>6} {'collapse':>9}")
    for a in sorted(args.alphas, reverse=True):
        rs = [r for r in recs if abs(r["alpha"] - a) < 1e-6]
        if not rs:
            continue
        n = len(rs)
        acc = sum(r["correct"] for r in rs) / n
        summary[f"{a:.2f}"] = {
            "n": n, "accuracy": acc,
            "n_correct": sum(r["correct"] for r in rs),
            "n_no_boxed": n - sum(r["has_boxed"] for r in rs),
            "mean_think_tokens": avg([r["think_tokens"] for r in rs]),
            "mean_chars": avg([r["n_chars"] for r in rs]),
            "mean_mon": avg([r["mon_total"] for r in rs]),
            "collapse_rate": sum(r["collapse"] for r in rs) / n,
        }
        log.info(f"{a:>6.2f} {n:>3} {acc:>7.1%} "
                 f"{sum(r['correct'] for r in rs):>8} "
                 f"{n - sum(r['has_boxed'] for r in rs):>6} "
                 f"{avg([r['think_tokens'] for r in rs]):>10.0f} "
                 f"{avg([r['mon_total'] for r in rs]):>6.1f} "
                 f"{sum(r['collapse'] for r in rs)/n*100:>8.1f}%")

    write_json({"seed": args.seed, "alphas": args.alphas,
                "selected_layers": sorted(directions.keys()),
                "prompt_system": CREST_SYSTEM, "summary": summary}, sum_path)
    log.info(f"\nSaved {out_path}\n      {sum_path}\nDone.")


if __name__ == "__main__":
    main()