scripts/intervention_prompt_prefix_correct_only.py

"""Prompt-prefix injection ablation: only use prefixes from FP16-CORRECT problems.

This is the foundational ablation flagged by a reviewer concern: the original
prompt-prefix experiment (scripts/intervention_prompt_prefix.py) injects
reference-model steps into the quantized model's prompt regardless of
whether the reference model's final answer is correct. If the reference
is wrong on ~27% of MATH-500 problems, the prefix leaks a wrong opening
~27% of the time; conversely, the accuracy boost may be partially
explained by the fact that FP16-correct prefixes bias the set of
problems where the prefix is ``useful.''

This script restricts the prefix source to problems where FP16's final
answer matches the gold, and injects an empty prefix otherwise.
Comparing this result to the original sweep isolates ``partial-solution
leak from a known-good reference'' from ``conditional subset selection
bias.''
"""

import argparse
import json
import os
import sys
import time

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))


def load_benchmark(name, max_samples=None):
    from datasets import load_dataset
    if name == "gsm8k":
        ds = load_dataset("openai/gsm8k", "main", split="test")
        problems = [{"id": f"gsm8k_{i}", "question": ex["question"], "answer": ex["answer"]} for i, ex in enumerate(ds)]
    elif name == "math500":
        ds = load_dataset("HuggingFaceH4/MATH-500", split="test")
        problems = [{"id": f"math500_{i}", "question": ex["problem"], "answer": ex["answer"]} for i, ex in enumerate(ds)]
    elif name == "gpqa":
        ds = load_dataset("Idavidrein/gpqa", "gpqa_diamond", split="train")
        problems = [{"id": f"gpqa_{i}", "question": ex["Question"], "answer": ex.get("Correct Answer", "")} for i, ex in enumerate(ds)]
    else:
        raise ValueError(f"Unknown benchmark: {name}")
    return problems[:max_samples] if max_samples else problems


def load_fp16_correct_prefixes(segmented_path: str, benchmark: str, k: int):
    """Return {problem_id: prefix_text} restricted to FP16-correct problems.

    Correctness is checked via scripts/eval_accuracy.py which uses math_verify
    for LaTeX-aware comparison.
    """
    from eval_accuracy import extract_pred, _equiv, _load_gold
    golds = _load_gold(benchmark)

    prefixes = {}
    n_total, n_correct, n_with_prefix = 0, 0, 0
    with open(segmented_path) as f:
        for line in f:
            t = json.loads(line)
            pid = t.get("problem_id")
            n_total += 1
            gold = t.get("gold_answer") or golds.get(pid, "")
            pred = extract_pred(t)
            if _equiv(pred, gold):
                n_correct += 1
                steps = (t.get("steps") or [])[:k]
                if steps:
                    prefix = "\n\n".join(s.get("text", "").strip()
                                         for s in steps if s.get("text"))
                    if prefix:
                        prefixes[pid] = prefix
                        n_with_prefix += 1
    print(f"  FP16 correct: {n_correct}/{n_total} ({n_correct/n_total:.1%})")
    print(f"  Prefixes available: {n_with_prefix}")
    return prefixes


def build_prompt(question, prefix, tokenizer):
    messages = [{"role": "user", "content": question}]
    base = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    return base + prefix + "\n\n" if prefix else base


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--model", required=True)
    parser.add_argument("--quant", default="bnb_nf4", choices=["fp16", "awq", "gptq", "bnb_nf4"])
    parser.add_argument("--bits", type=int, default=4)
    parser.add_argument("--benchmark", required=True, choices=["gsm8k", "math500", "gpqa"])
    parser.add_argument("--fp16-segmented", required=True)
    parser.add_argument("--k", type=int, required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--max-samples", type=int, default=None)
    parser.add_argument("--max-tokens", type=int, default=4096)
    parser.add_argument("--gpu-memory-utilization", type=float, default=0.55)
    parser.add_argument("--max-model-len", type=int, default=8192)
    args = parser.parse_args()

    os.makedirs(args.output, exist_ok=True)
    out_file = os.path.join(args.output, f"{args.benchmark}_run0.jsonl")
    if os.path.exists(out_file):
        print(f"[SKIP] {out_file}"); return

    from vllm import LLM, SamplingParams
    from transformers import AutoTokenizer

    kwargs = dict(model=args.model, dtype="float16", trust_remote_code=True,
                  gpu_memory_utilization=args.gpu_memory_utilization,
                  max_model_len=args.max_model_len, enforce_eager=True)
    if args.quant == "bnb_nf4":
        kwargs["quantization"] = "bitsandbytes"; kwargs["load_format"] = "bitsandbytes"

    print(f"Loading model: {args.model} ({args.quant})")
    llm = LLM(**kwargs)
    tokenizer = AutoTokenizer.from_pretrained(args.model, trust_remote_code=True)

    problems = load_benchmark(args.benchmark, args.max_samples)
    print(f"  {len(problems)} problems")

    print(f"Loading FP16-CORRECT prefixes (k={args.k}) from {args.fp16_segmented}")
    prefixes = load_fp16_correct_prefixes(args.fp16_segmented, args.benchmark, args.k) if args.k > 0 else {}

    prompts = [build_prompt(p["question"], prefixes.get(p["id"], ""), tokenizer) for p in problems]

    sampling = SamplingParams(temperature=0.0, max_tokens=args.max_tokens)
    start = time.time()
    outputs = llm.generate(prompts, sampling)
    elapsed = time.time() - start

    quant_str = f"{args.quant}_w{args.bits}_prefix_fp16correct_k{args.k}"
    n_with_prefix = sum(1 for p in problems if prefixes.get(p["id"]))
    with open(out_file, "w") as f:
        for p, out in zip(problems, outputs):
            gen = out.outputs[0]
            pref = prefixes.get(p["id"], "")
            merged = (pref + "\n\n" + gen.text) if pref else gen.text
            f.write(json.dumps({
                "problem_id": p["id"],
                "question": p["question"],
                "gold_answer": p["answer"],
                "model": args.model,
                "quantization": quant_str,
                "output": merged,
                "n_tokens": len(gen.token_ids),
                "time_seconds": elapsed / max(len(problems), 1),
                "intervention": {"kind": "prompt_prefix_fp16_correct_only",
                                 "k": args.k,
                                 "had_prefix": bool(pref)},
            }, ensure_ascii=False) + "\n")

    print(f"Done: {len(problems)} problems ({n_with_prefix} with prefix) in {elapsed:.1f}s")


if __name__ == "__main__":
    main()