Download benchmark.py from noodcon/Sampling-Config-Benchmark: direct link, hf CLI and curl.
- Browser
- Download file 18.6 kB
-
https://huggingface.co/datasets/noodcon/Sampling-Config-Benchmark/resolve/main/benchmark.py
- Command line
-
hf download hf://datasets/noodcon/Sampling-Config-Benchmark/benchmark.py
-
curl -L -o benchmark.py https://huggingface.co/datasets/noodcon/Sampling-Config-Benchmark/resolve/main/benchmark.py
18.6 kB
| #!/usr/bin/env python3 | |
| """ | |
| Sampling Config Benchmark (code / fix bug / toán, mức dễ-trung bình) | |
| ==================================================================== | |
| Tìm cấu hình sampling tốt nhất (temperature, top_p, top_k, repetition_penalty) | |
| cho một model, chấm hoàn toàn tự động: | |
| code : HumanEval + MBPP (chạy unit test) | |
| fix : HumanEvalFix (sửa code lỗi, chạy unit test) | |
| math : GSM8K + MATH-500 (chỉ level 1-3) | |
| Chạy với server tương thích OpenAI API (vLLM, SGLang, llama.cpp server, ...): | |
| vllm serve Qwen/Qwen3-8B --port 8000 | |
| python benchmark.py --model Qwen/Qwen3-8B --base-url http://localhost:8000/v1 | |
| CẢNH BÁO: script chạy code do model sinh ra. Hãy chạy trong Docker/VM/máy cô lập. | |
| """ | |
| import argparse | |
| import asyncio | |
| import hashlib | |
| import itertools | |
| import json | |
| import os | |
| import random | |
| import re | |
| import signal | |
| import sys | |
| import tempfile | |
| from asyncio.subprocess import DEVNULL | |
| from pathlib import Path | |
| import numpy as np | |
| from datasets import load_dataset | |
| from openai import AsyncOpenAI | |
| GRID = { | |
| "temperature": [0.0, 0.3, 0.6, 0.8, 1.0, 1.2], | |
| "top_p": [0.8, 0.9, 0.95, 1.0], | |
| "top_k": [0, 20, 40, 100], # 0 = tắt | |
| "repetition_penalty": [1.0, 1.05, 1.1], | |
| } | |
| CATS = ["code", "fix", "math"] | |
| SUBTASKS = {"humaneval": "code", "mbpp": "code", "humanevalfix": "fix", "gsm8k": "math", "math500": "math"} | |
| EXEC_SEM = None | |
| # ---------------------------------------------------------------------------- | |
| # Configs | |
| # ---------------------------------------------------------------------------- | |
| def make_configs(mode, n_random, seed): | |
| keys = list(GRID) | |
| seen, out = set(), [] | |
| for v in itertools.product(*GRID.values()): | |
| c = dict(zip(keys, v)) | |
| if c["temperature"] == 0: # greedy: top_p/top_k vô nghĩa | |
| c["top_p"], c["top_k"] = 1.0, 0 | |
| k = json.dumps(c, sort_keys=True) | |
| if k not in seen: | |
| seen.add(k) | |
| out.append(c) | |
| if mode == "random": | |
| random.Random(seed).shuffle(out) | |
| out = out[:n_random] | |
| return out | |
| # ---------------------------------------------------------------------------- | |
| # Datasets | |
| # ---------------------------------------------------------------------------- | |
| CODE_REPLY = "Reply with the complete code in a single ```python code block." | |
| def imports_of(code): | |
| return "\n".join(l for l in code.splitlines() if re.match(r"^(import|from)\s+\S", l)) | |
| def load_items(subtasks, n, seed): | |
| rng = random.Random(seed) | |
| items = [] | |
| def pick(ds): | |
| idx = list(range(len(ds))) | |
| rng.shuffle(idx) | |
| return [ds[i] for i in idx[:n]] | |
| if "humaneval" in subtasks: | |
| for r in pick(load_dataset("openai/openai_humaneval", split="test")): | |
| items.append(dict( | |
| id=f"he-{r['task_id']}", cat="code", task="humaneval", kind="exec", entry=r["entry_point"], | |
| pre=r["prompt"], post=r["test"] + f"\ncheck({r['entry_point']})", | |
| prompt=f"Complete the following Python function.\n\n```python\n{r['prompt']}\n```\n\n{CODE_REPLY}")) | |
| if "mbpp" in subtasks: | |
| for r in pick(load_dataset("google-research-datasets/mbpp", "sanitized", split="test")): | |
| m = re.search(r"def\s+(\w+)", r["code"]) | |
| tests = "\n".join(r["test_list"]) | |
| items.append(dict( | |
| id=f"mbpp-{r['task_id']}", cat="code", task="mbpp", kind="exec", entry=m.group(1) if m else "", | |
| pre="\n".join(r["test_imports"]), post=tests, | |
| prompt=f"{r['prompt']}\n\nYour code must pass these tests:\n```python\n{tests}\n```\n\n{CODE_REPLY}")) | |
| if "humanevalfix" in subtasks: | |
| for r in pick(load_dataset("bigcode/humanevalpack", "python", split="test")): | |
| buggy = r["prompt"] + r["buggy_solution"] | |
| items.append(dict( | |
| id=f"hef-{r['task_id']}", cat="fix", task="humanevalfix", kind="exec", entry=r["entry_point"], | |
| pre=imports_of(buggy), post=r["test"] + f"\ncheck({r['entry_point']})", | |
| prompt=("The following Python code contains a bug and fails its unit tests. " | |
| f"Find and fix the bug.\n\n```python\n{buggy}\n```\n\n" | |
| "Reply with the complete fixed code (including any helper functions) in a single ```python code block."))) | |
| if "gsm8k" in subtasks: | |
| for r in pick(load_dataset("openai/gsm8k", "main", split="test")): | |
| items.append(dict( | |
| id="gsm8k-" + hashlib.md5(r["question"].encode()).hexdigest()[:10], cat="math", task="gsm8k", kind="math", | |
| gold=r["answer"].split("####")[-1].strip().replace(",", ""), | |
| prompt=r["question"] + "\n\nSolve step by step. Put the final answer in \\boxed{}.")) | |
| if "math500" in subtasks: | |
| ds = load_dataset("HuggingFaceH4/MATH-500", split="test").filter(lambda r: r["level"] <= 3) | |
| for r in pick(ds): | |
| items.append(dict( | |
| id=f"math-{r['unique_id']}", cat="math", task="math500", kind="math", gold=r["answer"], | |
| prompt=r["problem"] + "\n\nSolve step by step. Put the final answer in \\boxed{}.")) | |
| return items | |
| # ---------------------------------------------------------------------------- | |
| # Scoring: math | |
| # ---------------------------------------------------------------------------- | |
| def strip_think(t): | |
| t = re.sub(r"<think>.*?</think>", "", t, flags=re.S) | |
| return t.split("</think>")[-1].strip() | |
| def last_boxed(s): | |
| i = s.rfind("\\boxed") | |
| j = s.find("{", i) if i >= 0 else -1 | |
| if j < 0: | |
| return None | |
| depth = 0 | |
| for k in range(j, len(s)): | |
| if s[k] == "{": | |
| depth += 1 | |
| elif s[k] == "}": | |
| depth -= 1 | |
| if depth == 0: | |
| return s[j + 1:k] | |
| return None | |
| def norm(a): | |
| a = re.sub(r"\\text\{([^}]*)\}", r"\1", a.strip()) | |
| for t in ["\\left", "\\right", "\\!", "\\,", "\\;", "\\ ", "$", "\\%", "%", "^\\circ", "^{\\circ}", "\\displaystyle"]: | |
| a = a.replace(t, "") | |
| a = a.replace("dfrac", "frac").replace("tfrac", "frac").replace(" ", "").rstrip(".") | |
| if re.fullmatch(r"-?[\d,]+(\.\d+)?", a): | |
| a = a.replace(",", "") | |
| return a | |
| def to_num(a): | |
| try: | |
| m = re.fullmatch(r"(-?)\\frac\{(-?[\d.]+)\}\{(-?[\d.]+)\}", a) | |
| if m: | |
| return (-1 if m[1] else 1) * float(m[2]) / float(m[3]) | |
| m = re.fullmatch(r"(-?[\d.]+)/(-?[\d.]+)", a) | |
| if m: | |
| return float(m[1]) / float(m[2]) | |
| return float(a) | |
| except Exception: | |
| return None | |
| def math_correct(item, text): | |
| text = strip_think(text) | |
| pred = last_boxed(text) | |
| if pred is None and item["task"] == "gsm8k": | |
| m = re.findall(r"-?\d[\d,]*\.?\d*", text) | |
| pred = m[-1] if m else None | |
| if pred is None: | |
| return False | |
| p, g = norm(pred), norm(item["gold"]) | |
| if p == g: | |
| return True | |
| x, y = to_num(p), to_num(g) | |
| return x is not None and y is not None and abs(x - y) < 1e-6 | |
| # ---------------------------------------------------------------------------- | |
| # Scoring: code execution | |
| # ---------------------------------------------------------------------------- | |
| def extract_code(text, entry): | |
| text = strip_think(text) | |
| blocks = re.findall(r"```(?:python|py|Python)?[ \t]*\n(.*?)```", text, flags=re.S) | |
| if not blocks: | |
| m = re.search(r"```(?:python|py|Python)?[ \t]*\n(.*)$", text, flags=re.S) # block bị cắt | |
| return m.group(1) if m else text | |
| cands = [b for b in blocks if entry and f"def {entry}" in b] | |
| return (cands or blocks)[-1] | |
| def _limits(): | |
| try: | |
| import resource | |
| resource.setrlimit(resource.RLIMIT_AS, (2 << 30, 2 << 30)) | |
| except Exception: | |
| pass | |
| async def run_python(program, timeout): | |
| with tempfile.TemporaryDirectory() as d: | |
| f = Path(d) / "main.py" | |
| f.write_text(program, encoding="utf-8", errors="replace") | |
| kw = {} if os.name == "nt" else {"preexec_fn": _limits, "start_new_session": True} | |
| p = await asyncio.create_subprocess_exec(sys.executable, "-I", str(f), cwd=d, | |
| stdin=DEVNULL, stdout=DEVNULL, stderr=DEVNULL, **kw) | |
| try: | |
| await asyncio.wait_for(p.wait(), timeout) | |
| return p.returncode == 0 | |
| except asyncio.TimeoutError: | |
| try: | |
| os.killpg(p.pid, signal.SIGKILL) if os.name != "nt" else p.kill() | |
| except Exception: | |
| pass | |
| await p.wait() | |
| return False | |
| async def score(item, text, timeout): | |
| if item["kind"] == "math": | |
| return float(math_correct(item, text)) | |
| code = extract_code(text, item["entry"]) | |
| program = f"{item['pre']}\n\n{code}\n\n{item['post']}\n" | |
| async with EXEC_SEM: | |
| return float(await run_python(program, timeout)) | |
| def rep_rate(text, n=4): | |
| w = text.split() | |
| if len(w) < n + 1: | |
| return 0.0 | |
| g = [tuple(w[i:i + n]) for i in range(len(w) - n + 1)] | |
| return 1 - len(set(g)) / len(g) | |
| # ---------------------------------------------------------------------------- | |
| # Runner | |
| # ---------------------------------------------------------------------------- | |
| async def eval_item(client, args, cfg, item, sem): | |
| n = 1 if cfg["temperature"] == 0 else args.n_samples | |
| last = None | |
| async with sem: | |
| for attempt in range(4): | |
| try: | |
| r = await client.chat.completions.create( | |
| model=args.model, messages=[{"role": "user", "content": item["prompt"]}], | |
| temperature=cfg["temperature"], top_p=cfg["top_p"], max_tokens=args.max_tokens, n=n, | |
| extra_body={"top_k": cfg["top_k"], "repetition_penalty": cfg["repetition_penalty"]}) | |
| break | |
| except Exception as e: # noqa | |
| last = e | |
| await asyncio.sleep(2 ** attempt) | |
| else: | |
| raise RuntimeError(f"API lỗi: {last}") | |
| texts = [c.message.content or "" for c in r.choices] | |
| scores = await asyncio.gather(*[score(item, t, args.exec_timeout) for t in texts]) | |
| return {"id": item["id"], "acc": float(np.mean(scores)), | |
| "rep": float(np.mean([rep_rate(strip_think(t)) for t in texts])), | |
| "trunc": float(np.mean([c.finish_reason == "length" for c in r.choices]))} | |
| def signature(args, items): | |
| return hashlib.md5(json.dumps([[i["id"] for i in items], args.n_samples, args.max_tokens, | |
| args.model, args.exec_timeout]).encode()).hexdigest() | |
| def load_records(path, sig): | |
| if not path.exists(): | |
| return {} | |
| out = {} | |
| for line in path.read_text().splitlines(): | |
| d = json.loads(line) | |
| if d.get("sig") == sig: | |
| out[d["key"]] = d | |
| return out | |
| async def run_all(args, items, configs, sig): | |
| global EXEC_SEM | |
| EXEC_SEM = asyncio.Semaphore(args.exec_workers) | |
| path = Path(args.out) / "raw_results.jsonl" | |
| path.parent.mkdir(parents=True, exist_ok=True) | |
| done = load_records(path, sig) | |
| client = AsyncOpenAI(base_url=args.base_url, api_key=args.api_key, timeout=900) | |
| sem = asyncio.Semaphore(args.concurrency) | |
| for i, cfg in enumerate(configs, 1): | |
| key = json.dumps(cfg, sort_keys=True) | |
| if key in done: | |
| print(f"[{i}/{len(configs)}] bỏ qua (đã có): {cfg}") | |
| continue | |
| print(f"[{i}/{len(configs)}] {cfg}") | |
| res = await asyncio.gather(*[eval_item(client, args, cfg, it, sem) for it in items]) | |
| rec = {"key": key, "sig": sig, "config": cfg, "items": res} | |
| done[key] = rec | |
| with path.open("a") as f: | |
| f.write(json.dumps(rec) + "\n") | |
| by = {c: np.mean([r["acc"] for r, it in zip(res, items) if it["cat"] == c]) for c in {it["cat"] for it in items}} | |
| print(" " + " ".join(f"{c}={v:.3f}" for c, v in sorted(by.items()))) | |
| return list(done.values()) | |
| # ---------------------------------------------------------------------------- | |
| # Analysis (bootstrap phân tầng theo category) | |
| # ---------------------------------------------------------------------------- | |
| def summarize(boots, mean): | |
| lo, hi = np.percentile(boots, [2.5, 97.5], axis=1) | |
| p_best = np.bincount(boots.argmax(0), minlength=len(mean)) / boots.shape[1] | |
| best = int(mean.argmax()) | |
| tied = [c for c in range(len(mean)) if c != best and np.percentile(boots[best] - boots[c], 2.5) <= 0] | |
| return lo, hi, p_best, best, tied | |
| def cfg_str(c): | |
| return f"temp={c['temperature']}, top_p={c['top_p']}, top_k={c['top_k']}, rep_p={c['repetition_penalty']}" | |
| def analyze(args, records, items): | |
| ids = [it["id"] for it in items] | |
| cats = [c for c in CATS if any(it["cat"] == c for it in items)] | |
| idx = {c: np.array([j for j, it in enumerate(items) if it["cat"] == c]) for c in cats} | |
| w = {c: float(args.weights.get(c, 1.0)) for c in cats} | |
| tw = sum(w.values()) | |
| w = {c: v / tw for c, v in w.items()} | |
| C, N = len(records), len(ids) | |
| acc, rep, trunc = np.zeros((C, N)), np.zeros((C, N)), np.zeros((C, N)) | |
| for c, r in enumerate(records): | |
| m = {x["id"]: x for x in r["items"]} | |
| for j, i in enumerate(ids): | |
| acc[c, j], rep[c, j], trunc[c, j] = m[i]["acc"], m[i]["rep"], m[i]["trunc"] | |
| rng = np.random.default_rng(args.seed) | |
| B = 2000 | |
| cboot = {c: np.stack([acc[:, rng.choice(idx[c], len(idx[c]))].mean(1) for _ in range(B)], axis=1) for c in cats} | |
| cmean = {c: acc[:, idx[c]].mean(1) for c in cats} | |
| oboot = sum(w[c] * cboot[c] for c in cats) | |
| omean = sum(w[c] * cmean[c] for c in cats) | |
| lo, hi, pb, best, tied = summarize(oboot, omean) | |
| b = records[best]["config"] | |
| L = [f"# Kết quả: `{args.model}`\n", | |
| f"- Câu hỏi: **{N}** | task: {', '.join(args.tasks)} | samples/câu: **{args.n_samples}** | max_tokens: {args.max_tokens}", | |
| f"- Trọng số category: " + ", ".join(f"{c}={w[c]:.2f}" for c in cats), | |
| f"- Số cấu hình đã test: **{C}**\n", | |
| "## 🏆 Cấu hình tốt nhất (tổng hợp)\n```", | |
| f"temp = {b['temperature']}\ntop p = {b['top_p']}\ntop k = {b['top_k']}\nrep p (repetition_penalty) = {b['repetition_penalty']}", | |
| f"```\nScore: **{omean[best]:.4f}** (95% CI {lo[best]:.4f} – {hi[best]:.4f}), P(best) = {pb[best]:.2f}\n"] | |
| if tied: | |
| L.append(f"> ⚠️ **{len(tied)}** cấu hình khác không khác biệt có ý nghĩa thống kê so với cấu hình này (cột `Tied`).\n") | |
| L.append("## Cấu hình tốt nhất cho từng loại\n\n| Loại | Cấu hình | Acc | 95% CI | Số cấu hình hòa |\n|:--|:--|--:|:--|--:|") | |
| per_cat = {} | |
| for c in cats: | |
| l2, h2, _, b2, t2 = summarize(cboot[c], cmean[c]) | |
| per_cat[c] = {"config": records[b2]["config"], "accuracy": float(cmean[c][b2]), "ci95": [float(l2[b2]), float(h2[b2])]} | |
| L.append(f"| {c} | {cfg_str(records[b2]['config'])} | {cmean[c][b2]:.4f} | {l2[b2]:.3f}–{h2[b2]:.3f} | {len(t2)} |") | |
| L.append("\n## Bảng xếp hạng (top 20)\n") | |
| L.append("| # | temp | top_p | top_k | rep_p | Score | 95% CI | P(best) | " + " | ".join(cats) + " | Rep4 | Trunc | Tied |") | |
| L.append("|--:|--:|--:|--:|--:|--:|:--|--:|" + "--:|" * len(cats) + "--:|--:|:-:|") | |
| for rank, c in enumerate(np.argsort(-omean)[:20], 1): | |
| g = records[c]["config"] | |
| L.append(f"| {rank} | {g['temperature']} | {g['top_p']} | {g['top_k']} | {g['repetition_penalty']} | {omean[c]:.4f} | " | |
| f"{lo[c]:.3f}–{hi[c]:.3f} | {pb[c]:.2f} | " + " | ".join(f"{cmean[k][c]:.3f}" for k in cats) + | |
| f" | {rep[c].mean():.3f} | {trunc[c].mean():.3f} | {'✅' if c == best or c in tied else ''} |") | |
| L.append("\n## Ảnh hưởng trung bình của từng tham số\n") | |
| for k in GRID: | |
| L.append(f"**{k}**\n\n| giá trị | Score TB |\n|--:|--:|") | |
| for v in GRID[k]: | |
| ix = [c for c in range(C) if records[c]["config"][k] == v] | |
| if ix: | |
| L.append(f"| {v} | {omean[ix].mean():.4f} |") | |
| L.append("") | |
| out = Path(args.out) | |
| out.mkdir(parents=True, exist_ok=True) | |
| (out / "results.md").write_text("\n".join(L)) | |
| (out / "best_config.json").write_text(json.dumps({ | |
| "model": args.model, "best_overall": b, "score": float(omean[best]), "ci95": [float(lo[best]), float(hi[best])], | |
| "best_per_category": per_cat, "statistically_tied": [records[c]["config"] for c in tied]}, | |
| indent=2, ensure_ascii=False)) | |
| print("\n".join(L[:22])) | |
| print(f"\nĐã lưu: {out}/results.md, best_config.json") | |
| # ---------------------------------------------------------------------------- | |
| def parse_weights(s): | |
| return {k: float(v) for k, v in (p.split("=") for p in s.split(","))} if s else {} | |
| def main(): | |
| p = argparse.ArgumentParser() | |
| p.add_argument("--model", required=True) | |
| p.add_argument("--base-url", default="http://localhost:8000/v1") | |
| p.add_argument("--api-key", default="EMPTY") | |
| p.add_argument("--tasks", nargs="+", default=list(SUBTASKS), choices=list(SUBTASKS)) | |
| p.add_argument("--n-per-task", type=int, default=80, help="số câu mỗi task") | |
| p.add_argument("--n-samples", type=int, default=4, help="số lần sample mỗi câu (giảm nhiễu)") | |
| p.add_argument("--max-tokens", type=int, default=2048) | |
| p.add_argument("--concurrency", type=int, default=64) | |
| p.add_argument("--exec-workers", type=int, default=8, help="số tiến trình chạy code song song") | |
| p.add_argument("--exec-timeout", type=float, default=10.0) | |
| p.add_argument("--weights", type=parse_weights, default={}, help='vd "code=1,fix=1,math=2"') | |
| p.add_argument("--mode", choices=["grid", "random"], default="grid") | |
| p.add_argument("--n-random", type=int, default=40) | |
| p.add_argument("--seed", type=int, default=42) | |
| p.add_argument("--out", default="results") | |
| p.add_argument("--analyze-only", action="store_true") | |
| args = p.parse_args() | |
| items = load_items(args.tasks, args.n_per_task, args.seed) | |
| configs = make_configs(args.mode, args.n_random, args.seed) | |
| sig = signature(args, items) | |
| print(f"{len(items)} câu hỏi | {len(configs)} cấu hình") | |
| if args.analyze_only: | |
| recs = list(load_records(Path(args.out) / "raw_results.jsonl", sig).values()) | |
| else: | |
| recs = asyncio.run(run_all(args, items, configs, sig)) | |
| if not recs: | |
| sys.exit("Chưa có kết quả nào khớp với tham số hiện tại.") | |
| analyze(args, recs, items) | |
| if __name__ == "__main__": | |
| main() | |