From e38b6c344b7a618545166920c4bf334b96de3314 Mon Sep 17 00:00:00 2001 From: Lilleman auf Larv Date: Sun, 22 Nov 2026 16:52:54 +0100 Subject: [PATCH] Print the mean of the bugs' own changes as task-bench's All change --- bin/task_bench/figures.py | 33 +++++++++++++++++++++++---------- bin/task_bench/main.py | 9 +++++---- bin/task_bench/test_figures.py | 19 +++++++++++++++++++ docs/decisions.md | 8 ++++---- docs/reading-cost.md | 17 +++++++++++++++++ 5 files changed, 68 insertions(+), 18 deletions(-) diff --git a/bin/task_bench/figures.py b/bin/task_bench/figures.py index 59875e22..4a2ac957 100644 --- a/bin/task_bench/figures.py +++ b/bin/task_bench/figures.py @@ -69,10 +69,12 @@ def reads_before(calls: list[ToolCall], bug_file: str) -> int | None: def table(results: list[Result], tasks: dict[int, str]) -> list[str]: """A row per task and side, then one per side over every task, then the head's change against the base. Each figure is the - median over the side's runs that have figures, and Reads over those that opened the bug's file.""" - rows = [row(f"{task}: {tasks[task]}", side, [result for result in results if (result.task, result.side) == (task, side)]) for task in sorted(tasks) for side in SIDES] + median over the side's runs that have figures, and Reads over those that opened the bug's file. The change is not the + difference of the two All rows: it is the mean of the bugs' own changes.""" + sides = {(task, side): [result for result in results if (result.task, result.side) == (task, side)] for task in tasks for side in SIDES} + rows = [row(f"{task}: {tasks[task]}", side, sides[task, side]) for task in sorted(tasks) for side in SIDES] base, head = ([result for result in results if result.side == side] for side in SIDES) - return [*HEADER, *rows, row("All", "base", base), row("All", "head", head), change(base, head)] + return [*HEADER, *rows, row("All", "base", base), row("All", "head", head), change(base, head, [(sides[task, "base"], sides[task, "head"]) for task in sorted(tasks)])] def medians(results: list[Result]) -> list[float | None]: @@ -95,15 +97,26 @@ def row(task: str, side: str, results: list[Result]) -> str: return cells([task, side, passed, *("-" if median is None else number(median) for median in medians(results))]) -def change(base: list[Result], head: list[Result]) -> str: - """The head's row less the base's: a count as the difference, and tokens and wall time as that difference's share of the base's.""" +def change(base: list[Result], head: list[Result], bugs: list[tuple[list[Result], list[Result]]]) -> str: + """The head's change against the base: the pass count as the difference over every run, and each other figure as the mean + over the bugs of that bug's own change, which is its head median less its base median. Tokens and wall time show it as a share + of the base's median, turns and reads as a count. A bug whose either side lacks the figure, or whose base median is zero where + a share is shown, doesn't count towards that figure's mean. The mean of the bugs' changes swings less than the change of + the All rows' medians, which lands in whichever bug's runs sit in the middle of the pooled costs.""" passed = sum(result.passed for result in head) - sum(result.passed for result in base) - pairs = list(zip(medians(base), medians(head))) - shares = [None if was is None or now is None or not was else f"{number(round(100 * (now - was) / was), signed=True)} %" for was, now in pairs] - counts = [None if was is None or now is None else number(now - was, signed=True) for was, now in pairs] + pairs = [list(zip(medians(was), medians(now))) for was, now in bugs] # Turns and reads are small counts, where a share misleads. - mixed = [*shares[:4], counts[4], shares[5], counts[6]] - return cells(["All", "change", number(passed, signed=True), *(found or "-" for found in mixed)]) + means = [mean_change(column, share=index not in (4, 6)) for index, column in enumerate(zip(*pairs))] if pairs else [None] * 7 + return cells(["All", "change", number(passed, signed=True), *(found or "-" for found in means)]) + + +def mean_change(pairs: tuple[tuple[float | None, float | None], ...], share: bool) -> str | None: + """The mean over the (base, head) medians of one figure, one pair per bug; None where no bug has both.""" + changes = [(now - was) * (100 / was if share else 1) for was, now in pairs if was is not None and now is not None and (was or not share)] + if not changes: + return None + mean = statistics.mean(changes) + return f"{number(round(mean), signed=True)} %" if share else number(mean, signed=True) def number(value: float, signed: bool = False) -> str: diff --git a/bin/task_bench/main.py b/bin/task_bench/main.py index 0cb3e4f4..c6e1c591 100644 --- a/bin/task_bench/main.py +++ b/bin/task_bench/main.py @@ -36,7 +36,8 @@ example: It prints the base and the head, then a table: a row per bug and side with how many fixes passed and the medians, over the runs that finished, of the input, cache-write, cache-read and output tokens, the turns, the wall time, and the reads and searches before the run first opened the file the bug is in. The median of the reads leaves out a run that never opened that file. Then come a row -per side over every bug, and the head's change against the base. The last line names the bench's folder: `task-bench` in the +per side over every bug, and the head's change against the base: the pass count's difference, and for each other column the mean over +the bugs of that bug's own change, which isn't the difference of the two rows above it. The last line names the bench's folder: `task-bench` in the chunk's review folder. That folder holds each run's result and stream, and digest.md, which says why runs failed in a few kilobytes per bug: @@ -46,9 +47,9 @@ That folder holds each run's result and stream, and digest.md, which says why ru passing run with the median tokens. A trace has a line per tool call, such as `Read pick.go:120-180` or `Grep "readName" → 4 hits`, and the first 3 lines of what Haiku wrote between calls. -Read a change against the noise. With the defaults, a bench of a commit against itself shows, in 19 cases of 20, an All row change -under 31% in output tokens, 50% in cache-read tokens and 21% in wall time. The mean of the bugs' own changes, which you work out -from the bug rows, stays under 12%, 16% and 10%. On `fejkdata`'s bugs every run passed, so the pass rate's noise is unmeasured. +Read a change against the noise. With the defaults, a bench of a commit against itself shows, in 19 cases of 20, a change under +12% in output tokens, 16% in cache-read tokens and 10% in wall time. On `fejkdata`'s bugs every run passed, so the pass rate's noise +is unmeasured. `docs/decisions.md` → `task-bench: a bench takes` has the figures. `task-bench gather`, run in the same checkout, turns the digest into plan items. It starts a claude on the project's rung, the diff --git a/bin/task_bench/test_figures.py b/bin/task_bench/test_figures.py index f46faff4..453a64b5 100644 --- a/bin/task_bench/test_figures.py +++ b/bin/task_bench/test_figures.py @@ -102,6 +102,25 @@ class TableTest(unittest.TestCase): results = [run(1, "base", 1, True, input_=0, turns=10, seconds=60, reads=0), run(1, "head", 1, False, input_=50, turns=12, seconds=120, reads=2)] self.assertEqual(table(results, {1: "calc.go:4:7 ARITHMETIC_BASE"})[-1], "| All | change | -1 | - | 0 % | 0 % | 0 % | +2 | +100 % | +2 |") + def test_the_change_is_the_mean_of_the_bugs_own_changes_not_the_change_of_the_pooled_medians(self): + results = [ + run(1, "base", 1, True, input_=100, turns=10, seconds=60, reads=3), run(1, "head", 1, True, input_=200, turns=14, seconds=90, reads=5), + run(2, "base", 1, True, input_=1000, turns=20, seconds=60, reads=7), run(2, "head", 1, True, input_=1000, turns=20, seconds=60, reads=7), + ] + rows = table(results, {1: "calc.go:4:7 ARITHMETIC_BASE", 2: "pick.go:9:3 ARITHMETIC_BASE"}) + self.assertEqual(rows[-3:], [ + "| All | base | 2/2 | 550 | 1000 | 5000 | 400 | 15 | 60 | 5 |", + "| All | head | 2/2 | 600 | 1000 | 5000 | 400 | 17 | 75 | 6 |", + "| All | change | 0 | +50 % | 0 % | 0 % | 0 % | +2 | +25 % | +1 |", + ]) + + def test_a_bug_whose_base_measured_zero_is_left_out_of_the_mean_share(self): + results = [ + run(1, "base", 1, True, input_=0), run(1, "head", 1, True, input_=50), + run(2, "base", 1, True, input_=100), run(2, "head", 1, True, input_=150), + ] + self.assertEqual(table(results, {1: "a.go:1:1 ARITHMETIC_BASE", 2: "b.go:1:1 ARITHMETIC_BASE"})[-1].split(" | ")[3], "+50 %") + def test_a_run_without_figures_counts_as_not_passed_and_a_side_without_any_shows_a_dash(self): results = [Result(1, "base", 1, False, None), run(1, "head", 1, True)] self.assertEqual(table(results, {1: "calc.go:4:7 ARITHMETIC_BASE"})[2:], [ diff --git a/docs/decisions.md b/docs/decisions.md index eb24af45..e070920a 100644 --- a/docs/decisions.md +++ b/docs/decisions.md @@ -825,14 +825,14 @@ Valid while Claude Code loads `~/.claude/rules/*.md` in every project, a path-sc **Defaults stay 5 bugs and 5 runs.** A sixth run per side cuts the spread of the mean of the bugs' cache-read changes from 16% to 13% for 10 more runs, about 35 minutes. -**A chunk-sized change doesn't rise above the noise.** PR #490 moved the medians by 5% to 9%. The spread at 5 × 6, the largest count measured, is 11% to 13%. It falls with the square root of the runs, so seeing a 9% change takes about 13 runs per side and bug: 130 runs, 8 hours and 70M cache-read tokens. No chunk waits that long. The bench shows a change of more than about 15% in tokens, if you work out the mean of the bugs' own changes from its bug rows. The All row it prints needs more than 31% in output tokens and 50% in cache-read tokens. What to try is filed as items 514 (print the mean of the bugs' changes, which has a third to half of the All row's spread in tokens), 515 (plant bugs Haiku fails at the base, so the pass rate moves) and 516 (measure the spread of the reads and the turns, which are counts, not token sums). +**A chunk-sized change doesn't rise above the noise.** PR #490 moved the medians by 5% to 9%. The spread at 5 × 6, the largest count measured, is 11% to 13%. It falls with the square root of the runs, so seeing a 9% change takes about 13 runs per side and bug: 130 runs, 8 hours and 70M cache-read tokens. No chunk waits that long. The bench shows a change of more than about 15% in tokens. Its All change is the mean of the bugs' own changes (item 514); the change of the pooled medians, which it printed before, needed more than 31% in output tokens and 50% in cache-read tokens. What to try is filed as items 515 (plant bugs Haiku fails at the base, so the pass rate moves) and 516 (measure the spread of the reads and the turns, which are counts, not token sums). **Pilot first.** A new setup, or a project the bench hasn't run on, runs 2 bugs × 2 runs before a full bench (lilleman, 2026-11-21). A pilot takes about 40 minutes. The first pilot of this calibration passed no run, because the API refused a token that held a line break. It showed that within 15 minutes, where a full bench would have planted for 25 minutes first and printed the same. Measured on `fejkdata` (Go, 5 bugs planted in the files `larv-review places` names, seed 1, Haiku at low effort), 2026-11-21: -- **Same commit at both sides** (head `c7dd7e15`, 5 bugs × 6 runs, after a pilot of 2 bugs × 2 runs): all 68 runs passed, as did the 30 counted chunk runs below, 98 in all. So the pass rate's spread is zero and it can't show a change of any size, though it is unmeasured on harder bugs. The All row's change was -5% in output tokens, -12% in cache-read tokens and -15% in wall time. -- **Spread by bugs × runs.** Each bug's 12 runs were split at random into two sides 4,000 times. Each cell is the 95th percentile of the change's size, in percent, first for the All row's change as the bench prints it, then for the mean of the bugs' own changes: +- **Same commit at both sides** (head `c7dd7e15`, 5 bugs × 6 runs, after a pilot of 2 bugs × 2 runs): all 68 runs passed, as did the 30 counted chunk runs below, 98 in all. So the pass rate's spread is zero and it can't show a change of any size, though it is unmeasured on harder bugs. The pooled change was -5% in output tokens, -12% in cache-read tokens and -15% in wall time. +- **Spread by bugs × runs.** Each bug's 12 runs were split at random into two sides 4,000 times. Each cell is the 95th percentile of the change's size, in percent, first for the change of the All rows' pooled medians, which the bench printed before item 514, then for the mean of the bugs' own changes, which it prints now: | Bugs × runs | Output tokens | Cache-read tokens | Wall time | |---|---|---|---| @@ -842,7 +842,7 @@ Measured on `fejkdata` (Go, 5 bugs planted in the files `larv-review places` nam | 5 × 6 | 28 / 11 | 43 / 13 | 19 / 8.5 | | 3 × 6 | 28 / 14 | 40 / 17 | 16 / 12 | - The All row pools every run, so its median lands in whichever bug's runs sit in the middle of the pooled costs, and a bug's cost differs from another's by up to 8×. In tokens, the mean of the bugs' changes has a third to half of the All row's spread. In wall time it gains only from 5 × 5. The 86 at 5 × 3 wasn't traced. For the mean of the bugs' token changes, 5 × 4 and 3 × 6 give the same spread (14 and 14, 18 and 17) for 40 and 36 runs. + The All rows pool every run, so their median lands in whichever bug's runs sit in the middle of the pooled costs, and a bug's cost differs from another's by up to 8×. In tokens, the mean of the bugs' changes has a third to half of the pooled change's spread. The bench keeps the pooled All rows per side, which cost nothing, and prints the mean as the All change. In wall time it gains only from 5 × 5. The 86 at 5 × 3 wasn't traced. For the mean of the bugs' token changes, 5 × 4 and 3 × 6 give the same spread (14 and 14, 18 and 17) for 40 and 36 runs. - **One finished chunk**: `fejkdata`'s PR #490, base `33b7fa80`, head `5b9c2a14`, which the comprehension panel ruled better on Navigation, Locality and Shape and the same on Self-sufficiency. The bench planted 5 bugs and ran 38 of 50 runs before the machine restarted. The first 3 runs per bug and side, 30 runs, are the ones counted, and all passed. The mean of the bugs' changes was +4.6% in output tokens, +8.9% in cache-read tokens and +3.8% in turns, with the bugs' own changes in cache-read tokens from -41% to +47%. The two token figures sit inside the spread at 5 × 3, 17% and 22%; the spread of the turns wasn't measured. The mean of the wall times' changes, +105%, lies above the 86% of that row, from one bug whose head runs took 6.8 times as long at the median. Nobody read its streams to find out why. The head cost slightly more tokens where the panel finds it easier to read, and the wall time can't be judged, so the bench neither confirmed nor contradicted the panel. - **Cost**: 5 bugs × 6 runs took 3.9 hours and 34M cache-read, 1.2M cache-write and 0.3M output tokens; a run takes about 3.5 minutes, and planting 16 to 25 minutes. A 5 × 5 bench is about 3.3 hours and 28M cache-read tokens. Gremlins ran out of 8 GB at the base of PR #490, so the help's example takes 16 GB. diff --git a/docs/reading-cost.md b/docs/reading-cost.md index d3aa0268..556f696c 100644 --- a/docs/reading-cost.md +++ b/docs/reading-cost.md @@ -3384,3 +3384,20 @@ Read most (opens and searches): - `bin/reading_cost/measure.py` 2 - `bin/review_rules/review_folder.py` 2 - `bin/task_bench/figures.py` 2 + +## Reading cost, chunk 666aabdd77a8, finished 2026-11-22T15:50:09Z + +283046 new input tokens before the first commit. + +Read most (opens and searches): + +- `docs/decisions.md` 14 +- `bin/task_bench/main.py` 9 +- `bin/task_bench/figures.py` 4 +- `bin/task_bench/plant.py` 4 +- `bin/task_bench/test_figures.py` 4 +- `bin/task_bench/runs.py` 3 +- `CHANGELOG.md` 2 +- `README.md` 2 +- `docs/comprehension-history.md` 2 +- `docs/score-anchors.md` 2