| |
| """Summarise bench.py results per model and arm, overall and per pack. |
| |
| python3 summarize.py results/*.jsonl [--out-dir results] |
| |
| Writes summary.csv (one row per model x arm x pack, with pack "ALL" for the total) and |
| summary.md, and prints the overall table. Standard library only, Python 3.9 or newer. |
| """ |
|
|
| import argparse |
| import csv |
| import json |
| import math |
| import os |
| import statistics |
| import sys |
| from collections import Counter, OrderedDict |
|
|
| ARM_ORDER = ("stepmold", "plain", "plain_schema") |
| OUTCOMES = ("passed", "escalated", "silently_wrong", "crashed") |
| Z95 = 1.959963984540054 |
|
|
| COLUMNS = ( |
| "label", "model", "arm", "pack", "n", "passed", "pass_rate", "pass_ci_low", |
| "pass_ci_high", "escalated_rate", "escalated_not_passed_rate", "silently_wrong_rate", |
| "crashed_rate", "fields_matched_mean", "calls_per_case", "retries_per_case", |
| "rejected_calls_per_case", "latency_median_ms", "wall_median_ms", |
| "prompt_tokens_per_case", "completion_tokens_per_case", "reasoning_tokens_per_case", |
| "top_reject_reasons", |
| ) |
|
|
|
|
| def case_key(record): |
| return (record.get("label"), record.get("arm"), record.get("pack"), record.get("case"), |
| record.get("run")) |
|
|
|
|
| def read(paths): |
| """Case records (first copy of each case-run wins), their calls, open infra errors. |
| |
| A call is kept only if its case-run has a case record: a case-run that was cut off |
| and re-run leaves orphan calls behind, and they are not part of any result. |
| """ |
| runs, cases, calls, infra = [], OrderedDict(), [], [] |
| for path in paths: |
| with open(path, "r", encoding="utf-8") as handle: |
| for line in handle: |
| line = line.strip() |
| if not line: |
| continue |
| try: |
| record = json.loads(line) |
| except ValueError: |
| continue |
| kind = record.get("kind") if isinstance(record, dict) else None |
| if kind == "case": |
| cases.setdefault(case_key(record), record) |
| elif kind == "call": |
| calls.append(record) |
| elif kind == "infra_error": |
| infra.append(record) |
| elif kind == "run": |
| runs.append(record) |
| kept = set(record.get("case_run_id") for record in cases.values()) |
| calls = [call for call in calls if call.get("case_run_id") in kept] |
| infra = [record for record in infra if case_key(record) not in cases] |
| return runs, list(cases.values()), calls, infra |
|
|
|
|
| def wilson(successes, total, z=Z95): |
| """Wilson score interval for a proportion, as (low, high). (None, None) when empty.""" |
| if not total: |
| return None, None |
| p = successes / float(total) |
| denominator = 1.0 + z * z / total |
| centre = (p + z * z / (2.0 * total)) / denominator |
| half = z * math.sqrt(p * (1.0 - p) / total + z * z / (4.0 * total * total)) / denominator |
| return max(0.0, centre - half), min(1.0, centre + half) |
|
|
|
|
| def _mean(values): |
| values = [value for value in values if isinstance(value, (int, float))] |
| return sum(values) / float(len(values)) if values else None |
|
|
|
|
| def _median(values): |
| values = [value for value in values if isinstance(value, (int, float))] |
| return statistics.median(values) if values else None |
|
|
|
|
| def reject_reasons(calls, top=3): |
| """The commonest reasons a call's answer was not committed, as (text, count). |
| |
| stepmold's own wording is kept (records hold it verbatim); only the kind is added in |
| front when the wording does not already start with it. |
| """ |
| counts = Counter() |
| for call in calls: |
| if call.get("accepted") is not False: |
| continue |
| kind = call.get("reject_kind") or "unknown" |
| reason = " ".join(str(call.get("reject_reason") or "no reason given").split()) |
| reason = reason.replace(" — ", "; ") |
| if not reason.startswith(kind + ":"): |
| reason = "%s: %s" % (kind, reason) |
| counts[reason] += 1 |
| return counts.most_common(top) |
|
|
|
|
| def metrics(cases, calls): |
| n = len(cases) |
| passed = sum(1 for case in cases if case.get("passed")) |
| low, high = wilson(passed, n) |
| outcomes = Counter(case.get("outcome") for case in cases) |
|
|
| def rate(count): |
| return count / float(n) if n else None |
|
|
| fields = [case["fields_matched"] / float(case["fields_total"]) |
| for case in cases if case.get("fields_total")] |
| return OrderedDict([ |
| ("n", n), |
| ("passed", passed), |
| ("pass_rate", rate(passed)), |
| ("pass_ci_low", low), |
| ("pass_ci_high", high), |
| ("escalated_rate", rate(sum(1 for case in cases if case.get("escalated")))), |
| ("escalated_not_passed_rate", rate(outcomes.get("escalated", 0))), |
| ("silently_wrong_rate", rate(outcomes.get("silently_wrong", 0))), |
| ("crashed_rate", rate(outcomes.get("crashed", 0))), |
| ("fields_matched_mean", _mean(fields)), |
| ("calls_per_case", _mean([case.get("calls") for case in cases])), |
| ("retries_per_case", _mean([case.get("retries") for case in cases])), |
| ("rejected_calls_per_case", _mean([case.get("rejected_calls") for case in cases])), |
| ("latency_median_ms", _median([call.get("latency_ms") for call in calls])), |
| ("wall_median_ms", _median([case.get("wall_ms") for case in cases])), |
| ("prompt_tokens_per_case", _mean([case.get("prompt_tokens") for case in cases])), |
| ("completion_tokens_per_case", |
| _mean([case.get("completion_tokens") for case in cases])), |
| ("reasoning_tokens_per_case", _mean([case.get("reasoning_tokens") for case in cases])), |
| ("top_reject_reasons", reject_reasons(calls)), |
| ]) |
|
|
|
|
| def _arm_rank(arm): |
| return ARM_ORDER.index(arm) if arm in ARM_ORDER else len(ARM_ORDER) |
|
|
|
|
| def summarize(cases, calls): |
| """One row per (label, arm, pack), plus pack "ALL" per (label, arm), in report order.""" |
| calls_by_run = {} |
| for call in calls: |
| calls_by_run.setdefault(call.get("case_run_id"), []).append(call) |
| groups = OrderedDict() |
| for case in cases: |
| groups.setdefault((case.get("label"), case.get("arm")), []).append(case) |
| rows = [] |
| for label, arm in sorted(groups, key=lambda key: (str(key[0]), _arm_rank(key[1]), |
| str(key[1]))): |
| group = groups[(label, arm)] |
| model = group[0].get("model") |
| packs = sorted(set(case.get("pack") for case in group)) |
| for pack in ["ALL"] + packs: |
| subset = group if pack == "ALL" else [c for c in group if c.get("pack") == pack] |
| subset_calls = [call for case in subset |
| for call in calls_by_run.get(case.get("case_run_id"), ())] |
| row = OrderedDict([("label", label), ("model", model), ("arm", arm), |
| ("pack", pack)]) |
| row.update(metrics(subset, subset_calls)) |
| rows.append(row) |
| return rows |
|
|
|
|
| |
|
|
|
|
| def _csv_value(key, value): |
| if key == "top_reject_reasons": |
| return "; ".join("%s (%d)" % (reason, count) for reason, count in value) |
| if value is None: |
| return "" |
| if isinstance(value, float): |
| return "%.4f" % value |
| return value |
|
|
|
|
| def write_csv(rows, path): |
| with open(path, "w", newline="", encoding="utf-8") as handle: |
| writer = csv.writer(handle) |
| writer.writerow(COLUMNS) |
| for row in rows: |
| writer.writerow([_csv_value(key, row.get(key)) for key in COLUMNS]) |
|
|
|
|
| def _pct(value): |
| return "n/a" if value is None else "%.1f%%" % (value * 100.0) |
|
|
|
|
| def _num(value, digits=2): |
| return "n/a" if value is None else ("%.*f" % (digits, value)) |
|
|
|
|
| def _ms(value): |
| return "n/a" if value is None else "%.0f ms" % value |
|
|
|
|
| def _pass(row): |
| if row["pass_rate"] is None: |
| return "n/a" |
| return "%s (%.1f to %.1f)" % (_pct(row["pass_rate"]), row["pass_ci_low"] * 100.0, |
| row["pass_ci_high"] * 100.0) |
|
|
|
|
| HEADER = ("| %s | Arm | Case-runs | Pass rate (95%% CI) | Escalated, not passed | " |
| "Silently wrong | Crashed | Fields matched | Calls / case | Retries / case | " |
| "Median call latency |") |
| RULE = "|---|---|---:|---|---:|---:|---:|---:|---:|---:|---:|" |
|
|
|
|
| def _line(first, row): |
| return "| %s | %s | %d | %s | %s | %s | %s | %s | %s | %s | %s |" % ( |
| first, row["arm"], row["n"], _pass(row), _pct(row["escalated_not_passed_rate"]), |
| _pct(row["silently_wrong_rate"]), _pct(row["crashed_rate"]), |
| _pct(row["fields_matched_mean"]), _num(row["calls_per_case"]), |
| _num(row["retries_per_case"]), _ms(row["latency_median_ms"])) |
|
|
|
|
| def markdown(rows, sources, infra): |
| overall = [row for row in rows if row["pack"] == "ALL"] |
| total = sum(row["n"] for row in overall) |
| out = ["# stepmold-bench summary", "", |
| "From %s: %d case-runs." % (", ".join("`%s`" % s for s in sources), total), ""] |
| if infra: |
| out += ["%d case-run(s) hit a transport or bench error and have no result yet. " |
| "Run bench.py again with the same arguments to retry them." % len(infra), ""] |
| out += ["## Overall", "", HEADER % "Model", RULE] |
| out += [_line(row["label"], row) for row in overall] |
| for label in sorted(set(row["label"] for row in rows), key=str): |
| out += ["", "## %s, by pack" % label, "", HEADER % "Pack", RULE] |
| packs = sorted(set(row["pack"] for row in rows |
| if row["label"] == label and row["pack"] != "ALL")) |
| for pack in packs: |
| out += [_line(pack, row) for row in rows |
| if row["label"] == label and row["pack"] == pack] |
| out += ["", "## Tokens per case-run", "", |
| "| Model | Arm | Prompt | Completion | Of which reasoning | Median case-run time |", |
| "|---|---|---:|---:|---:|---:|"] |
| for row in overall: |
| out.append("| %s | %s | %s | %s | %s | %s |" % ( |
| row["label"], row["arm"], _num(row["prompt_tokens_per_case"], 0), |
| _num(row["completion_tokens_per_case"], 0), |
| _num(row["reasoning_tokens_per_case"], 0), _ms(row["wall_median_ms"]))) |
| out += ["", "## Top reject reasons", ""] |
| for row in overall: |
| out.append("**%s, %s arm** (%s rejected calls per case-run)" % ( |
| row["label"], row["arm"], _num(row["rejected_calls_per_case"]))) |
| out.append("") |
| if not row["top_reject_reasons"]: |
| out += ["None.", ""] |
| continue |
| out += ["| Calls | Reason |", "|---:|---|"] |
| out += ["| %d | %s |" % (count, reason.replace("|", "\\|")) |
| for reason, count in row["top_reject_reasons"]] |
| out.append("") |
| out += [ |
| "## How to read this", "", |
| "- **Pass rate** is the share of case-runs that `stepmold.eval` scores as passed: " |
| "every expected field matches and, when the case names one, the run reached the " |
| "expected end node. The interval is a Wilson 95% interval that treats every " |
| "case-run as independent. Repeated runs of the same case are not independent, so " |
| "the real interval is wider.", |
| "- **Escalated, not passed**: the case failed, but the run took an `on_fail` or " |
| "`on_unsure` edge on the way, so the workflow itself flagged it. A wrong answer " |
| "that was flagged.", |
| "- **Silently wrong**: the run reached an end node normally, took no escalation " |
| "edge, and the answer did not match the gold case.", |
| "- **Crashed**: the run stopped before any end node (no edge matched, a prompt " |
| "could not be rendered, a node with no `on_fail` spent its retries).", |
| "- Passed, escalated-not-passed, silently wrong and crashed add up to 100%.", |
| "- **Fields matched** is the mean share of a case's expected fields that came back " |
| "right. A crashed run counts as zero.", |
| "- **Calls / case** counts every model request, think passes included. " |
| "**Retries / case** counts stepmold's re-samples after a rejected answer. Gate " |
| "draws are not retries.", |
| "- In the plain arm a \"rejected\" call is one whose reply held no JSON object, so " |
| "nothing was committed. The plain arm never asks again.", |
| "", |
| ] |
| return "\n".join(out) |
|
|
|
|
| def main(argv=None): |
| parser = argparse.ArgumentParser( |
| prog="summarize.py", |
| description="Summarise bench.py results into summary.csv and summary.md.") |
| parser.add_argument("files", nargs="+", help="results JSONL files from bench.py") |
| parser.add_argument("--out-dir", dest="out_dir", default=None, |
| help="where to write summary.csv and summary.md " |
| "(default: the first file's directory)") |
| args = parser.parse_args(argv) |
| missing = [path for path in args.files if not os.path.isfile(path)] |
| if missing: |
| sys.stderr.write("summarize: no such file: %s\n" % ", ".join(missing)) |
| return 2 |
| _, cases, calls, infra = read(args.files) |
| if not cases: |
| sys.stderr.write("summarize: no case records in %s\n" % ", ".join(args.files)) |
| return 1 |
| rows = summarize(cases, calls) |
| out_dir = args.out_dir or os.path.dirname(os.path.abspath(args.files[0])) |
| os.makedirs(out_dir, exist_ok=True) |
| write_csv(rows, os.path.join(out_dir, "summary.csv")) |
| text = markdown(rows, [os.path.basename(path) for path in args.files], infra) |
| with open(os.path.join(out_dir, "summary.md"), "w", encoding="utf-8") as handle: |
| handle.write(text) |
| overall = [row for row in rows if row["pack"] == "ALL"] |
| print(HEADER % "Model") |
| print(RULE) |
| for row in overall: |
| print(_line(row["label"], row)) |
| print("\nwrote %s and %s" % (os.path.join(out_dir, "summary.csv"), |
| os.path.join(out_dir, "summary.md"))) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
