Upload 2 files

benchmark.py

@@ -0,0 +1,592 @@
+#!/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)