noodcon's picture
Upload 3 files
5493f13 verified
Raw History Blame Contribute Delete
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()