benchmark.py

#!/usr/bin/env python3

from __future__ import annotations

import argparse
import ast
import getpass
import json
import math
import os
import re
import sys
import time
import unicodedata
from collections import Counter, defaultdict
from datetime import datetime, timezone
from pathlib import Path
from typing import Any

import torch
from datasets import load_dataset
from huggingface_hub import HfApi, get_token, hf_hub_download
from huggingface_hub.errors import HfHubHTTPError
from transformers import AutoModelForCausalLM, AutoTokenizer


DATASET_ID = "ArrowLabs/ArrowBench-Instruct"
EXPECTED_CASES = 1000
EXPECTED_CATEGORIES = {
    "general": 350,
    "multi_turn": 250,
    "system_prompts": 200,
    "recall_in_context": 120,
    "code": 80,
}
EXPECTED_DIFFICULTIES = {"easy": 200, "medium": 400, "hard": 400}
ELO_SCALE = 400.0
ELO_PRIOR_RATING = 1_000.0
ELO_PRIOR_WEIGHT = 4.0


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--model", required=True, help="Local model directory or Hugging Face model ID.")
    parser.add_argument("--out-dir", type=Path, default=Path("runs/bananamind-instruct-bench-1.2"))
    parser.add_argument("--dataset-id", default=DATASET_ID)
    parser.add_argument("--dataset-revision", default="main")
    parser.add_argument(
        "--hf-token",
        default=os.environ.get("HF_TOKEN"),
        help="Optional token. Omit this to use `hf auth login`; inaccessible tokens trigger a hidden CLI prompt.",
    )
    parser.add_argument("--device", default="auto", help="auto, cpu, cuda, cuda:0, etc.")
    parser.add_argument(
        "--dtype",
        choices=("auto", "float32", "bfloat16", "float16"),
        default="auto",
    )
    parser.add_argument("--threads", type=int, default=16)
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--repetition-penalty", type=float, default=1.1)
    parser.add_argument("--use-cache", action=argparse.BooleanOptionalAction, default=True)
    parser.add_argument("--trust-remote-code", action=argparse.BooleanOptionalAction, default=True)
    parser.add_argument("--resume", action="store_true")
    parser.add_argument(
        "--limit",
        type=int,
        default=None,
        help="Developer smoke-test limit. A limited run is explicitly marked non-official.",
    )
    return parser.parse_args()


def access_error(error: BaseException) -> bool:
    if not isinstance(error, HfHubHTTPError):
        return False
    response = getattr(error, "response", None)
    return response is not None and response.status_code in {401, 403, 404}


def token_has_dataset_access(token: str | None, dataset_id: str, revision: str) -> bool:
    if not token:
        return False
    try:
        HfApi().whoami(token=token)
        hf_hub_download(
            repo_id=dataset_id,
            filename="data/test.jsonl",
            repo_type="dataset",
            revision=revision,
            token=token,
        )
        return True
    except HfHubHTTPError as error:
        if access_error(error):
            return False
        raise RuntimeError(f"Could not contact Hugging Face while checking dataset access: {error}") from error


def resolve_hf_token(args: argparse.Namespace) -> str:
    candidates: list[tuple[str, str | None]] = [
        ("--hf-token/HF_TOKEN", args.hf_token),
        ("saved Hugging Face login", get_token()),
    ]
    seen: set[str] = set()
    for source, candidate in candidates:
        if not candidate or candidate in seen:
            continue
        seen.add(candidate)
        print(f"Checking {source} access to {args.dataset_id}...", flush=True)
        if token_has_dataset_access(candidate, args.dataset_id, args.dataset_revision):
            print("Dataset access confirmed.", flush=True)
            return candidate
        print(f"The {source} token cannot access the gated dataset.", flush=True)

    for attempt in range(1, 4):
        try:
            candidate = getpass.getpass(
                f"Hugging Face token with access to {args.dataset_id} (attempt {attempt}/3): "
            ).strip()
        except (EOFError, KeyboardInterrupt) as error:
            raise RuntimeError(
                "A Hugging Face token is required. Run `hf auth login` or pass --hf-token."
            ) from error
        if not candidate:
            continue
        if token_has_dataset_access(candidate, args.dataset_id, args.dataset_revision):
            print("Dataset access confirmed. The prompted token is used only for this process.", flush=True)
            return candidate
        print("That token does not have access to the gated dataset.", flush=True)
    raise RuntimeError(
        f"No token with access to {args.dataset_id} was provided. Accept the dataset gate first."
    )


def normalize_messages(value: Any) -> list[dict[str, str]]:
    if isinstance(value, dict) and set(value) >= {"role", "content"}:
        value = [dict(role=role, content=content) for role, content in zip(value["role"], value["content"])]
    messages = [{"role": str(item["role"]), "content": str(item["content"])} for item in value]
    if not messages or messages[-1]["role"] != "user":
        raise ValueError("Every benchmark record must end with a user message")
    return messages


def load_suite(args: argparse.Namespace, token: str) -> list[dict[str, Any]]:
    dataset = load_dataset(
        args.dataset_id,
        split="test",
        revision=args.dataset_revision,
        token=token,
    )
    records: list[dict[str, Any]] = []
    for index, raw in enumerate(dataset, 1):
        record = dict(raw)
        if "id" not in record:
            record["id"] = f"{record.get('category', 'item')}-{index:04d}"
        if "version" not in record:
            record["version"] = "1.2"
        record["messages"] = normalize_messages(record["messages"])
        record["evaluator"] = json.loads(record.pop("evaluator_json"))
        records.append(record)
    validate_suite(records, require_complete=True)
    return records[: args.limit] if args.limit is not None else records


def validate_suite(records: list[dict[str, Any]], *, require_complete: bool) -> None:
    required = {
        "category", "difficulty", "category_weight",
        "difficulty_weight", "item_elo", "messages", "evaluator",
        "max_new_tokens", "tags",
    }
    ids: set[str] = set()
    for record in records:
        missing = required - set(record)
        if missing:
            raise ValueError(f"{record.get('id', '<unknown>')} is missing fields: {sorted(missing)}")
        if record["id"] in ids:
            raise ValueError(f"Duplicate benchmark ID: {record['id']}")
        ids.add(record["id"])
        normalize_messages(record["messages"])
        if record["difficulty"] not in EXPECTED_DIFFICULTIES:
            raise ValueError(f"Unknown difficulty in {record['id']}: {record['difficulty']}")
    if not require_complete:
        return
    categories = Counter(record["category"] for record in records)
    difficulties = Counter(record["difficulty"] for record in records)
    if len(records) != EXPECTED_CASES:
        raise ValueError(f"Expected {EXPECTED_CASES} dataset cases, found {len(records)}")
    if dict(categories) != EXPECTED_CATEGORIES:
        raise ValueError(f"Category counts differ: {dict(categories)} != {EXPECTED_CATEGORIES}")
    if dict(difficulties) != EXPECTED_DIFFICULTIES:
        raise ValueError(f"Difficulty counts differ: {dict(difficulties)} != {EXPECTED_DIFFICULTIES}")


def folded(text: str) -> str:
    value = unicodedata.normalize("NFKD", text)
    value = "".join(char for char in value if not unicodedata.combining(char))
    return " ".join(value.strip().split())


def loose_exact(text: str) -> str:
    return folded(text).strip(" \t\r\n.!`'\"").casefold()


def extract_code(text: str) -> str:
    match = re.search(r"```(?:python)?\s*\n?(.*?)```", text, flags=re.I | re.S)
    return match.group(1).strip() if match else text.strip()


def evaluate(text: str, spec: dict[str, Any]) -> tuple[bool, dict[str, Any]]:
    kind = spec["type"]
    if kind == "exact":
        actual = loose_exact(text)
        expected = loose_exact(str(spec["value"]))
        return actual == expected, {"actual": actual, "expected": expected}
    if kind in {"contains_any", "contains_all", "not_contains"}:
        actual = folded(text).casefold()
        found = {value: folded(str(value)).casefold() in actual for value in spec["values"]}
        passed = any(found.values()) if kind == "contains_any" else all(found.values())
        if kind == "not_contains":
            passed = not any(found.values())
        return passed, {"found": found}
    if kind == "number":
        matches = re.findall(r"(?<![\w.])-?\d+(?:\.\d+)?", text.replace(",", ""))
        actual = float(matches[-1]) if matches else None
        expected = float(spec["value"])
        passed = actual is not None and math.isclose(actual, expected, rel_tol=0.0, abs_tol=1e-9)
        return passed, {"last_number": actual, "expected": expected}
    if kind == "regex":
        matched = [bool(re.search(pattern, text, flags=re.I | re.S)) for pattern in spec["patterns"]]
        passed = all(matched) if spec.get("mode", "any") == "all" else any(matched)
        return passed, {"matched": matched, "patterns": spec["patterns"]}
    if kind == "json_exact":
        candidate = text.strip()
        if candidate.startswith("```"):
            candidate = re.sub(r"^```(?:json)?\s*|\s*```$", "", candidate, flags=re.I)
        try:
            parsed = json.loads(candidate)
        except json.JSONDecodeError as error:
            return False, {"json_error": str(error)}
        return parsed == spec["value"], {"parsed": parsed, "expected": spec["value"]}
    if kind == "sentence_count":
        sentences = [part for part in re.split(r"[.!?]+(?:\s+|$)", text.strip()) if part.strip()]
        return len(sentences) == spec["count"], {"sentence_count": len(sentences), "expected": spec["count"]}
    if kind == "word_count":
        words = re.findall(r"\b[\w'-]+\b", text, flags=re.UNICODE)
        return len(words) == spec["count"], {"word_count": len(words), "expected": spec["count"]}
    if kind == "bullet_count":
        bullets = re.findall(r"(?m)^\s*(?:[-*]|\d+[.)])\s+", text)
        required = {term: folded(term).casefold() in folded(text).casefold() for term in spec.get("required", [])}
        passed = len(bullets) == spec["count"] and all(required.values())
        return passed, {"bullet_count": len(bullets), "expected": spec["count"], "required": required}
    if kind == "lines_exact":
        lines = [loose_exact(line) for line in text.splitlines() if line.strip()]
        expected = [loose_exact(line) for line in spec["values"]]
        return lines == expected, {"lines": lines, "expected": expected}
    if kind == "code":
        code = extract_code(text)
        try:
            ast.parse(code)
            syntax_valid, syntax_error = True, None
        except SyntaxError as error:
            syntax_valid, syntax_error = False, str(error)
        matched = [bool(re.search(pattern, code, flags=re.I | re.S)) for pattern in spec["patterns"]]
        patterns_pass = all(matched) if spec.get("mode", "any") == "all" else any(matched)
        return syntax_valid and patterns_pass, {
            "code": code,
            "syntax_valid": syntax_valid,
            "syntax_error": syntax_error,
            "matched": matched,
            "patterns": spec["patterns"],
        }
    if kind in {"all", "any"}:
        outcomes = [evaluate(text, child) for child in spec["evaluators"]]
        flags = [outcome[0] for outcome in outcomes]
        passed = all(flags) if kind == "all" else any(flags)
        return passed, {"subtests": [details | {"passed": flag} for flag, details in outcomes]}
    raise ValueError(f"Unsupported evaluator type: {kind}")


class ModelRunner:
    def __init__(self, args: argparse.Namespace, token: str):
        self.args = args
        if args.device == "auto":
            args.device = "cuda" if torch.cuda.is_available() else "cpu"
        self.device = torch.device(args.device)
        torch.manual_seed(args.seed)
        torch.set_num_threads(args.threads)
        torch.set_float32_matmul_precision("high")
        if args.dtype == "auto":
            dtype = torch.bfloat16 if self.device.type == "cuda" and torch.cuda.is_bf16_supported() else torch.float32
        else:
            dtype = {
                "float32": torch.float32,
                "bfloat16": torch.bfloat16,
                "float16": torch.float16,
            }[args.dtype]
        local = Path(args.model).is_dir()
        common = {
            "trust_remote_code": args.trust_remote_code,
            "local_files_only": local,
            "token": None if local else token,
        }
        print(f"Loading {args.model} on {self.device} as {dtype}...", flush=True)
        self.tokenizer = AutoTokenizer.from_pretrained(args.model, **common)
        self.model = AutoModelForCausalLM.from_pretrained(args.model, dtype=dtype, **common).to(self.device).eval()
        self.prompt_format = "native_chat_template" if self.tokenizer.chat_template else "alpaca_instruction_fallback"
        context_candidates = [
            getattr(self.model.config, "max_position_embeddings", None),
            getattr(self.model.config, "n_positions", None),
        ]
        self.context_length = next((int(value) for value in context_candidates if value), 4096)

    def encode(self, messages: list[dict[str, str]]) -> dict[str, torch.Tensor]:
        if self.tokenizer.chat_template:
            encoded = self.tokenizer.apply_chat_template(
                messages,
                add_generation_prompt=True,
                return_tensors="pt",
                return_dict=True,
            )
        else:
            instruction = messages[-1]["content"]
            prior = "\n".join(f"{message['role'].capitalize()}: {message['content']}" for message in messages[:-1])
            prompt = "Below is an instruction that describes a task"
            if prior:
                prompt += ", paired with an input that provides further context"
            prompt += ". Write a response that appropriately completes the request.\n\n"
            prompt += f"### Instruction:\n{instruction}\n\n"
            if prior:
                prompt += f"### Input:\n{prior}\n\n"
            prompt += "### Response:\n"
            encoded = self.tokenizer(prompt, return_tensors="pt")
        return {name: tensor.to(self.device) for name, tensor in encoded.items()}

    @torch.inference_mode()
    def run(self, record: dict[str, Any]) -> dict[str, Any]:
        started = time.monotonic()
        inputs = self.encode(record["messages"])
        input_tokens = int(inputs["input_ids"].shape[1])
        available = self.context_length - input_tokens
        if available <= 0:
            return {
                "text": "",
                "input_tokens": input_tokens,
                "generated_tokens": 0,
                "natural_eos": False,
                "hit_limit": False,
                "context_overflow": True,
                "elapsed_seconds": time.monotonic() - started,
            }
        limit = min(int(record["max_new_tokens"]), available)
        output = self.model.generate(
            **inputs,
            max_new_tokens=limit,
            do_sample=False,
            repetition_penalty=self.args.repetition_penalty,
            pad_token_id=self.tokenizer.eos_token_id,
            eos_token_id=self.tokenizer.eos_token_id,
            use_cache=self.args.use_cache,
        )
        generated_ids = output[0, input_tokens:]
        ended = bool(generated_ids.numel() and generated_ids[-1].item() == self.tokenizer.eos_token_id)
        return {
            "text": self.tokenizer.decode(generated_ids, skip_special_tokens=True).strip(),
            "input_tokens": input_tokens,
            "generated_tokens": int(generated_ids.numel()),
            "natural_eos": ended,
            "hit_limit": int(generated_ids.numel()) == limit and not ended,
            "context_overflow": False,
            "elapsed_seconds": time.monotonic() - started,
        }


def expected_score(model_elo: float, item_elo: float) -> float:
    return 1.0 / (1.0 + 10.0 ** ((item_elo - model_elo) / ELO_SCALE))


def estimate_elo(results: list[dict[str, Any]]) -> float:
    if not results:
        return ELO_PRIOR_RATING

    def residual(rating: float) -> float:
        prior = ELO_PRIOR_WEIGHT * (0.5 - expected_score(rating, ELO_PRIOR_RATING))
        games = sum(
            result["point_weight"]
            * ((1.0 if result["passed"] else 0.0) - expected_score(rating, result["item_elo"]))
            for result in results
        )
        return prior + games

    low, high = 0.0, 3_000.0
    for _ in range(80):
        middle = (low + high) / 2.0
        if residual(middle) > 0:
            low = middle
        else:
            high = middle
    return (low + high) / 2.0


def summarize_group(results: list[dict[str, Any]]) -> dict[str, Any]:
    passed = sum(bool(result["passed"]) for result in results)
    possible = sum(result["point_weight"] for result in results)
    earned = sum(result["earned_points"] for result in results)
    return {
        "cases": len(results),
        "passed": passed,
        "pass_rate": passed / len(results) if results else 0.0,
        "weighted_points": earned,
        "possible_weighted_points": possible,
        "weighted_score": earned / possible if possible else 0.0,
        "elo": round(estimate_elo(results)),
        "elo_unrounded": estimate_elo(results),
    }


def summarize(results: list[dict[str, Any]], *, official: bool) -> dict[str, Any]:
    categories: dict[str, list[dict[str, Any]]] = defaultdict(list)
    difficulties: dict[str, list[dict[str, Any]]] = defaultdict(list)
    for result in results:
        categories[result["category"]].append(result)
        difficulties[result["difficulty"]].append(result)
    summary = summarize_group(results)
    summary.update(
        {
            "official_complete_run": official,
            "overall_elo": summary.pop("elo"),
            "overall_elo_unrounded": summary.pop("elo_unrounded"),
            "categories": {name: summarize_group(items) for name, items in categories.items()},
            "difficulties": {name: summarize_group(items) for name, items in difficulties.items()},
            "natural_eos_count": sum(bool(result["natural_eos"]) for result in results),
            "generation_limit_hits": sum(bool(result["hit_limit"]) for result in results),
            "context_overflows": sum(bool(result["context_overflow"]) for result in results),
        }
    )
    return summary


def read_partial(path: Path) -> dict[str, dict[str, Any]]:
    if not path.exists():
        return {}
    results: dict[str, dict[str, Any]] = {}
    with path.open(encoding="utf-8") as handle:
        for line in handle:
            if line.strip():
                result = json.loads(line)
                results[result["id"]] = result
    return results


def write_outputs(
    args: argparse.Namespace,
    runner: ModelRunner,
    results: list[dict[str, Any]],
    *,
    official: bool,
) -> tuple[Path, Path]:
    summary = summarize(results, official=official)
    report = {
        "created_at": datetime.now(timezone.utc).isoformat(),
        "benchmark": "BananaMind Instruct Bench 1.2",
        "dataset_id": args.dataset_id,
        "dataset_revision": args.dataset_revision,
        "model": args.model,
        "device": str(runner.device),
        "prompt_format": runner.prompt_format,
        "generation_settings": {
            "do_sample": False,
            "repetition_penalty": args.repetition_penalty,
            "use_cache": args.use_cache,
            "seed": args.seed,
        },
        "elo": {
            "scale": ELO_SCALE,
            "prior_rating": ELO_PRIOR_RATING,
            "prior_weight": ELO_PRIOR_WEIGHT,
            "method": "weighted fixed-item logistic maximum-likelihood rating",
        },
        "summary": summary,
        "results": results,
    }
    report_path = args.out_dir / "report.json"
    report_path.write_text(json.dumps(report, indent=2, ensure_ascii=True) + "\n")

    lines = [
        "# BananaMind Instruct Bench 1.2",
        "",
        f"**Model:** {args.model}",
        f"**Overall Elo:** {summary['overall_elo']}",
        f"**Raw pass rate:** {summary['passed']}/{summary['cases']} ({summary['pass_rate']:.2%})",
        f"**Weighted score:** {summary['weighted_score']:.2%}",
        f"**Official complete run:** {'yes' if official else 'no'}",
        "",
    ]
    for index, result in enumerate(results, 1):
        lines.extend(
            [
                f"## {index:04d}. {result['id']}",
                "",
                f"**Result:** {'PASS' if result['passed'] else 'FAIL'} | "
                f"**Difficulty:** {result['difficulty']} | **Item Elo:** {result['item_elo']}",
                "",
                "**Assistant:**",
                "",
                result["text"],
                "",
            ]
        )
    transcript_path = args.out_dir / "transcript.md"
    transcript_path.write_text("\n".join(lines))
    return report_path, transcript_path


def main() -> None:
    args = parse_args()
    if args.limit is not None and not 1 <= args.limit <= EXPECTED_CASES:
        raise ValueError(f"--limit must be between 1 and {EXPECTED_CASES}")
    args.out_dir.mkdir(parents=True, exist_ok=True)
    partial_path = args.out_dir / "partial_results.jsonl"
    if partial_path.exists() and not args.resume:
        partial_path.unlink()

    token = resolve_hf_token(args)
    records = load_suite(args, token)
    runner = ModelRunner(args, token)
    completed = read_partial(partial_path) if args.resume else {}
    expected_ids = {record["id"] for record in records}
    completed = {key: value for key, value in completed.items() if key in expected_ids}

    with partial_path.open("a", encoding="utf-8") as partial:
        for index, record in enumerate(records, 1):
            if record["id"] in completed:
                print(f"[{index:04d}/{len(records):04d}] RESUME {record['id']}", flush=True)
                continue
            generation = runner.run(record)
            if generation["context_overflow"]:
                passed, evaluation = False, {"error": "input exceeds model context length"}
            else:
                passed, evaluation = evaluate(generation["text"], record["evaluator"])
            point_weight = float(record["category_weight"]) * float(record["difficulty_weight"])
            result = {
                "id": record["id"],
                "category": record["category"],
                "difficulty": record["difficulty"],
                "category_weight": float(record["category_weight"]),
                "difficulty_weight": float(record["difficulty_weight"]),
                "point_weight": point_weight,
                "earned_points": point_weight if passed else 0.0,
                "item_elo": int(record["item_elo"]),
                "messages": record["messages"],
                **generation,
                "passed": passed,
                "evaluation": evaluation,
            }
            completed[record["id"]] = result
            partial.write(json.dumps(result, ensure_ascii=True) + "\n")
            partial.flush()
            print(
                f"[{index:04d}/{len(records):04d}] {'PASS' if passed else 'FAIL'} "
                f"{record['id']} ({record['difficulty']}, Elo {record['item_elo']})",
                flush=True,
            )

    ordered_results = [completed[record["id"]] for record in records]
    official = len(records) == EXPECTED_CASES and len(ordered_results) == EXPECTED_CASES
    report_path, transcript_path = write_outputs(args, runner, ordered_results, official=official)
    summary = summarize(ordered_results, official=official)

    print("\nBananaMind Instruct Bench 1.2")
    print(f"Overall Elo: {summary['overall_elo']}")
    print(f"Raw: {summary['passed']}/{summary['cases']} ({summary['pass_rate']:.2%})")
    print(f"Weighted score: {summary['weighted_score']:.2%}")
    for category in EXPECTED_CATEGORIES:
        group = summary["categories"].get(category)
        if group:
            print(
                f"{category}: Elo {group['elo']} | {group['passed']}/{group['cases']} "
                f"({group['pass_rate']:.2%}) | weighted {group['weighted_score']:.2%}"
            )
    if not official:
        print(f"NON-OFFICIAL: this was not a complete {EXPECTED_CASES}-case run.")
    print(f"Report: {report_path}")
    print(f"Transcript: {transcript_path}")


if __name__ == "__main__":
    try:
        main()
    except KeyboardInterrupt:
        print("\nInterrupted. Re-run with --resume to continue.", file=sys.stderr)
        raise SystemExit(130)