scripts/run_eval.py

"""Evaluate Dream-7B-Instruct with baseline / CCD / CCD-DS on Trip Plan or HumanEval.

Hyperparameters follow the Dream authors' official eval scripts, which is what the
paper says it does ("we follow the base models' default settings without tuning"):

  Trip Plan  : steps=256,  max_new_tokens=256,  temperature=0,   top_p=1,   alg=entropy
               (DreamLM/Dream eval/eval_dream_gen_planning.sh)  -- 2-shot prompt
  HumanEval  : steps=768,  max_new_tokens=768,  temperature=0.1, top_p=0.9, alg=entropy
               (DreamLM/Dream eval_instruct/eval.sh)            -- 0-shot, chat template

Usage:
  python run_eval.py --task trip --method ccd_ds --limit 100 --out outputs/x.json
"""
import argparse, json, os, random, sys, time
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

import numpy as np
import torch
from transformers import AutoModel, AutoTokenizer

import ccd_decode
from trip_metric import parse_response, compute_example_score
from sanitize_utils import sanitize

MODEL = "Dream-org/Dream-v0-Instruct-7B"
HERE = os.path.dirname(os.path.abspath(__file__))
DATA = os.path.join(HERE, "..", "data")

TASK_DEFAULTS = {
    "trip":      dict(steps=256, max_new_tokens=256, temperature=0.0, top_p=1.0),
    "humaneval": dict(steps=768, max_new_tokens=768, temperature=0.1, top_p=0.9),
}


# ---------------------------------------------------------------- data / prompts

def load_trip(limit=None, num_cities=None, seed=0):
    """Load Trip Plan examples.

    IMPORTANT: the benchmark file is ordered by difficulty -- the first 200 of the
    1600 examples all have num_cities=3 (the easiest tier), then 200 with 4, etc.
    Taking a prefix therefore samples ONLY the easiest tier and inflates the score
    (measured: 55% on a prefix-60 vs the paper's 15.10% over the full set).
    When no explicit tier is requested we take a *stratified* sample: equal numbers
    from each num_cities tier, so the subset matches the full benchmark's mix.
    """
    with open(os.path.join(DATA, "trip_planning.json")) as f:
        data = json.load(f)
    items = list(data.values())
    if num_cities is not None:
        # single-tier request (e.g. the Claim 5 City=3 ablation): prefix is fine,
        # every example in the tier is equivalent for sampling purposes
        items = [i for i in items if i["num_cities"] == str(num_cities)]
        if limit:
            items = items[:limit]
    elif limit:
        tiers = sorted({i["num_cities"] for i in items}, key=int)
        per = limit // len(tiers)
        rng = random.Random(seed)
        picked = []
        for t in tiers:
            pool = [i for i in items if i["num_cities"] == t]
            picked.extend(rng.sample(pool, min(per, len(pool))))
        # top up any remainder deterministically from the unpicked pool
        if len(picked) < limit:
            rest = [i for i in items if i not in picked]
            picked.extend(rng.sample(rest, limit - len(picked)))
        items = picked
    # 2-shot prompt, exactly as DreamLM/Dream eval_planning.py::eval_trip
    prompts = []
    for i in items:
        splits = i["prompt_5shot"].split("TASK:")
        prompts.append("TASK:".join(splits[:3] + [splits[-1]]))
    return items, prompts


def load_humaneval(limit=None, offset=0):
    """HumanEval problems [offset, offset+limit).

    The offset lets us EXTEND an existing run instead of repeating it: having
    already scored problems 0..31, we buy problems 32..63 and merge to n=64 for
    the price of the increment rather than re-running the whole prefix.
    """
    from datasets import load_dataset
    ds = load_dataset("openai/openai_humaneval", split="test")
    items = list(ds)[offset:]
    if limit:
        items = items[:limit]
    return items


def humaneval_prompt(tok, doc):
    """lm_eval humaneval_instruct: user doc_to_text + assistant gen_prefix, continued."""
    user = ("Write a solution to the following problem and make sure that it "
            "passes the tests:\n```" + doc["prompt"])
    prefix = "Here is the completed function:\n```python\n" + doc["prompt"] + "\n"
    chat = [{"role": "user", "content": user},
            {"role": "assistant", "content": prefix}]
    return tok.apply_chat_template(chat, tokenize=False,
                                   add_generation_prompt=False,
                                   continue_final_message=True)


# ---------------------------------------------------------------- scoring

def score_trip(items, responses):
    scores = []
    for item, r in zip(items, responses):
        r = r.split("<|endoftext|>")[0].split("\n\nTASK")[0]
        scores.append(compute_example_score(item["cities"], item["durations"],
                                            parse_response(r)))
    return 100.0 * sum(scores) / len(scores), scores


def score_humaneval(items, responses):
    """pass@1 via subprocess exec, mirroring lm_eval's code_eval + build_predictions_instruct."""
    import subprocess, tempfile
    scores = []
    for doc, r in zip(items, responses):
        for stop in ["\nclass", "\ndef", "\n#", "\nif", "\nprint"]:
            r = r.split(stop)[0]
        body = r.split("```python\n", 1)[-1].split("```")[0]
        code = sanitize(doc["prompt"] + "\n" + body, doc["entry_point"])
        program = code + "\n" + doc["test"] + "\n" + f"check({doc['entry_point']})\n"
        with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
            f.write(program); path = f.name
        try:
            p = subprocess.run([sys.executable, path], capture_output=True, timeout=15)
            scores.append(1.0 if p.returncode == 0 else 0.0)
        except subprocess.TimeoutExpired:
            scores.append(0.0)
        finally:
            os.unlink(path)
    return 100.0 * sum(scores) / len(scores), scores


# ---------------------------------------------------------------- main

class _NoMaskLogits(torch.nn.Module):
    """Dry-run only: forbid emitting <|mask|> as a clean-data prediction.

    A trained Dream never does; a randomly initialised tiny model does, which
    re-masks positions and hides real bugs behind noise.
    """
    def __init__(self, inner, mask_id):
        super().__init__()
        self.inner, self.mask_id = inner, mask_id
        self.config = inner.config

    def forward(self, *a, **kw):
        out = self.inner(*a, **kw)
        out.logits[..., self.mask_id] = -1e4
        return out


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--task", choices=["trip", "humaneval"], required=True)
    ap.add_argument("--method", choices=["baseline", "ccd", "ccd_ds"], required=True)
    ap.add_argument("--limit", type=int, default=None)
    ap.add_argument("--offset", type=int, default=0,
                    help="skip the first N problems (HumanEval; lets a run extend an earlier one)")
    ap.add_argument("--num-cities", type=int, default=None)
    ap.add_argument("--buffer-V", type=int, default=4)
    ap.add_argument("--history-d", type=int, default=3)
    ap.add_argument("--temperature", type=float, default=None)
    ap.add_argument("--top-p", type=float, default=None,
                    help="override top_p; 1.0 disables nucleus filtering")
    ap.add_argument("--steps", type=int, default=None)
    ap.add_argument("--out", required=True)
    ap.add_argument("--seed", type=int, default=0,
                    help="RNG seed for temperature sampling. Only bites when temperature>0: "
                         "at T=0 ccd_decode._pick_token takes the argmax, so those runs are "
                         "deterministic with or without it. Does NOT affect which examples are "
                         "evaluated -- load_trip's stratified sample is fixed at seed 0 so every "
                         "arm scores the same examples.")
    ap.add_argument("--tiny", action="store_true",
                    help="local CPU dry-run with tiny random weights")
    args = ap.parse_args()

    # Seed every RNG that can touch decoding. NOTE: the temperature-sweep results
    # shipped in outputs/ (c6_*_t0.1/0.4/0.7/1.0) were produced BEFORE this was
    # added and therefore do not reproduce bit-exactly from this seed; the T=0
    # runs (Trip Plan, HumanEval, the ablations) are argmax and always did.
    random.seed(args.seed)
    np.random.seed(args.seed)
    torch.manual_seed(args.seed)
    torch.cuda.manual_seed_all(args.seed)

    cfg = dict(TASK_DEFAULTS[args.task])
    if args.temperature is not None:
        cfg["temperature"] = args.temperature
    if args.top_p is not None:
        cfg["top_p"] = args.top_p
    if args.steps is not None:
        cfg["steps"] = args.steps; cfg["max_new_tokens"] = args.steps

    print(f"[cfg] task={args.task} method={args.method} V={args.buffer_V} d={args.history_d} "
          f"seed={args.seed} {cfg}", flush=True)

    tok = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)
    if args.tiny:
        # Local CPU dry-run: real tokenizer/prompts/metrics, tiny random weights.
        # Exercises the whole pipeline end-to-end so no GPU minute is spent on a crash.
        from transformers import AutoConfig
        cfg_m = AutoConfig.from_pretrained(MODEL, trust_remote_code=True)
        cfg_m.num_hidden_layers, cfg_m.hidden_size = 2, 128
        cfg_m.intermediate_size, cfg_m.num_attention_heads = 256, 4
        cfg_m.num_key_value_heads, cfg_m.tie_word_embeddings = 2, True
        model = AutoModel.from_config(cfg_m, trust_remote_code=True).eval()
        model = _NoMaskLogits(model, cfg_m.mask_token_id)
        device = "cpu"
    else:
        model = AutoModel.from_pretrained(MODEL, torch_dtype=torch.bfloat16,
                                          trust_remote_code=True).to("cuda").eval()
        device = "cuda"
    mask_id = model.config.mask_token_id

    if args.task == "trip":
        items, prompts = load_trip(args.limit, args.num_cities)
    else:
        items = load_humaneval(args.limit, args.offset)
        prompts = [humaneval_prompt(tok, d) for d in items]

    responses, all_steps, all_budgets, n_fallback = [], [], [], 0
    all_ic, all_stable = [], []
    t0 = time.time()
    for n, prompt in enumerate(prompts):
        enc = tok(prompt, return_tensors="pt")
        input_ids = enc.input_ids.to(device)
        attn = enc.attention_mask.to(device)
        x, st = ccd_decode.generate(
            model, input_ids, attention_mask=attn,
            max_new_tokens=cfg["max_new_tokens"], steps=cfg["steps"],
            temperature=cfg["temperature"], top_p=cfg["top_p"],
            mask_token_id=mask_id, method=args.method,
            buffer_V=args.buffer_V, history_d=args.history_d,
        )
        gen = x[0, input_ids.shape[1]:]
        text = tok.decode(gen.tolist()).split(tok.eos_token)[0]
        responses.append(text)
        all_steps.append(st["steps"])
        all_budgets.append(st["budgets"])
        all_ic.append(st["ic_sizes"])
        all_stable.append(st["n_stable"])
        n_fallback += st["fallbacks"]
        if n == 0:
            print(f"--- example 0 response ---\n{text[:600]}\n---", flush=True)
        if (n + 1) % 10 == 0:
            el = time.time() - t0
            print(f"[{n+1}/{len(prompts)}] mean_steps={sum(all_steps)/len(all_steps):.2f} "
                  f"elapsed={el/60:.1f}min eta={el/(n+1)*(len(prompts)-n-1)/60:.1f}min", flush=True)

    if args.task == "trip":
        score, per_ex = score_trip(items, responses)
    else:
        score, per_ex = score_humaneval(items, responses)

    mean_steps = sum(all_steps) / len(all_steps)
    result = {
        "task": args.task, "method": args.method, "config": cfg,
        "buffer_V": args.buffer_V, "history_d": args.history_d,
        "n_examples": len(items), "score": score, "offset": args.offset, "seed": args.seed,
        "mean_steps": mean_steps,
        "speedup_vs_uniform": cfg["steps"] / mean_steps,
        "fallback_steps": n_fallback,
        "wall_clock_s": time.time() - t0,
        "per_example_score": per_ex, "per_example_steps": all_steps,
        "responses": responses,
        "budgets": all_budgets,
        "ic_sizes": all_ic, "n_stable": all_stable,
    }
    os.makedirs(os.path.dirname(args.out) or ".", exist_ok=True)
    with open(args.out, "w") as f:
        json.dump(result, f, indent=1)

    print(f"\n=== RESULT {args.task}/{args.method} V={args.buffer_V} d={args.history_d} ===")
    print(f"score={score:.2f}  mean_steps={mean_steps:.2f}  "
          f"speedup={cfg['steps']/mean_steps:.2f}x  n={len(items)}  "
          f"fallback_steps={n_fallback}  wall={result['wall_clock_s']/60:.1f}min")


if __name__ == "__main__":
    main()