| """Cross-run statistics: what, if anything, separated a good run from a bad one. |
| |
| Accuracy is not comparable across benchmarks -- 0.95 on BFCL and 0.17 on AIME |
| are both ordinary -- so every comparison here works on `z`, the within-task |
| z-score of the final accuracy. A feature that "helps" is one that moves a run |
| up relative to the other runs on *its own* benchmark. |
| |
| With 48 runs over 7 benchmarks these are descriptive, not inferential: n per |
| task is 4-8, so the right reading of any correlation is "worth a look", not |
| "established". Effect sizes are reported alongside n for that reason. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import math |
| from collections import defaultdict |
| from typing import Any, Iterable, Sequence |
|
|
| from .features import RunFeatures |
|
|
| NUMERIC_FEATURES = [ |
| "wall_h", |
| "turns", |
| "tool_calls", |
| "output_tokens", |
| "cost_usd", |
| "thinking_blocks", |
| "thinking_chars", |
| "narration_chars", |
| "n_eval_calls", |
| "n_scored_evals", |
| "n_distinct_model_versions", |
| "first_eval_h", |
| "tail_idle_h", |
| "last_improvement_h", |
| "time_awareness_calls", |
| "tool_errors", |
| "bg_tasks", |
| "max_parallel_bg", |
| "bg_busy_s", |
| "machine_busy_frac", |
| "dead_air_h", |
| "compactions", |
| "api_retries", |
| "mean_eval_limit", |
| "final_message_chars", |
| ] |
|
|
|
|
| def _rank(xs: Sequence[float]) -> list[float]: |
| order = sorted(range(len(xs)), key=lambda i: xs[i]) |
| ranks = [0.0] * len(xs) |
| i = 0 |
| while i < len(order): |
| j = i |
| while j + 1 < len(order) and xs[order[j + 1]] == xs[order[i]]: |
| j += 1 |
| avg = (i + j) / 2 + 1 |
| for k in range(i, j + 1): |
| ranks[order[k]] = avg |
| i = j + 1 |
| return ranks |
|
|
|
|
| def spearman(xs: Sequence[float], ys: Sequence[float]) -> float | None: |
| if len(xs) < 4: |
| return None |
| rx, ry = _rank(xs), _rank(ys) |
| mx, my = sum(rx) / len(rx), sum(ry) / len(ry) |
| num = sum((a - mx) * (b - my) for a, b in zip(rx, ry)) |
| den = math.sqrt(sum((a - mx) ** 2 for a in rx) * sum((b - my) ** 2 for b in ry)) |
| return num / den if den else None |
|
|
|
|
| def within_task_z(feats: Iterable[RunFeatures]) -> dict[str, float]: |
| """Final accuracy, z-scored inside each benchmark. |
| |
| Tasks with a single run get z = 0: there is nothing to be better than. |
| """ |
| by_task: defaultdict[str, list[RunFeatures]] = defaultdict(list) |
| for f in feats: |
| if f.accuracy is not None: |
| by_task[f.task].append(f) |
| z: dict[str, float] = {} |
| for task, group in by_task.items(): |
| accs = [f.accuracy for f in group] |
| m = sum(accs) / len(accs) |
| sd = math.sqrt(sum((a - m) ** 2 for a in accs) / len(accs)) if len(accs) > 1 else 0.0 |
| for f in group: |
| z[f.run_id] = ((f.accuracy - m) / sd) if sd else 0.0 |
| return z |
|
|
|
|
| def feature_correlations(feats: list[RunFeatures]) -> list[dict[str, Any]]: |
| z = within_task_z(feats) |
| rows = [] |
| for name in NUMERIC_FEATURES: |
| pairs = [ |
| (getattr(f, name), z[f.run_id]) |
| for f in feats |
| if f.run_id in z and getattr(f, name, None) is not None |
| ] |
| if len(pairs) < 8: |
| continue |
| rho = spearman([p[0] for p in pairs], [p[1] for p in pairs]) |
| if rho is None: |
| continue |
| rows.append({"feature": name, "rho_vs_within_task_z": round(rho, 3), "n": len(pairs)}) |
| return sorted(rows, key=lambda r: -abs(r["rho_vs_within_task_z"])) |
|
|
|
|
| def technique_effects(feats: list[RunFeatures], min_each: int = 4) -> list[dict[str, Any]]: |
| """Mean within-task z for runs that used a technique vs runs that did not.""" |
| z = within_task_z(feats) |
| names: set[str] = set() |
| for f in feats: |
| names.update(f.techniques) |
| rows = [] |
| for name in sorted(names): |
| with_, without = [], [] |
| for f in feats: |
| if f.run_id not in z: |
| continue |
| (with_ if name in f.techniques else without).append(z[f.run_id]) |
| if len(with_) < min_each or len(without) < min_each: |
| continue |
| rows.append( |
| { |
| "technique": name, |
| "n_with": len(with_), |
| "n_without": len(without), |
| "mean_z_with": round(sum(with_) / len(with_), 3), |
| "mean_z_without": round(sum(without) / len(without), 3), |
| "delta_z": round(sum(with_) / len(with_) - sum(without) / len(without), 3), |
| } |
| ) |
| return sorted(rows, key=lambda r: -r["delta_z"]) |
|
|
|
|
| def per_task_table(feats: list[RunFeatures]) -> list[dict[str, Any]]: |
| by: defaultdict[str, list[RunFeatures]] = defaultdict(list) |
| for f in feats: |
| by[f.task].append(f) |
|
|
| def avg(xs): |
| xs = [x for x in xs if x is not None] |
| return round(sum(xs) / len(xs), 3) if xs else None |
|
|
| rows = [] |
| for task, g in sorted(by.items()): |
| rows.append( |
| { |
| "task": task, |
| "n_runs": len(g), |
| "mean_accuracy": avg([f.accuracy for f in g]), |
| "mean_turns": avg([f.turns for f in g]), |
| "mean_eval_calls": avg([f.n_eval_calls for f in g]), |
| "mean_model_versions": avg([f.n_distinct_model_versions for f in g]), |
| "mean_train_hours": avg([f.action_time_s.get("train", 0) / 3600 for f in g]), |
| "mean_eval_hours": avg([f.action_time_s.get("eval_official", 0) / 3600 for f in g]), |
| "mean_wait_hours": avg([f.action_time_s.get("wait_poll", 0) / 3600 for f in g]), |
| "mean_dead_air_h": avg([f.dead_air_h for f in g]), |
| "mean_busy_frac": avg([f.machine_busy_frac for f in g]), |
| "mean_tail_idle_h": avg([f.tail_idle_h for f in g]), |
| "mean_cost_usd": avg([f.cost_usd for f in g]), |
| "mean_oom_hits": avg([f.error_signals.get("oom", 0) for f in g]), |
| } |
| ) |
| return rows |
|
|
|
|
| def rerun_variance(feats: list[RunFeatures]) -> list[dict[str, Any]]: |
| """Spread between repeated runs of the same (task, base model) cell. |
| |
| This is the noise floor. Any claimed improvement smaller than it is not |
| an improvement, and it bounds what a single-seed sweep can conclude. |
| """ |
| by: defaultdict[tuple[str, str], list[RunFeatures]] = defaultdict(list) |
| for f in feats: |
| if f.accuracy is not None: |
| by[(f.task, f.base_model)].append(f) |
| rows = [] |
| for (task, model), g in sorted(by.items()): |
| if len(g) < 2: |
| continue |
| accs = sorted(f.accuracy for f in g) |
| rows.append( |
| { |
| "task": task, |
| "base_model": model, |
| "n": len(g), |
| "min": round(accs[0], 4), |
| "max": round(accs[-1], 4), |
| "spread": round(accs[-1] - accs[0], 4), |
| "rel_spread": round((accs[-1] - accs[0]) / accs[-1], 3) if accs[-1] else None, |
| } |
| ) |
| return sorted(rows, key=lambda r: -r["spread"]) |
|
|
|
|
| def final_verification(feats: list[RunFeatures]) -> dict[str, Any]: |
| """Did the run end by grading its own submission the way the harness will? |
| |
| The deliverable is `final_model`, and the harness scores it with |
| `evaluate.py` at full sample count. A run that never does that itself is |
| shipping something it has not checked -- a cheap habit with a large |
| downside, so it is worth knowing how often it happens. |
| """ |
| verified, partial, none = [], [], [] |
| for f in feats: |
| late = [ |
| e |
| for e in f.evals |
| if e.model_path |
| and "final_model" in e.model_path |
| and f.wall_h |
| and e.t_rel / 3600 > 0.6 * f.wall_h |
| ] |
| if any(e.limit is None or e.limit >= 150 for e in late): |
| verified.append(f.run_id) |
| elif late: |
| partial.append(f.run_id) |
| else: |
| none.append(f.run_id) |
| n = len(feats) |
| return { |
| "n": n, |
| "verified_at_full_scale": len(verified), |
| "verified_but_subsampled": len(partial), |
| "never_graded_own_submission": len(none), |
| "pct_verified": round(100 * len(verified) / n, 1) if n else None, |
| "never_graded_examples": none[:8], |
| } |
|
|
|
|
| def dev_to_harness_drop(feats: list[RunFeatures]) -> dict[str, Any]: |
| """Best score the agent measured itself vs the score the harness gave it. |
| |
| A systematic positive drop is selection on the development signal: the |
| agent picked whichever checkpoint happened to look best, and a fresh |
| grading pass gives some of that back. |
| """ |
| rows = [] |
| for f in feats: |
| if f.best_observed is None or f.accuracy is None: |
| continue |
| rows.append( |
| { |
| "run_id": f.run_id, |
| "task": f.task, |
| "best_self_measured": round(f.best_observed, 4), |
| "harness": round(f.accuracy, 4), |
| "drop": round(f.best_observed - f.accuracy, 4), |
| } |
| ) |
| drops = [r["drop"] for r in rows] |
| return { |
| "n": len(rows), |
| "mean_drop": round(sum(drops) / len(drops), 4) if drops else None, |
| "median_drop": round(sorted(drops)[len(drops) // 2], 4) if drops else None, |
| "n_overstated": sum(1 for d in drops if d > 0.02), |
| "n_understated": sum(1 for d in drops if d < -0.02), |
| "worst": sorted(rows, key=lambda r: -r["drop"])[:6], |
| } |
|
|
|
|
| def oom_recovery(feats: list[RunFeatures]) -> dict[str, Any]: |
| """How often an out-of-memory failure appears, and whether it ended the run. |
| |
| OOM is the signature failure of this task: one H100, a 4B model, and an |
| agent that has to guess batch size and sequence length. Recovering from |
| it without human help is a capability in its own right. |
| """ |
| hit = [f for f in feats if f.error_signals.get("oom")] |
| return { |
| "runs_with_oom": len(hit), |
| "of": len(feats), |
| "pct": round(100 * len(hit) / len(feats), 1) if feats else None, |
| "mean_oom_events_when_hit": round(sum(f.error_signals["oom"] for f in hit) / len(hit), 2) if hit else None, |
| "all_still_produced_a_model": all(f.accuracy is not None for f in hit), |
| } |
|
|
