312 lines
13 KiB
Python
312 lines
13 KiB
Python
#!/usr/bin/env python3
|
||
"""benchmark.py — 골든태스크 품질 회귀 벤치마크 (리뷰 3주차).
|
||
|
||
plain Claude vs 이 하네스를 같은 골든태스크로 실행·채점·비교한다. 개선이 증명되지 않는
|
||
role/fan-out/framework의 제거 근거를 만든다. 이 도구는 **측정 인프라**다 — 실제 비교 데이터는
|
||
두 arm으로 과제를 실행하고 record 로 점수를 적재해야 쌓인다(정직: 데이터 없으면 '미실행' 표시).
|
||
|
||
repo-level `benchmark/`(워크스페이스 비의존): golden-tasks.yaml · benchmark-rubric.yaml ·
|
||
runs.jsonl(append-only) · BENCHMARK.md(비교 리포트).
|
||
|
||
Usage:
|
||
benchmark.py list # 골든태스크 목록
|
||
benchmark.py run --task GT-01 --arm plain|harness [--execute] [--timeout 900]
|
||
# fixture+verify 가 있는 과제를 임시 복사본에서 실행·자동채점. 기본 --dry-run(미실행, 예산보호),
|
||
# --execute 를 줘야 claude CLI 를 호출하고 verify 로 객관 채점 후 runs.jsonl 에 적재한다.
|
||
benchmark.py record --task GT-01 --arm plain|harness \
|
||
--scores "first-pass-acceptance=1,tests-pass-rate=0.9,rework-count=1,tokens=8000" [--note ...]
|
||
# fixture 없는(문서/결정 등 수동채점) 과제용 — 사람이 채점한 점수를 적재.
|
||
benchmark.py compare # runs.jsonl -> BENCHMARK.md (plain vs harness delta)
|
||
"""
|
||
import json
|
||
import os
|
||
import re
|
||
import shutil
|
||
import subprocess
|
||
import sys
|
||
import tempfile
|
||
from datetime import datetime, timezone
|
||
|
||
import yaml
|
||
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
ROOT = os.environ.get("CLAUDE_PROJECT_DIR") or os.path.dirname(os.path.dirname(HERE))
|
||
BENCH = os.path.join(ROOT, "benchmark")
|
||
TASKS = os.path.join(BENCH, "golden-tasks.yaml")
|
||
RUBRIC = os.path.join(BENCH, "benchmark-rubric.yaml")
|
||
RUNS = os.path.join(BENCH, "runs.jsonl")
|
||
OUT = os.path.join(BENCH, "BENCHMARK.md")
|
||
|
||
|
||
def _load(path, key):
|
||
return (yaml.safe_load(open(path, encoding="utf-8")) or {}).get(key, {})
|
||
|
||
|
||
def _tasks():
|
||
return _load(TASKS, "golden-tasks")
|
||
|
||
|
||
def _rubric():
|
||
return _load(RUBRIC, "benchmark-rubric")
|
||
|
||
|
||
def _runs():
|
||
if not os.path.exists(RUNS):
|
||
return []
|
||
out = []
|
||
for line in open(RUNS, encoding="utf-8"):
|
||
line = line.strip()
|
||
if line:
|
||
try:
|
||
out.append(json.loads(line))
|
||
except json.JSONDecodeError:
|
||
pass
|
||
return out
|
||
|
||
|
||
def cmd_list():
|
||
t = _tasks()
|
||
tasks = t.get("tasks", [])
|
||
print(f"골든태스크 {len(tasks)}개 (카테고리: {', '.join(t.get('categories', []))})")
|
||
for x in tasks:
|
||
print(f" {x['id']} [{x['category']}/{x.get('difficulty','-')}] {x['prompt']}")
|
||
|
||
|
||
def cmd_record(opt):
|
||
task, arm = opt.get("task"), opt.get("arm")
|
||
valid_ids = {x["id"] for x in _tasks().get("tasks", [])}
|
||
arms = _rubric().get("arms", ["plain", "harness"])
|
||
if task not in valid_ids:
|
||
sys.stderr.write(f"unknown task {task!r} — golden-tasks.yaml 참고(list)\n")
|
||
sys.exit(2)
|
||
if arm not in arms:
|
||
sys.stderr.write(f"arm은 {arms} 중 하나여야 한다(got {arm!r})\n")
|
||
sys.exit(2)
|
||
scores = {}
|
||
for kv in (opt.get("scores") or "").split(","):
|
||
kv = kv.strip()
|
||
if "=" in kv:
|
||
k, v = kv.split("=", 1)
|
||
try:
|
||
scores[k.strip()] = float(v)
|
||
except ValueError:
|
||
scores[k.strip()] = v.strip()
|
||
rec = {"at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
|
||
"task": task, "arm": arm, "scores": scores, "note": opt.get("note")}
|
||
os.makedirs(BENCH, exist_ok=True)
|
||
with open(RUNS, "a", encoding="utf-8") as f:
|
||
f.write(json.dumps(rec, ensure_ascii=False) + "\n")
|
||
print(f"[benchmark] recorded {task}/{arm}: {scores}")
|
||
|
||
|
||
def _mean(vals):
|
||
vals = [v for v in vals if isinstance(v, (int, float))]
|
||
return sum(vals) / len(vals) if vals else None
|
||
|
||
|
||
# ─────────────────────────────────────────────── REAL runner + automated grader (R3)
|
||
# 재리뷰 지적: benchmark.py 는 '임의 점수 recorder'였다(모델 미실행). 이제 fixture+verify 가 있는
|
||
# 과제를 실제로 실행한다 — 임시 복사본에서 claude CLI(one-shot -p)를 두 arm(plain/harness)으로
|
||
# 돌리고, verify(pytest 등)로 **객관 채점**한다. 정직: 실행은 실제 API 예산을 쓰므로 기본은
|
||
# --dry-run(플러밍만 확인, 미실행). --execute 를 줘야 CLI 를 호출한다. 위조 점수 없음.
|
||
_CLAUDE_CMD = os.environ.get("ORGOS_BENCH_CLAUDE", "claude")
|
||
|
||
|
||
def _task_by_id(tid):
|
||
for t in _tasks().get("tasks", []):
|
||
if t.get("id") == tid:
|
||
return t
|
||
return None
|
||
|
||
|
||
def _git(args, cwd):
|
||
return subprocess.run(["git"] + args, cwd=cwd, capture_output=True, text=True)
|
||
|
||
|
||
def _setup_workdir(task, arm):
|
||
"""fixture 를 임시 dir 로 복사하고 git 기준선 커밋. harness arm 은 repo .claude 를 얹는다.
|
||
(workdir, fixture_abs) 반환. fixture 없으면 (None, None)."""
|
||
fx = task.get("fixture")
|
||
if not fx:
|
||
return None, None
|
||
# fixture 경로는 benchmark/ 기준(golden-tasks.yaml 위치). 절대경로면 그대로.
|
||
fixture_abs = fx if os.path.isabs(fx) else os.path.join(BENCH, fx)
|
||
if not os.path.isdir(fixture_abs):
|
||
return None, None
|
||
work = tempfile.mkdtemp(prefix=f"bench_{task['id']}_{arm}_")
|
||
for name in os.listdir(fixture_abs):
|
||
s = os.path.join(fixture_abs, name)
|
||
d = os.path.join(work, name)
|
||
(shutil.copytree if os.path.isdir(s) else shutil.copy2)(s, d)
|
||
_git(["init", "-q"], work)
|
||
_git(["add", "-A"], work)
|
||
_git(["-c", "user.email=b@b", "-c", "user.name=b", "commit", "-qm", "baseline"], work)
|
||
if arm == "harness":
|
||
# 하네스 arm: .claude(settings/hooks/agents)를 얹어 게이트가 실제로 작동하게 한다.
|
||
shutil.copytree(os.path.join(ROOT, ".claude"), os.path.join(work, ".claude"))
|
||
return work, fixture_abs
|
||
|
||
|
||
def _grade(work, task):
|
||
"""arm 실행 후 객관 채점. verify 실행 + git diff 로 점수 산출."""
|
||
scores = {}
|
||
verify = task.get("verify")
|
||
if verify:
|
||
vr = subprocess.run(verify, cwd=work, shell=True, capture_output=True, text=True, timeout=300)
|
||
out = (vr.stdout or "") + (vr.stderr or "")
|
||
scores["first-pass-acceptance"] = 1.0 if vr.returncode == 0 else 0.0
|
||
m = re.search(r"(\d+)\s+passed(?:,\s*(\d+)\s+failed)?", out)
|
||
if m:
|
||
p = int(m.group(1)); f = int(m.group(2) or 0)
|
||
scores["tests-pass-rate"] = round(p / (p + f), 3) if (p + f) else 0.0
|
||
else:
|
||
scores["tests-pass-rate"] = 1.0 if vr.returncode == 0 else 0.0
|
||
# unnecessary-change-lines: expected-changed-files 밖의 diff 라인 수.
|
||
exp = set(task.get("expected-changed-files") or [])
|
||
ns = _git(["diff", "--numstat", "HEAD"], work).stdout
|
||
extra = 0
|
||
for line in ns.splitlines():
|
||
parts = line.split("\t")
|
||
if len(parts) == 3:
|
||
add, dele, path = parts
|
||
if path not in exp and not path.startswith(".claude/"):
|
||
extra += (int(add) if add.isdigit() else 0) + (int(dele) if dele.isdigit() else 0)
|
||
scores["unnecessary-change-lines"] = extra
|
||
return scores
|
||
|
||
|
||
def cmd_run(opt):
|
||
task = _task_by_id(opt.get("task"))
|
||
arm = opt.get("arm")
|
||
if not task:
|
||
sys.stderr.write(f"unknown task {opt.get('task')!r} (list 참고)\n"); sys.exit(2)
|
||
if arm not in _rubric().get("arms", ["plain", "harness"]):
|
||
sys.stderr.write(f"arm 은 plain|harness 여야 한다(got {arm!r})\n"); sys.exit(2)
|
||
if not task.get("fixture"):
|
||
sys.stderr.write(f"{task['id']} 은 실행 fixture 가 없다 — 수동 record 대상(run 불가)\n"); sys.exit(2)
|
||
execute = bool(opt.get("execute"))
|
||
work, fixture_abs = _setup_workdir(task, arm)
|
||
if not work:
|
||
sys.stderr.write(f"fixture 설정 실패: {task.get('fixture')}\n"); sys.exit(1)
|
||
cli = [_CLAUDE_CMD, "-p", task["prompt"], "--dangerously-skip-permissions"]
|
||
env = dict(os.environ)
|
||
env["CLAUDE_PROJECT_DIR"] = work
|
||
if arm == "harness":
|
||
env["ORGOS_WORKSPACE"] = work # 하네스 arm: workspace 를 작업 dir 로
|
||
print(f"== benchmark run: {task['id']} / {arm} ==")
|
||
print(f" workdir: {work}")
|
||
print(f" verify : {task.get('verify')}")
|
||
print(f" CLI : {' '.join(cli[:2])} \"<prompt>\" {' '.join(cli[3:])}")
|
||
if not execute:
|
||
# 기본: 플러밍만 확인(미실행). fixture/verify 가 실제로 돌아가는지 baseline 채점으로 증명.
|
||
base = _grade(work, task)
|
||
print(f" [dry-run] 미실행(예산 보호). baseline verify → first-pass-acceptance="
|
||
f"{base.get('first-pass-acceptance')} (버그 상태라 0 이어야 정상).")
|
||
print(" 실제 실행: --execute 를 주면 claude CLI 를 호출하고 자동 채점·record 한다.")
|
||
return
|
||
if not shutil.which(_CLAUDE_CMD):
|
||
sys.stderr.write(f"claude CLI('{_CLAUDE_CMD}') 미가용 — ORGOS_BENCH_CLAUDE 로 지정하세요\n"); sys.exit(1)
|
||
print(" [execute] claude CLI 호출 중… (실제 API 예산 소비)")
|
||
try:
|
||
subprocess.run(cli, cwd=work, env=env, timeout=int(opt.get("timeout", 900) or 900))
|
||
except subprocess.TimeoutExpired:
|
||
print(" [execute] 타임아웃 — 부분 결과로 채점")
|
||
scores = _grade(work, task)
|
||
rec = {"at": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
|
||
"task": task["id"], "arm": arm, "scores": scores, "note": "auto(run)",
|
||
"workdir": work}
|
||
os.makedirs(BENCH, exist_ok=True)
|
||
with open(RUNS, "a", encoding="utf-8") as f:
|
||
f.write(json.dumps(rec, ensure_ascii=False) + "\n")
|
||
print(f" [execute] auto-graded {task['id']}/{arm}: {scores}")
|
||
|
||
|
||
def cmd_compare():
|
||
rub = _rubric()
|
||
dims = rub.get("dimensions", {})
|
||
runs = _runs()
|
||
by = {"plain": {}, "harness": {}}
|
||
for r in runs:
|
||
arm = r.get("arm")
|
||
if arm not in by:
|
||
continue
|
||
for k, v in (r.get("scores") or {}).items():
|
||
by[arm].setdefault(k, []).append(v)
|
||
ts = datetime.now().strftime("%Y-%m-%d %H:%M")
|
||
n_plain = sum(1 for r in runs if r.get("arm") == "plain")
|
||
n_harness = sum(1 for r in runs if r.get("arm") == "harness")
|
||
L = ["# 🏁 골든태스크 벤치마크 (plain Claude vs 하네스)", "",
|
||
f"생성: {ts} · 실행 표본: plain {n_plain} · harness {n_harness} "
|
||
f"(골든태스크 {len(_tasks().get('tasks', []))}개)",
|
||
"> 측정 인프라. 표본이 없으면 '미실행'으로 **정직히** 표시한다(위장 없음). "
|
||
"delta>0 = 하네스 이득(방향 보정됨).", "",
|
||
"| dimension | 방향 | weight | plain | harness | delta | 판정 |",
|
||
"|---|---|--:|--:|--:|--:|:--:|"]
|
||
wins = losses = ties = 0
|
||
composite = 0.0
|
||
for dim, spec in dims.items():
|
||
direction = spec.get("direction", "higher-better")
|
||
w = spec.get("weight", 1)
|
||
pm = _mean(by["plain"].get(dim, []))
|
||
hm = _mean(by["harness"].get(dim, []))
|
||
if pm is None or hm is None:
|
||
L.append(f"| {dim} | {direction} | {w} | "
|
||
f"{'-' if pm is None else round(pm,3)} | "
|
||
f"{'-' if hm is None else round(hm,3)} | - | ⚪ 미실행 |")
|
||
continue
|
||
raw = (hm - pm) if direction == "higher-better" else (pm - hm)
|
||
verdict = "✅ 하네스" if raw > 1e-9 else ("❌ plain" if raw < -1e-9 else "➖ 동률")
|
||
if raw > 1e-9:
|
||
wins += 1; composite += w
|
||
elif raw < -1e-9:
|
||
losses += 1; composite -= w
|
||
else:
|
||
ties += 1
|
||
L.append(f"| {dim} | {direction} | {w} | {round(pm,3)} | {round(hm,3)} | "
|
||
f"{round(raw,3):+} | {verdict} |")
|
||
L += ["",
|
||
f"**요약**: 하네스 우세 {wins} · plain 우세 {losses} · 동률 {ties} · "
|
||
f"가중 composite {composite:+g} (양수=하네스 이득).",
|
||
"", "> 판정 규칙(rubric.decision-rule): 하네스가 카테고리에서 delta<=0이면 그 role/fan-out/"
|
||
"framework는 비용만 늘리는 것 → 제거/경량화 후보. 표본을 채워 이 표를 실증한다."]
|
||
if n_plain == 0 and n_harness == 0:
|
||
L += ["", "⚠️ 아직 실행 표본이 없다. `benchmark.py record`로 두 arm의 점수를 적재하면 "
|
||
"이 표가 실증 데이터로 채워진다(현재는 프레임만)."]
|
||
os.makedirs(BENCH, exist_ok=True)
|
||
with open(OUT, "w", encoding="utf-8") as f:
|
||
f.write("\n".join(L) + "\n")
|
||
print(f"[benchmark] compare -> {os.path.relpath(OUT, ROOT)} "
|
||
f"(plain {n_plain} · harness {n_harness} 표본)")
|
||
|
||
|
||
def main():
|
||
a = sys.argv[1:]
|
||
if not a:
|
||
sys.stderr.write(__doc__)
|
||
sys.exit(1)
|
||
cmd = a[0]
|
||
opt = {}
|
||
i = 1
|
||
while i < len(a):
|
||
if a[i].startswith("--"):
|
||
k = a[i][2:]
|
||
opt[k] = a[i + 1] if i + 1 < len(a) and not a[i + 1].startswith("--") else True
|
||
i += 2
|
||
else:
|
||
i += 1
|
||
if cmd == "list":
|
||
cmd_list()
|
||
elif cmd == "run":
|
||
cmd_run(opt)
|
||
elif cmd == "record":
|
||
cmd_record(opt)
|
||
elif cmd == "compare":
|
||
cmd_compare()
|
||
else:
|
||
sys.stderr.write(f"unknown command: {cmd}\n")
|
||
sys.exit(1)
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|