eval_local.py

#!/usr/bin/env python3
"""Local holdout eval: teacher-forced loss on reference assistant turns.

This is not the on-chain 100-sample duel. It answers: did the adapter get
closer to the SOTA reference on samples neither king nor challenger solved?

Compare king-only vs SFT vs DPO. Submit only if holdout NLL drops a lot
(recipe: treat < 5% relative drop as noise).

Usage:
  python eval_local.py --model models/king118 --data datasets/mix/holdout_sft.jsonl \\
      --out runs/eval-king.json
  python eval_local.py --model models/king118 --adapter runs/sft-on-king118 \\
      --data datasets/mix/holdout_sft.jsonl --out runs/eval-sft.json --compare runs/eval-king.json
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer


def load_jsonl(path: Path) -> list[dict]:
    return [json.loads(line) for line in path.read_text().splitlines() if line.strip()]


def load_model(model_path: str, adapter: str | None, attn: str):
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True, use_fast=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        trust_remote_code=True,
        torch_dtype=torch.bfloat16,
        device_map="auto",
        attn_implementation=attn,
    )
    if adapter:
        from peft import PeftModel

        model = PeftModel.from_pretrained(model, adapter)
        print(f"loaded adapter {adapter}")
    model.eval()
    return model, tokenizer


def assistant_spans(tokenizer, messages: list[dict], max_len: int) -> tuple[torch.Tensor, list[tuple[int, int]]]:
    """Tokenize the full chat and return (input_ids, assistant token ranges)."""
    ids = tokenizer.apply_chat_template(
        messages, tokenize=True, add_generation_prompt=False, return_tensors="pt"
    )[0]
    if ids.numel() > max_len:
        ids = ids[-max_len:]
    # rebuild spans by growing the conversation
    spans: list[tuple[int, int]] = []
    prefix: list[dict] = []
    prev_len = 0
    for message in messages:
        prefix.append(message)
        cur = tokenizer.apply_chat_template(
            prefix, tokenize=True, add_generation_prompt=False
        )
        cur_len = len(cur)
        if message.get("role") == "assistant":
            start = prev_len
            end = cur_len
            # map through left-truncate
            full_len = cur_len
            shift = max(0, full_len - max_len)
            start = max(0, start - shift)
            end = max(0, end - shift)
            if end > start:
                spans.append((start, min(end, ids.numel())))
        prev_len = cur_len
    return ids, spans


@torch.no_grad()
def score_row(model, tokenizer, messages: list[dict], max_len: int) -> dict:
    ids, spans = assistant_spans(tokenizer, messages, max_len)
    if not spans:
        return {"nll": None, "tokens": 0, "correct": 0}
    device = next(model.parameters()).device
    x = ids.unsqueeze(0).to(device)
    logits = model(input_ids=x).logits[0, :-1]
    target = ids[1:].to(device)
    logp = torch.log_softmax(logits, dim=-1)
    nll_sum = 0.0
    tokens = 0
    correct = 0
    for start, end in spans:
        # labels are next-token, so supervise ids[start+1:end]
        a = max(start, 0)
        b = min(end, target.numel() + 1)
        lo = max(a - 1, 0)
        hi = min(b - 1, target.numel())
        if hi <= lo:
            continue
        tok_nll = -logp[lo:hi].gather(1, target[lo:hi].unsqueeze(1)).squeeze(1)
        pred = logp[lo:hi].argmax(dim=-1)
        nll_sum += float(tok_nll.sum().item())
        tokens += hi - lo
        correct += int((pred == target[lo:hi]).sum().item())
    return {
        "nll": (nll_sum / tokens) if tokens else None,
        "tokens": tokens,
        "correct": correct,
    }


def main() -> int:
    parser = argparse.ArgumentParser(description="Teacher-forced holdout eval against the reference.")
    parser.add_argument("--model", required=True, help="king / base model directory")
    parser.add_argument("--adapter", help="optional LoRA adapter directory")
    parser.add_argument("--data", type=Path, default=Path("datasets/mix/holdout_sft.jsonl"))
    parser.add_argument("--out", type=Path, required=True)
    parser.add_argument("--compare", type=Path, help="previous eval json to diff against")
    parser.add_argument("--max-seq-len", type=int, default=8192)
    parser.add_argument("--limit", type=int, default=0, help="score only the first N rows (0 = all)")
    parser.add_argument("--attn", default="sdpa")
    args = parser.parse_args()

    rows = load_jsonl(args.data)
    if args.limit:
        rows = rows[: args.limit]
    model, tokenizer = load_model(args.model, args.adapter, args.attn)

    per: list[dict] = []
    nll_num = 0.0
    nll_den = 0
    tok_ok = 0
    tok_n = 0
    by_phase: dict[str, list[float]] = {}
    for i, row in enumerate(rows, start=1):
        result = score_row(model, tokenizer, row["messages"], args.max_seq_len)
        rec = {
            "sample_id": row.get("sample_id"),
            "phase": row.get("phase"),
            "habits": row.get("habits"),
            **result,
        }
        per.append(rec)
        if result["nll"] is not None and result["tokens"]:
            nll_num += result["nll"] * result["tokens"]
            nll_den += result["tokens"]
            tok_ok += result["correct"]
            tok_n += result["tokens"]
            by_phase.setdefault(row.get("phase") or "unknown", []).append(result["nll"])
        print(
            f"[{i}/{len(rows)}] nll={result['nll']} tokens={result['tokens']} "
            f"phase={row.get('phase')} id={row.get('sample_id')}"
        )

    mean_nll = nll_num / nll_den if nll_den else None
    acc = tok_ok / tok_n if tok_n else None
    report = {
        "model": args.model,
        "adapter": args.adapter,
        "data": str(args.data),
        "rows": len(rows),
        "mean_nll": mean_nll,
        "token_accuracy": acc,
        "tokens": tok_n,
        "nll_by_phase": {k: sum(v) / len(v) for k, v in by_phase.items() if v},
        "per_sample": per,
    }
    if args.compare and args.compare.is_file():
        prev = json.loads(args.compare.read_text())
        old = prev.get("mean_nll")
        if old and mean_nll:
            rel = (old - mean_nll) / old
            report["baseline"] = {
                "path": str(args.compare),
                "mean_nll": old,
                "token_accuracy": prev.get("token_accuracy"),
            }
            report["relative_nll_drop"] = rel
            report["gate"] = (
                "pass"
                if rel >= 0.08
                else ("weak" if rel >= 0.05 else "fail")
            )
            print(
                f"\nvs {args.compare}: NLL {old:.4f} → {mean_nll:.4f}  "
                f"relative drop {rel*100:.1f}%  gate={report['gate']}"
            )
            print("gate: pass ≥8%  weak ≥5%  fail <5%  (submit only on pass)")

    args.out.parent.mkdir(parents=True, exist_ok=True)
    args.out.write_text(json.dumps(report, indent=2) + "\n")
    print(f"\nmean NLL {mean_nll}  token acc {acc}  tokens {tok_n}")
    print(f"wrote {args.out}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())