File size: 5,169 Bytes
32030e4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 | """Aggregate scored predictions: per family, macro and micro means, bootstrap CIs, calibration."""
from __future__ import annotations
import random
from collections import defaultdict
from statistics import mean
INTERVAL_FAMILIES = ("estimation", "operating_point_transfer", "evidence_budget_transfer")
INTERVAL_FIELDS = ("dT_max_K", "coolant_rise_K", "dP_kPa")
def _number(value) -> bool:
return isinstance(value, (int, float)) and not isinstance(value, bool)
def interval_hits(task: dict, parsed: dict | None) -> dict:
"""Per answer field: 1 if the interval holds the truth, 0 if not, None if no usable interval."""
if task["family"] not in INTERVAL_FAMILIES:
return {}
hits: dict = {}
for field in INTERVAL_FIELDS:
truth = (task.get("answer") or {}).get(field)
if not _number(truth):
continue
interval = (parsed or {}).get(field)
usable = isinstance(interval, (list, tuple)) and len(interval) == 2 and all(map(_number, interval))
hits[field] = int(min(interval) <= truth <= max(interval)) if usable else None
return hits
def interval_coverage(rows: list[dict]) -> dict:
"""Share of stated intervals holding the truth, overall and by family. The target is 90%."""
by_family: dict = defaultdict(list)
for row in rows:
by_family[row["family"]].extend((row.get("interval_hits") or {}).values())
def describe(values: list) -> dict:
stated = [value for value in values if value is not None]
return {"intervals": len(stated), "missing": len(values) - len(stated),
"coverage": round(mean(stated), 4) if stated else None}
every = [value for values in by_family.values() for value in values]
return {"target": 0.9, **describe(every),
"by_family": {family: describe(values) for family, values in sorted(by_family.items()) if values}}
def _macro(rows: list[dict]) -> float:
by_family = defaultdict(list)
for row in rows:
by_family[row["family"]].append(row["score"])
return mean(mean(values) for values in by_family.values())
def usage_totals(rows: list[dict], input_price: float | None, output_price: float | None,
*, tasks: int) -> dict:
"""Token totals and list-price cost (prices per million tokens, no cache or batch discount).
Output tokens include thinking. Calls that failed outright report no usage, so a run with
errors can cost more than this says.
"""
usages = [row.get("usage") or {} for row in rows]
input_tokens = sum(usage.get("prompt_tokens", 0) for usage in usages)
output_tokens = sum(usage.get("completion_tokens", 0) for usage in usages)
cost = None
if input_price is not None and output_price is not None:
cost = (input_tokens * input_price + output_tokens * output_price) / 1e6
return {
"input_tokens": input_tokens,
"output_tokens": output_tokens,
"input_price_per_million": input_price,
"output_price_per_million": output_price,
"cost_usd": None if cost is None else round(cost, 4),
"cost_per_task_usd": None if cost is None or not tasks else round(cost / tasks, 4),
}
def summarise(rows: list[dict], *, bootstrap: int = 1000, seed: int = 0) -> dict:
"""``rows``: one per (task, sample) with family, score, calibration_sq_error and tags.
The headline is the macro mean (each family weighted equally) because family sizes
differ; samples of the same task are averaged before bootstrapping over tasks.
"""
if not rows:
return {"n": 0}
per_task = defaultdict(list)
for row in rows:
per_task[(row["task_id"], row["family"])].append(row)
task_rows = [{"task_id": tid, "family": fam, "score": mean(r["score"] for r in rs),
"regime": (rs[0].get("tags") or {}).get("regime")}
for (tid, fam), rs in per_task.items()]
rng = random.Random(seed)
draws = sorted(_macro([rng.choice(task_rows) for _ in task_rows]) for _ in range(bootstrap))
families = defaultdict(list)
for row in task_rows:
families[row["family"]].append(row["score"])
regimes = defaultdict(list)
for row in task_rows:
if row["regime"]:
regimes[row["regime"]].append(row["score"])
calibration = [r["calibration_sq_error"] for r in rows if r.get("calibration_sq_error") is not None]
return {
"n_tasks": len(task_rows),
"n_samples": len(rows),
"macro_mean": round(_macro(task_rows), 4),
"macro_mean_95ci": [round(draws[int(0.025 * bootstrap)], 4), round(draws[int(0.975 * bootstrap) - 1], 4)],
"micro_mean": round(mean(r["score"] for r in task_rows), 4),
"by_family": {f: {"n": len(v), "mean": round(mean(v), 4)} for f, v in sorted(families.items())},
"by_regime": {k: {"n": len(v), "mean": round(mean(v), 4)} for k, v in sorted(regimes.items())},
"calibration_mse": round(mean(calibration), 4) if calibration else None,
"interval_coverage": interval_coverage(rows),
"unparsed_rate": round(sum(1 for r in rows if r.get("parsed") is None) / len(rows), 4),
}
|