| |
| |
| |
| |
| |
| """Standalone grader for the P&W subtask benchmark. Python 3.9+ and numpy only. |
| |
| uv run grade.py --gold gold/rollouts/ --pred predictions/seen-policy/ [--pred baselines/terra-zero-shot/ ...] |
| [--tasks connect-dc-jack,...] [--split test|cross-validation] [--cohort rollout|demo] |
| [--common] [--resamples 1000] [--seg-iou 0.8 | --seg-tol 1] [--out results.json] |
| |
| Files: every *.jsonl under each folder, one episode per line, in P&W's catalog field format: |
| {"source": ..., "episode": ..., "task": ..., "subtasks": [{"startSec", "endSec", "label", "rating"}, ...], ...} |
| Episodes are keyed by (source, episode). Gold lines may also carry "split" and "cohort"; --split / --cohort filter on |
| the gold's values. A predicted line rates a segment "failed" or not; when "rating" is missing, pSuccess < 0.5 means failed. |
| An episode is scored for a predictor when it is in the gold (after the filters) and in that predictor's files. |
| With several --pred folders, deltas against the first are computed on the episodes all of them cover (paired), and |
| --common scores every predictor on that common set only. |
| |
| Rules, applied identically to gold and predictions |
| ------------------------------------------------- |
| 1. Labels. P&W's two sort picks ("Pick up a single black screw from the table." and "... silver screw ...") are scored |
| as one label, "Pick up a single screw from the table." (screw colour is not scored). --keep-colour turns this off. |
| 2. Clean-up of each episode's list of segments, deterministic, in this order: |
| a. segments with endSec <= startSec are dropped; |
| b. segments are sorted by (startSec, endSec); ties keep the file's order; |
| c. exact duplicates (same startSec, endSec and label) are dropped, keeping the first; |
| d. each segment after the first starts where the previous one ends (startSec := previous endSec). This closes gaps |
| (the following segment absorbs them) and resolves overlaps (the earlier segment keeps the overlapping time); |
| a segment left with no time is dropped. |
| Predictions are then clipped to the gold's span [first gold startSec, last gold endSec]. |
| 3. Ratings. Gold "failed" counts as failed; "ok", "excellent" (and a missing rating) count as success. |
| |
| Metrics (pooled over the episodes of a task; the all-tasks row is the unweighted mean of the task values) |
| ------------------------------------------------------------------------------------------------------- |
| - seg-F1@IoU0.8 (segment F1): adjacent segments with the same label are merged into one run (on both sides). This is |
| the standard MS-TCN segmental F1: each predicted run, in time order, claims the unclaimed gold run of the same label |
| with the highest IoU; it is a true positive if that IoU >= 0.8, else a false positive; unclaimed gold runs are false |
| negatives. F1 = 2TP / (2TP + FP + FN). --seg-iou sets a different IoU threshold (the result key keeps its name). |
| - seg-F1@T s (--seg-tol T, replaces the IoU rule; the result key keeps its name): on the same merged runs, a predicted |
| run and a gold run can match if they have the same label and both |start difference| and |end difference| are <= T |
| seconds. Matching is one to one and greedy over all same-label pairs, smallest max(|start diff|, |end diff|) first |
| (ties: lower gold index, then lower predicted index). TP = matched pairs, FP = unmatched predicted runs, FN = unmatched |
| gold runs; F1 as above. This is the same rule as the internal "seg-F1@1 s" metric when T = 1. |
| - Boundary error (s): the boundaries are the change points between consecutive merged runs (episode start and end are not |
| boundaries). Gold and predicted boundaries are matched one to one, closest first, if within 2 s of each other (labels |
| ignored). The metric is the mean absolute time difference of the matched pairs. "boundary recall" is the share of gold |
| boundaries matched, reported beside it so that a low error from few matches is visible; "boundary precision" is the |
| share of predicted boundaries matched to a gold boundary. |
| - Failure F1 / precision / recall (attempt level): attempts are the cleaned segments, NOT merged (a retry is its own |
| attempt). Predicted and gold attempts are matched one to one if they have the same label and IoU >= 0.5, greedily by |
| IoU (ties: lower gold index, then lower predicted index). A predicted failed attempt matched to a gold failed attempt is |
| a true positive; every other predicted failed attempt is a false positive; every other gold failed attempt is a false |
| negative. |
| Output |
| ------ |
| JSON on stdout (or --out FILE), with these top-level keys: |
| - "results": {predictor folder: {task: {metric: {"value", "lo", "hi"}}, "all": {...}}}. Metrics: seg_f1_iou80 (segment |
| F1 at the chosen --seg-iou or --seg-tol), boundary_err_s, boundary_recall, boundary_precision, failed_f1, failed_precision, |
| failed_recall, plus "n" (episodes scored). F1, precision and recall are fractions in [0, 1]; boundary_err_s is in seconds. "lo"/"hi" are the 95% CI. |
| - "deltas": {"<pred> - <first pred>": same layout}, paired differences on the common episodes (only with several --pred). |
| - "results_common": same layout as "results", every predictor scored on the common episodes (with several --pred). |
| - "coverage": {predictor: {task: {"gold", "scored", "common"}}}, episode counts per task. |
| - "episodes": {task: n}, the episodes scored per task (the common set when deltas or --common apply). |
| - "options": the settings used (tasks, split, cohort, resamples, seed, merge_labels, common, seg_iou or seg_tol). |
| |
| Examples |
| -------- |
| uv run grade.py --gold gold/rollouts --pred predictions/seen-policy --split test # our model, test rollouts |
| uv run grade.py --gold gold/rollouts --pred predictions/seen-policy --pred baselines/terra-zero-shot --split test --common |
| uv run grade.py --gold gold/rollouts --pred predictions/new-family # each family held out |
| uv run grade.py --gold gold/rollouts --pred predictions/seen-policy --split test --seg-tol 1 --out tol1.json |
| uv run test_grade.py # unit tests |
| |
| Confidence intervals: 95% percentile intervals from an episode bootstrap (--resamples draws, seeded per task), resampling |
| episodes within each task. Deltas use the same draws for both predictors (paired), on the common episodes. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| import zlib |
| from pathlib import Path |
|
|
| import numpy as np |
|
|
| SORT_PICKS = ("Pick up a single black screw from the table.", "Pick up a single silver screw from the table.") |
| SORT_PICK = "Pick up a single screw from the table." |
| LABEL_GROUPS = {SORT_PICKS[0]: SORT_PICK, SORT_PICKS[1]: SORT_PICK} |
| SEG_IOU = 0.8 |
| FAIL_IOU = 0.5 |
| BOUNDARY_WINDOW = 2.0 |
| TOL = 1e-6 |
| METRICS = ("seg_f1_iou80", "boundary_err_s", "boundary_recall", "boundary_precision", "failed_f1", "failed_precision", "failed_recall") |
| COUNTS = ("seg_tp", "seg_fp", "seg_fn", "b_err", "b_matched", "b_gold", "b_pred", "f_tp", "f_fp", "f_fn") |
|
|
|
|
| def key(line: dict) -> tuple: |
| return (line["source"], line["episode"]) |
|
|
|
|
| def _failed(seg: dict, is_pred: bool) -> bool: |
| rating = seg.get("rating") |
| if rating is None and is_pred and seg.get("pSuccess") is not None: |
| return float(seg["pSuccess"]) < 0.5 |
| return rating == "failed" |
|
|
|
|
| def normalise(subtasks: list, merge_labels: bool = True, is_pred: bool = False) -> list: |
| """[(start, end, label, failed)] after rules 1-2d of the module docstring.""" |
| rows = [] |
| for i, s in enumerate(subtasks): |
| a, b = float(s["startSec"]), float(s["endSec"]) |
| if b - a <= TOL: |
| continue |
| label = LABEL_GROUPS.get(s["label"], s["label"]) if merge_labels else s["label"] |
| rows.append((a, b, i, label, _failed(s, is_pred), s["label"])) |
| rows.sort(key=lambda r: (r[0], r[1], r[2])) |
| seen, out = set(), [] |
| for a, b, _, label, failed, raw in rows: |
| dup = (round(a, 6), round(b, 6), raw) |
| if dup in seen: |
| continue |
| seen.add(dup) |
| if out: |
| a = out[-1][1] |
| if b - a <= TOL: |
| continue |
| out.append((a, b, label, failed)) |
| return out |
|
|
|
|
| def clip(segs: list, lo: float, hi: float) -> list: |
| out = [] |
| for a, b, label, failed in segs: |
| a, b = max(a, lo), min(b, hi) |
| if b - a > TOL: |
| out.append((a, b, label, failed)) |
| return out |
|
|
|
|
| def runs(segs: list) -> list: |
| """Adjacent same-label segments merged: [(start, end, label, any failed)].""" |
| out = [] |
| for a, b, label, failed in segs: |
| if out and out[-1][2] == label: |
| out[-1] = (out[-1][0], b, label, out[-1][3] or failed) |
| else: |
| out.append((a, b, label, failed)) |
| return out |
|
|
|
|
| def _iou(x, y) -> float: |
| inter = min(x[1], y[1]) - max(x[0], y[0]) |
| if inter <= 0: |
| return 0.0 |
| return inter / (max(x[1], y[1]) - min(x[0], y[0])) |
|
|
|
|
| def seg_counts(gold_runs: list, pred_runs: list, threshold: float = SEG_IOU) -> tuple: |
| used = [False] * len(gold_runs) |
| tp = fp = 0 |
| for p in pred_runs: |
| best, index = 0.0, -1 |
| for i, g in enumerate(gold_runs): |
| if g[2] == p[2] and not used[i]: |
| v = _iou(g, p) |
| if v > best: |
| best, index = v, i |
| if index >= 0 and best >= threshold - TOL: |
| used[index] = True |
| tp += 1 |
| else: |
| fp += 1 |
| return tp, fp, used.count(False) |
|
|
|
|
| def seg_counts_tol(gold_runs: list, pred_runs: list, tol: float) -> tuple: |
| pairs = sorted((max(abs(g[0] - p[0]), abs(g[1] - p[1])), i, j) |
| for i, g in enumerate(gold_runs) for j, p in enumerate(pred_runs) if g[2] == p[2]) |
| gi, pj = set(), set() |
| for d, i, j in pairs: |
| if d > tol + TOL: |
| break |
| if i not in gi and j not in pj: |
| gi.add(i) |
| pj.add(j) |
| return len(gi), len(pred_runs) - len(gi), len(gold_runs) - len(gi) |
|
|
|
|
| def boundary_errors(gold_runs: list, pred_runs: list, window: float = BOUNDARY_WINDOW) -> tuple: |
| """(matched absolute errors, number of gold boundaries, number of predicted boundaries).""" |
| g = [r[1] for r in gold_runs[:-1]] |
| p = [r[1] for r in pred_runs[:-1]] |
| pairs = sorted((abs(x - y), i, j) for i, x in enumerate(g) for j, y in enumerate(p) if abs(x - y) <= window + TOL) |
| gi, pj, errors = set(), set(), [] |
| for d, i, j in pairs: |
| if i not in gi and j not in pj: |
| gi.add(i) |
| pj.add(j) |
| errors.append(d) |
| return errors, len(g), len(p) |
|
|
|
|
| def match_attempts(pred: list, gold: list, threshold: float = FAIL_IOU) -> list: |
| pairs = sorted((-_iou(p, g), j, i) for i, p in enumerate(pred) for j, g in enumerate(gold) if p[2] == g[2] and _iou(p, g) >= threshold - TOL) |
| up, ug, out = set(), set(), [] |
| for _, j, i in pairs: |
| if i not in up and j not in ug: |
| up.add(i) |
| ug.add(j) |
| out.append((i, j)) |
| return out |
|
|
|
|
| def episode_counts(gold_line: dict, pred_line: dict, merge_labels: bool = True, seg_iou: float = SEG_IOU, seg_tol: float | None = None) -> dict: |
| gold = normalise(gold_line["subtasks"], merge_labels) |
| if not gold: |
| return None |
| pred = clip(normalise(pred_line["subtasks"], merge_labels, is_pred=True), gold[0][0], gold[-1][1]) |
| gr, pr = runs(gold), runs(pred) |
| tp, fp, fn = seg_counts(gr, pr, seg_iou) if seg_tol is None else seg_counts_tol(gr, pr, seg_tol) |
| errors, n_gold_b, n_pred_b = boundary_errors(gr, pr) |
| flagged = [i for i, a in enumerate(pred) if a[3]] |
| failed = {j for j, a in enumerate(gold) if a[3]} |
| hits = sum(1 for i, j in match_attempts(pred, gold) if pred[i][3] and j in failed) |
| return {"seg_tp": tp, "seg_fp": fp, "seg_fn": fn, "b_err": float(sum(errors)), "b_matched": len(errors), "b_gold": n_gold_b, "b_pred": n_pred_b, |
| "f_tp": hits, "f_fp": len(flagged) - hits, "f_fn": len(failed) - hits} |
|
|
|
|
| def _ratio(a, b): |
| a, b = np.asarray(a, dtype=float), np.asarray(b, dtype=float) |
| with np.errstate(divide="ignore", invalid="ignore"): |
| return np.where(b > 0, a / np.where(b > 0, b, 1), np.nan) |
|
|
|
|
| def metrics_of(c: np.ndarray) -> dict: |
| """c: [..., len(COUNTS)] summed counts -> {metric: array}.""" |
| k = {name: c[..., i] for i, name in enumerate(COUNTS)} |
| return {"seg_f1_iou80": _ratio(2 * k["seg_tp"], 2 * k["seg_tp"] + k["seg_fp"] + k["seg_fn"]), |
| "boundary_err_s": _ratio(k["b_err"], k["b_matched"]), |
| "boundary_recall": _ratio(k["b_matched"], k["b_gold"]), |
| "boundary_precision": _ratio(k["b_matched"], k["b_pred"]), |
| "failed_f1": _ratio(2 * k["f_tp"], 2 * k["f_tp"] + k["f_fp"] + k["f_fn"]), |
| "failed_precision": _ratio(k["f_tp"], k["f_tp"] + k["f_fp"]), |
| "failed_recall": _ratio(k["f_tp"], k["f_tp"] + k["f_fn"])} |
|
|
|
|
| def _draws(task: str, n: int, resamples: int, seed: int) -> np.ndarray: |
| rng = np.random.default_rng([seed, zlib.crc32(task.encode())]) |
| return rng.integers(0, n, size=(resamples, n)) |
|
|
|
|
| def _summary(point: float, draws) -> dict: |
| out = {"value": None if point is None or np.isnan(point) else float(point)} |
| if draws is not None: |
| d = np.asarray(draws, dtype=float) |
| d = d[~np.isnan(d)] |
| out["lo"] = float(np.percentile(d, 2.5)) if len(d) else None |
| out["hi"] = float(np.percentile(d, 97.5)) if len(d) else None |
| return out |
|
|
|
|
| def grade_lines(gold_lines: list, preds: dict, tasks: list | None = None, split: str | None = None, cohort: str | None = None, |
| resamples: int = 1000, seed: int = 0, merge_labels: bool = True, common: bool = False, seg_iou: float = SEG_IOU, |
| seg_tol: float | None = None) -> dict: |
| """preds: {name: [lines]}, the first is the reference for deltas. Returns {"coverage", "results": {name: {task: {metric: {value, lo, hi}}, "all": ...}}, |
| "deltas": {name: {task: {metric: ...}}}, "episodes"}.""" |
| gold = {} |
| for x in gold_lines: |
| if tasks and x["task"] not in tasks: |
| continue |
| if split and x.get("split") != split: |
| continue |
| if cohort and x.get("cohort") != cohort: |
| continue |
| if key(x) in gold: |
| raise ValueError(f"duplicate gold episode {key(x)}") |
| gold[key(x)] = x |
| by_pred = {} |
| for name, lines in preds.items(): |
| d = {} |
| for x in lines: |
| if key(x) in d: |
| raise ValueError(f"{name}: duplicate predicted episode {key(x)}") |
| d[key(x)] = x |
| by_pred[name] = d |
| names = list(by_pred) |
| task_list = sorted({x["task"] for x in gold.values()}) |
| common_keys = {t: sorted(k for k, x in gold.items() if x["task"] == t and all(k in by_pred[n] for n in names)) for t in task_list} |
| out = {"coverage": {}, "results": {}, "deltas": {}, "episodes": {}, "options": {"tasks": tasks, "split": split, "cohort": cohort, "resamples": resamples, |
| "seed": seed, "merge_labels": merge_labels, "common": common, |
| "seg_iou": seg_iou}} |
| if seg_tol is not None: |
| out["options"]["seg_tol"] = seg_tol |
| counts_cache = {} |
|
|
| def counts(name, keys): |
| rows = [] |
| for k in keys: |
| ck = (name, k) |
| if ck not in counts_cache: |
| c = episode_counts(gold[k], by_pred[name][k], merge_labels, seg_iou, seg_tol) |
| counts_cache[ck] = None if c is None else [c[n] for n in COUNTS] |
| if counts_cache[ck] is not None: |
| rows.append(counts_cache[ck]) |
| return np.asarray(rows, dtype=float).reshape(-1, len(COUNTS)) |
|
|
| def score(name, keys_by_task): |
| res, draws_by_task = {}, {} |
| for t in task_list: |
| keys = keys_by_task[t] |
| c = counts(name, keys) |
| if not len(c): |
| continue |
| point = metrics_of(c.sum(0)) |
| draws = None |
| if resamples: |
| idx = _draws(t, len(c), resamples, seed) |
| draws = metrics_of(c[idx].sum(1)) |
| draws_by_task[t] = draws |
| res[t] = {m: _summary(point[m], None if draws is None else draws[m]) for m in METRICS} |
| res[t]["n"] = len(c) |
| if res: |
| res["all"] = {m: _summary(float(np.nanmean([res[t][m]["value"] if res[t][m]["value"] is not None else np.nan for t in res])), |
| np.nanmean(np.stack([draws_by_task[t][m] for t in draws_by_task]), axis=0) if resamples and draws_by_task else None) for m in METRICS} |
| res["all"]["n"] = sum(res[t]["n"] for t in task_list if t in res) |
| res["all"]["tasks"] = sum(1 for t in task_list if t in res) |
| return res, draws_by_task |
|
|
| for name in names: |
| own = {t: sorted(k for k, x in gold.items() if x["task"] == t and k in by_pred[name]) for t in task_list} |
| out["coverage"][name] = {t: {"gold": sum(1 for x in gold.values() if x["task"] == t), "scored": len(own[t]), "common": len(common_keys[t])} for t in task_list} |
| out["results"][name], _ = score(name, common_keys if common else own) |
| out["episodes"] = {t: len(common_keys[t]) for t in task_list} |
| if len(names) > 1: |
| ref_point = {} |
| ref_draws = {} |
| for name in names: |
| res, dr = score(name, common_keys) |
| ref_point[name], ref_draws[name] = res, dr |
| base = names[0] |
| for name in names[1:]: |
| delta = {} |
| for t in task_list: |
| if t not in ref_point[name] or t not in ref_point[base]: |
| continue |
| delta[t] = {} |
| for m in METRICS: |
| a, b = ref_point[name][t][m]["value"], ref_point[base][t][m]["value"] |
| d = None if a is None or b is None else a - b |
| dd = (ref_draws[name][t][m] - ref_draws[base][t][m]) if resamples else None |
| delta[t][m] = _summary(np.nan if d is None else d, dd) |
| delta[t]["n"] = ref_point[name][t]["n"] |
| if delta: |
| ts = [t for t in task_list if t in delta] |
| delta["all"] = {} |
| for m in METRICS: |
| vals = [delta[t][m]["value"] for t in ts if delta[t][m]["value"] is not None] |
| dd = np.nanmean(np.stack([ref_draws[name][t][m] - ref_draws[base][t][m] for t in ts]), axis=0) if resamples else None |
| delta["all"][m] = _summary(float(np.mean(vals)) if vals else np.nan, dd) |
| delta["all"]["n"] = sum(delta[t]["n"] for t in ts) |
| out["deltas"][f"{name} - {base}"] = delta |
| out["results_common"] = {n: ref_point[n] for n in names} |
| return out |
|
|
|
|
| def read_folder(path: str) -> list: |
| p = Path(path) |
| files = sorted(p.rglob("*.jsonl")) if p.is_dir() else [p] |
| lines = [] |
| for f in files: |
| with open(f) as fh: |
| lines += [json.loads(x) for x in fh if x.strip()] |
| return lines |
|
|
|
|
| def _fmt(s: dict, metric: str) -> str: |
| if s.get("value") is None: |
| return "-" |
| scale, digits = (1, 2) if metric == "boundary_err_s" else (100, 1) |
| v = f"{s['value'] * scale:.{digits}f}" |
| if s.get("lo") is not None: |
| v += f" [{s['lo'] * scale:.{digits}f}, {s['hi'] * scale:.{digits}f}]" |
| return v |
|
|
|
|
| def main(argv=None): |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| ap.add_argument("--gold", required=True) |
| ap.add_argument("--pred", required=True, action="append", help="a predictions folder or file; repeat to compare (deltas against the first)") |
| ap.add_argument("--tasks", default="", help="comma-separated task names (default: all in the gold)") |
| ap.add_argument("--split", default=None, help="test or cross-validation (the gold's split field)") |
| ap.add_argument("--cohort", default=None, help="rollout or demo (the gold's cohort field)") |
| ap.add_argument("--common", action="store_true", help="score every predictor on the episodes all of them cover") |
| ap.add_argument("--resamples", type=int, default=1000) |
| ap.add_argument("--seed", type=int, default=0) |
| ap.add_argument("--seg-iou", type=float, default=SEG_IOU, help="IoU threshold for segment F1 (default 0.8)") |
| ap.add_argument("--seg-tol", type=float, default=None, metavar="SECONDS", |
| help="segment F1 with a boundary tolerance in seconds instead of the IoU rule (see the docstring)") |
| ap.add_argument("--keep-colour", action="store_true", help="score the black and silver sort picks as different labels") |
| ap.add_argument("--out", default=None, help="write the JSON results to this file instead of stdout") |
| a = ap.parse_args(argv) |
| preds = {p.rstrip("/"): read_folder(p) for p in a.pred} |
| res = grade_lines(read_folder(a.gold), preds, [t for t in a.tasks.split(",") if t] or None, a.split, a.cohort, a.resamples, a.seed, not a.keep_colour, a.common, a.seg_iou, a.seg_tol) |
| text = json.dumps(res, indent=1) |
| if a.out: |
| Path(a.out).write_text(text + "\n") |
| else: |
| print(text) |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
