File size: 2,781 Bytes
99e41a8
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""Success-rate statistics for robot evaluations.

Results files are JSONL, one episode per line:
  {"run": "groot17_libero", "suite": "libero_spatial", "task": 3, "seed": 0, "success": true}

Usage:
  python -m robotics.eval.stats results/*.jsonl            # per run/suite table
  python -m robotics.eval.stats results/a.jsonl results/b.jsonl --compare RUN_A RUN_B
"""
from __future__ import annotations

import argparse
import json
import math
from collections import defaultdict
from pathlib import Path


def wilson(k: int, n: int, z: float = 1.96) -> tuple[float, float]:
    """95% Wilson score interval for k successes out of n."""
    if n == 0:
        return (0.0, 1.0)
    p = k / n
    denom = 1 + z * z / n
    centre = (p + z * z / (2 * n)) / denom
    half = z * math.sqrt(p * (1 - p) / n + z * z / (4 * n * n)) / denom
    return (max(0.0, centre - half), min(1.0, centre + half))


def compare(k1: int, n1: int, k2: int, n2: int) -> dict:
    """Two-proportion z-test (pooled). Returns diff, z and two-sided p-value."""
    p1, p2 = k1 / n1, k2 / n2
    pooled = (k1 + k2) / (n1 + n2)
    se = math.sqrt(pooled * (1 - pooled) * (1 / n1 + 1 / n2))
    z = (p2 - p1) / se if se > 0 else 0.0
    pval = math.erfc(abs(z) / math.sqrt(2))
    return {"diff": p2 - p1, "z": z, "p_value": pval}


def load(paths: list[str]) -> list[dict]:
    rows = []
    for p in paths:
        for line in Path(p).read_text().splitlines():
            if line.strip():
                rows.append(json.loads(line))
    return rows


def summarize(rows: list[dict]) -> dict[tuple[str, str], tuple[int, int]]:
    agg: dict[tuple[str, str], list[int]] = defaultdict(lambda: [0, 0])
    for r in rows:
        key = (r.get("run", "?"), r.get("suite", "all"))
        agg[key][0] += bool(r["success"])
        agg[key][1] += 1
    return {k: (v[0], v[1]) for k, v in agg.items()}


def main(argv: list[str] | None = None) -> None:
    ap = argparse.ArgumentParser()
    ap.add_argument("files", nargs="+")
    ap.add_argument("--compare", nargs=2, metavar=("RUN_A", "RUN_B"))
    a = ap.parse_args(argv)
    summ = summarize(load(a.files))
    print(f"{'run':30} {'suite':18} {'n':>5} {'success':>8}  95% CI")
    for (run, suite), (k, n) in sorted(summ.items()):
        lo, hi = wilson(k, n)
        print(f"{run:30} {suite:18} {n:5d} {k / n:8.1%}  [{lo:.1%}, {hi:.1%}]")
    if a.compare:
        tot = defaultdict(lambda: [0, 0])
        for (run, _), (k, n) in summ.items():
            tot[run][0] += k
            tot[run][1] += n
        (k1, n1), (k2, n2) = tot[a.compare[0]], tot[a.compare[1]]
        c = compare(k1, n1, k2, n2)
        print(f"\n{a.compare[1]} - {a.compare[0]}: {c['diff']:+.1%}  z={c['z']:.2f}  p={c['p_value']:.4f}")


if __name__ == "__main__":
    main()