Create run_our_benchmark.py

run_our_benchmark.py

@@ -0,0 +1,690 @@
+#!/usr/bin/env python3
+import argparse
+import json
+import re
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import torch
+from datasets import load_dataset
+from tqdm import tqdm
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+
+LM_EVAL_TASKS = {
+    "hellaswag": {
+        "display": "HellaSwag",
+        "task": "hellaswag",
+        "preferred_metrics": ["acc_norm", "acc_norm,none", "acc"],
+    },
+    "arc": {
+        "display": "ARC-Easy",
+        "task": "arc_easy",
+        "preferred_metrics": ["acc_norm", "acc_norm,none", "acc"],
+    },
+    "arcChall": {
+        "display": "ARC-Challenge",
+        "task": "arc_challenge",
+        "preferred_metrics": ["acc_norm", "acc_norm,none", "acc"],
+    },
+    "piqa": {
+        "display": "PIQA",
+        "task": "piqa",
+        "preferred_metrics": ["acc_norm", "acc_norm,none", "acc", "acc,none"],
+    },
+}
+
+OUR_BENCHMARK_DATASET = "WhirlwindAI/Benchmark-TEST"
+
+
+def die(msg: str, code: int = 1) -> None:
+    print(f"[ERROR] {msg}", file=sys.stderr)
+    sys.exit(code)
+
+
+def run_cmd(cmd: List[str]) -> None:
+    print("\n[CMD]", " ".join(cmd), flush=True)
+    proc = subprocess.run(cmd)
+    if proc.returncode != 0:
+        die(f"Command failed with exit code {proc.returncode}")
+
+
+def find_latest_json(path: Path) -> Path:
+    if path.is_file():
+        return path
+
+    json_files = list(path.rglob("*.json"))
+    if not json_files:
+        die(f"No JSON result file found in {path}")
+
+    json_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    return json_files[0]
+
+
+def load_json(path: Path) -> Dict[str, Any]:
+    with path.open("r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+def metric_from_result(task_result: Dict[str, Any], preferred: List[str]) -> Tuple[str, float]:
+    for key in preferred:
+        if key in task_result and isinstance(task_result[key], (int, float)):
+            return key, float(task_result[key])
+
+    for key, value in task_result.items():
+        if "acc_norm" in key and isinstance(value, (int, float)):
+            return key, float(value)
+
+    for key, value in task_result.items():
+        if key.startswith("acc") and isinstance(value, (int, float)):
+            return key, float(value)
+
+    die(f"Could not find accuracy metric in result: {task_result}")
+
+
+def run_lm_eval(
+    model_id: str,
+    device: str,
+    dtype: str,
+    batch_size: str,
+    limit: Optional[int],
+    trust_remote_code: bool,
+) -> Dict[str, Dict[str, Any]]:
+    tasks = ",".join(info["task"] for info in LM_EVAL_TASKS.values())
+
+    model_args = [
+        f"pretrained={model_id}",
+        f"dtype={dtype}",
+    ]
+
+    if trust_remote_code:
+        model_args.append("trust_remote_code=True")
+
+    with tempfile.TemporaryDirectory(prefix="open_slm_lm_eval_") as tmp:
+        out_dir = Path(tmp)
+
+        cmd = [
+            sys.executable,
+            "-m",
+            "lm_eval",
+            "--model",
+            "hf",
+            "--model_args",
+            ",".join(model_args),
+            "--tasks",
+            tasks,
+            "--device",
+            device,
+            "--batch_size",
+            batch_size,
+            "--output_path",
+            str(out_dir),
+        ]
+
+        if limit is not None:
+            cmd.extend(["--limit", str(limit)])
+
+        run_cmd(cmd)
+
+        result_path = find_latest_json(out_dir)
+        raw = load_json(result_path)
+
+    if "results" not in raw:
+        die(f"Unexpected lm_eval JSON format. Top-level keys: {list(raw.keys())}")
+
+    return raw["results"]
+
+
+def normalize_percent(x: float) -> float:
+    if x <= 1.0:
+        return x * 100.0
+    return x
+
+
+def extract_lm_eval_scores(raw_results: Dict[str, Dict[str, Any]]) -> Dict[str, Dict[str, Any]]:
+    scores: Dict[str, Dict[str, Any]] = {}
+
+    for key, info in LM_EVAL_TASKS.items():
+        task_name = info["task"]
+
+        if task_name not in raw_results:
+            die(f"Task {task_name} not found in lm_eval results. Found: {list(raw_results.keys())}")
+
+        metric_name, value = metric_from_result(raw_results[task_name], info["preferred_metrics"])
+
+        scores[key] = {
+            "display": info["display"],
+            "task": task_name,
+            "metric": metric_name,
+            "score": normalize_percent(value),
+        }
+
+    return scores
+
+
+def count_params(model: torch.nn.Module) -> int:
+    return sum(p.numel() for p in model.parameters())
+
+
+def pick_first_present(ex: Dict[str, Any], names: List[str]) -> Optional[Any]:
+    for name in names:
+        if name in ex and ex[name] is not None:
+            return ex[name]
+    return None
+
+
+def normalize_choices(raw_choices: Any, ex: Dict[str, Any]) -> Optional[List[str]]:
+    if raw_choices is None:
+        letter_choices = []
+        for k in ["A", "B", "C", "D", "E"]:
+            if k in ex and ex[k] is not None:
+                letter_choices.append(str(ex[k]))
+        if len(letter_choices) >= 2:
+            return letter_choices
+
+        lower_choices = []
+        for k in ["choice_a", "choice_b", "choice_c", "choice_d", "choice_e"]:
+            if k in ex and ex[k] is not None:
+                lower_choices.append(str(ex[k]))
+        if len(lower_choices) >= 2:
+            return lower_choices
+
+        option_choices = []
+        for k in ["option_a", "option_b", "option_c", "option_d", "option_e"]:
+            if k in ex and ex[k] is not None:
+                option_choices.append(str(ex[k]))
+        if len(option_choices) >= 2:
+            return option_choices
+
+        return None
+
+    if isinstance(raw_choices, dict):
+        if "text" in raw_choices:
+            return [str(x) for x in raw_choices["text"]]
+        if "choices" in raw_choices:
+            return [str(x) for x in raw_choices["choices"]]
+        if "options" in raw_choices:
+            return [str(x) for x in raw_choices["options"]]
+
+        vals = []
+        for k in ["A", "B", "C", "D", "E"]:
+            if k in raw_choices:
+                vals.append(str(raw_choices[k]))
+        if len(vals) >= 2:
+            return vals
+
+    if isinstance(raw_choices, list):
+        return [str(x) for x in raw_choices]
+
+    return None
+
+
+def normalize_answer(raw_answer: Any, choices: List[str]) -> Optional[int]:
+    if raw_answer is None:
+        return None
+
+    if isinstance(raw_answer, bool):
+        return int(raw_answer)
+
+    if isinstance(raw_answer, int):
+        if 0 <= raw_answer < len(choices):
+            return raw_answer
+        if 1 <= raw_answer <= len(choices):
+            return raw_answer - 1
+
+    if isinstance(raw_answer, float) and raw_answer.is_integer():
+        return normalize_answer(int(raw_answer), choices)
+
+    ans = str(raw_answer).strip()
+
+    if len(ans) == 1 and ans.upper() in "ABCDE":
+        idx = ord(ans.upper()) - ord("A")
+        if 0 <= idx < len(choices):
+            return idx
+
+    if re.fullmatch(r"\d+", ans):
+        return normalize_answer(int(ans), choices)
+
+    for i, choice in enumerate(choices):
+        if ans == str(choice).strip():
+            return i
+
+    low = ans.lower()
+    for i, choice in enumerate(choices):
+        if low == str(choice).strip().lower():
+            return i
+
+    return None
+
+
+def build_our_benchmark_item(ex: Dict[str, Any]) -> Optional[Tuple[str, List[str], int]]:
+    prompt = pick_first_present(
+        ex,
+        [
+            "ctx",
+            "question",
+            "prompt",
+            "input",
+            "problem",
+            "query",
+            "text",
+            "instruction",
+        ],
+    )
+
+    raw_choices = pick_first_present(
+        ex,
+        [
+            "endings",
+            "choices",
+            "options",
+            "answers",
+            "candidates",
+            "multiple_choice",
+        ],
+    )
+
+    choices = normalize_choices(raw_choices, ex)
+
+    raw_answer = pick_first_present(
+        ex,
+        [
+            "label",
+            "answer",
+            "target",
+            "correct",
+            "correct_answer",
+            "answer_idx",
+            "answer_index",
+            "gold",
+        ],
+    )
+
+    if prompt is None or choices is None:
+        return None
+
+    answer_idx = normalize_answer(raw_answer, choices)
+    if answer_idx is None:
+        return None
+
+    return str(prompt), choices, answer_idx
+
+
+def score_continuation(
+    model: torch.nn.Module,
+    tokenizer: Any,
+    prompt: str,
+    continuation: str,
+    device: str,
+    normalize: str,
+) -> float:
+    full_text = prompt + continuation
+
+    enc_full = tokenizer(full_text, return_tensors="pt", add_special_tokens=False).to(device)
+    enc_prompt = tokenizer(prompt, return_tensors="pt", add_special_tokens=False).to(device)
+
+    input_ids = enc_full["input_ids"]
+    prompt_len = enc_prompt["input_ids"].shape[1]
+
+    if input_ids.shape[1] < 2:
+        return -1e30
+
+    with torch.no_grad():
+        logits = model(input_ids=input_ids).logits
+
+    shift_logits = logits[:, :-1, :]
+    shift_labels = input_ids[:, 1:]
+
+    start = max(prompt_len - 1, 0)
+    cont_logits = shift_logits[:, start:, :]
+    cont_labels = shift_labels[:, start:]
+
+    if cont_labels.numel() == 0:
+        return -1e30
+
+    log_probs = torch.log_softmax(cont_logits, dim=-1)
+    token_log_probs = log_probs.gather(-1, cont_labels.unsqueeze(-1)).squeeze(-1)
+
+    if normalize == "mean":
+        return float(token_log_probs.mean().item())
+
+    if normalize == "sum":
+        return float(token_log_probs.sum().item())
+
+    raise ValueError(f"Unknown normalize mode: {normalize}")
+
+
+def run_our_benchmark(
+    model_id: str,
+    device: str,
+    dtype: str,
+    limit: Optional[int],
+    trust_remote_code: bool,
+    normalize: str,
+    split: Optional[str],
+    choice_prefix: str,
+) -> Dict[str, Any]:
+    print(f"\n[INFO] Loading model/tokenizer for our_benchmark: {model_id}", flush=True)
+
+    tokenizer = AutoTokenizer.from_pretrained(
+        model_id,
+        trust_remote_code=trust_remote_code,
+    )
+
+    if tokenizer.pad_token is None and tokenizer.eos_token is not None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    torch_dtype = {
+        "float32": torch.float32,
+        "fp32": torch.float32,
+        "float16": torch.float16,
+        "fp16": torch.float16,
+        "bfloat16": torch.bfloat16,
+        "bf16": torch.bfloat16,
+        "auto": "auto",
+    }.get(dtype, dtype)
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_id,
+        torch_dtype=torch_dtype,
+        trust_remote_code=trust_remote_code,
+    ).to(device)
+
+    model.eval()
+    params = count_params(model)
+
+    print(f"[INFO] Loading dataset: {OUR_BENCHMARK_DATASET}", flush=True)
+    ds = load_dataset(OUR_BENCHMARK_DATASET)
+
+    if split is None:
+        if "test" in ds:
+            split_name = "test"
+        elif "validation" in ds:
+            split_name = "validation"
+        else:
+            split_name = list(ds.keys())[0]
+    else:
+        split_name = split
+
+    data = ds[split_name]
+
+    print(f"[INFO] our_benchmark split: {split_name}", flush=True)
+    print(f"[INFO] our_benchmark columns: {data.column_names}", flush=True)
+
+    if len(data) > 0:
+        print("[INFO] First example preview:")
+        print(json.dumps(data[0], indent=2, ensure_ascii=False)[:2000])
+
+    total = 0
+    correct = 0
+    skipped = 0
+
+    n = len(data) if limit is None else min(limit, len(data))
+
+    for i in tqdm(range(n), desc="our_benchmark"):
+        ex = dict(data[i])
+        item = build_our_benchmark_item(ex)
+
+        if item is None:
+            skipped += 1
+            continue
+
+        prompt, choices, answer_idx = item
+
+        scores = []
+        for choice in choices:
+            continuation = choice_prefix + str(choice)
+            s = score_continuation(
+                model=model,
+                tokenizer=tokenizer,
+                prompt=prompt,
+                continuation=continuation,
+                device=device,
+                normalize=normalize,
+            )
+            scores.append(s)
+
+        pred_idx = max(range(len(scores)), key=lambda j: scores[j])
+
+        correct += int(pred_idx == answer_idx)
+        total += 1
+
+    if total == 0:
+        die("our_benchmark: zero valid examples parsed. Need to adapt field parser.")
+
+    acc = 100.0 * correct / total
+
+    del model
+    if device.startswith("cuda"):
+        torch.cuda.empty_cache()
+
+    return {
+        "display": "Our Benchmark",
+        "task": OUR_BENCHMARK_DATASET,
+        "metric": f"acc_custom_loglikelihood_{normalize}",
+        "score": acc,
+        "correct": correct,
+        "total": total,
+        "skipped": skipped,
+        "split": split_name,
+        "params": params,
+    }
+
+
+def compute_final_avg(scores: Dict[str, Dict[str, Any]]) -> Optional[float]:
+    hellaswag = scores.get("hellaswag", {}).get("score")
+    arc = scores.get("arc", {}).get("score")
+    arc_chall = scores.get("arcChall", {}).get("score")
+    piqa = scores.get("piqa", {}).get("score")
+    our_benchmark = scores.get("our_benchmark", {}).get("score")
+
+    components = []
+
+    if hellaswag is not None:
+        components.append(hellaswag)
+
+    if arc is not None and arc_chall is not None:
+        components.append((arc + arc_chall) / 2.0)
+    elif arc is not None:
+        components.append(arc)
+    elif arc_chall is not None:
+        components.append(arc_chall)
+
+    if piqa is not None:
+        components.append(piqa)
+
+    if our_benchmark is not None:
+        components.append(our_benchmark)
+
+    if len(components) < 2:
+        return None
+
+    return sum(components) / len(components)
+
+
+def print_table(model_id: str, params: Optional[int], scores: Dict[str, Dict[str, Any]]) -> None:
+    final_avg = compute_final_avg(scores)
+
+    print("\n" + "=" * 74)
+    print("OPEN SLM LEADERBOARD STYLE RESULT")
+    print("=" * 74)
+    print(f"Model:  {model_id}")
+
+    if params is not None:
+        print(f"Params: {params:,}")
+
+    print("-" * 74)
+    print(f"{'Benchmark':<18} {'Task':<18} {'Metric':<28} {'Score':>8}")
+    print("-" * 74)
+
+    order = ["hellaswag", "arc", "arcChall", "piqa", "our_benchmark"]
+
+    for key in order:
+        if key not in scores:
+            continue
+
+        s = scores[key]
+        print(
+            f"{s['display']:<18} "
+            f"{str(s['task'])[:18]:<18} "
+            f"{str(s['metric'])[:28]:<28} "
+            f"{s['score']:>7.2f}%"
+        )
+
+    print("-" * 74)
+
+    if "arc" in scores and "arcChall" in scores:
+        arc_avg = (scores["arc"]["score"] + scores["arcChall"]["score"]) / 2.0
+        print(f"{'ARC Avg':<66} {arc_avg:>7.2f}%")
+
+    if final_avg is not None:
+        print(f"{'Final Avg':<66} {final_avg:>7.2f}%")
+    else:
+        print(f"{'Final Avg':<66} {'N/A':>8}")
+
+    print("=" * 74)
+
+    if "our_benchmark" in scores:
+        s = scores["our_benchmark"]
+        if "correct" in s:
+            print(
+                f"our_benchmark details: {s['correct']}/{s['total']} correct, "
+                f"skipped={s['skipped']}, split={s['split']}"
+            )
+
+
+def save_result(
+    path: str,
+    model_id: str,
+    params: Optional[int],
+    scores: Dict[str, Dict[str, Any]],
+) -> None:
+    payload = {
+        "model": model_id,
+        "params": params,
+        "scores": scores,
+        "arc_avg": None,
+        "final_avg": compute_final_avg(scores),
+    }
+
+    if "arc" in scores and "arcChall" in scores:
+        payload["arc_avg"] = (scores["arc"]["score"] + scores["arcChall"]["score"]) / 2.0
+
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(payload, f, indent=2, ensure_ascii=False)
+
+    print(f"\n[INFO] Saved JSON: {path}")
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Run Open SLM Leaderboard style benchmark on a HF model repo/local path."
+    )
+
+    p.add_argument(
+        "model",
+        help="HF repo id or local model path.",
+    )
+
+    p.add_argument("--device", default="cuda:0", help="cuda:0, cuda, cpu...")
+    p.add_argument("--dtype", default="bfloat16", help="bfloat16, float16, float32, auto")
+    p.add_argument("--batch-size", default="auto", help="lm_eval batch size, e.g. auto, 1, 2, 4")
+
+    p.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Debug limit applied to lm_eval and our_benchmark. Do not use for final scores.",
+    )
+
+    p.add_argument(
+        "--skip-lm-eval",
+        action="store_true",
+        help="Skip HellaSwag/ARC/PIQA.",
+    )
+
+    p.add_argument(
+        "--skip-our-benchmark",
+        action="store_true",
+        help="Skip our_benchmark.",
+    )
+
+    p.add_argument(
+        "--our-benchmark-split",
+        default=None,
+        help="Force our_benchmark split, e.g. test/validation/train. Default: test if available.",
+    )
+
+    p.add_argument(
+        "--our-benchmark-normalize",
+        default="mean",
+        choices=["mean", "sum"],
+        help="Continuation scoring. mean ~= acc_norm style. sum ~= raw loglikelihood.",
+    )
+
+    p.add_argument(
+        "--choice-prefix",
+        default="",
+        help="Prefix added before each answer choice when scoring our_benchmark.",
+    )
+
+    p.add_argument(
+        "--no-trust-remote-code",
+        action="store_true",
+        help="Disable trust_remote_code.",
+    )
+
+    p.add_argument(
+        "--json-out",
+        default=None,
+        help="Optional output JSON file.",
+    )
+
+    return p.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    trust_remote_code = not args.no_trust_remote_code
+    scores: Dict[str, Dict[str, Any]] = {}
+    params: Optional[int] = None
+
+    if not args.skip_lm_eval:
+        print("[INFO] Running LM-eval standard tasks...", flush=True)
+        raw_lm = run_lm_eval(
+            model_id=args.model,
+            device=args.device,
+            dtype=args.dtype,
+            batch_size=args.batch_size,
+            limit=args.limit,
+            trust_remote_code=trust_remote_code,
+        )
+        scores.update(extract_lm_eval_scores(raw_lm))
+
+    if not args.skip_our_benchmark:
+        print("[INFO] Running our_benchmark...", flush=True)
+        our_benchmark = run_our_benchmark(
+            model_id=args.model,
+            device=args.device,
+            dtype=args.dtype,
+            limit=args.limit,
+            trust_remote_code=trust_remote_code,
+            normalize=args.our_benchmark_normalize,
+            split=args.our_benchmark_split,
+            choice_prefix=args.choice_prefix,
+        )
+        params = our_benchmark.get("params")
+        scores["our_benchmark"] = our_benchmark
+
+    print_table(args.model, params, scores)
+
+    if args.json_out:
+        save_result(args.json_out, args.model, params, scores)
+
+
+if __name__ == "__main__":
+    main()