| |
| """Recompute tab:planner-transfer from the frozen planner table. No GPU, no checkpoints. |
| |
| python reproduce/planner/planner_tables.py |
| python reproduce/planner/planner_tables.py --latex |
| |
| Everything comes from `planner_cells.csv`: 36 checkpoints, the planner-independent metrics, one |
| sobriety per probe family, and one success rate per planner. |
| |
| This experiment is deliberately separate from the pools of `reproduce/tables.py`. Every planner |
| arm must be evaluated on the SAME checkpoints for the comparison to be paired, so it uses a fixed |
| 36-checkpoint set: all 25 of its training runs also appear in the main pools, 20 of the 36 are |
| themselves cells of the development or held-out pool, and the other 16 are further epochs of those |
| same runs. It is therefore a subset of the paper's runs rather than of its reported checkpoints, |
| and these numbers are not comparable to `reproduce/tables.py`'s. |
| |
| Sobriety is the one factor containing a search, so each planner needs a probe. The assignment is |
| fixed by a rule declared before any outcome was seen -- same search family, matched budget |
| fraction -- not by whichever probe correlates best. Under the declared rule predictive sampling |
| scores +0.51; under the probe that would have flattered it, +0.80. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| from pathlib import Path |
|
|
| import numpy as np |
| from scipy.stats import spearmanr |
| from sklearn.isotonic import IsotonicRegression |
|
|
| GRADED = ("pusht", "dmc", "tworoom") |
| NAME = {"pusht": "PushT", "dmc": "Reacher", "tworoom": "Two-Room"} |
| NUM_EVAL = 50 |
| |
| PLANNERS = [("cem", "mcem", "CEM (300 samples; 30/10/10 iterations)"), |
| ("mppi", "mcem", "MPPI (300 samples, 10 iterations, softmax tau=0.5)"), |
| ("icem", "mcem", "iCEM (300 samples, 10 iterations, colored noise beta=2)"), |
| ("ps", "mcem", "predictive sampling (300 samples, 1 iteration)"), |
| ("ms", "madam", "gradient (AdamW, 100 initialisations, 30 steps)"), |
| ("ss", "ss", "single-start gradient (AdamW, 1 initialisation, 100 steps)")] |
| ROWS = [("straightness", "Straightness"), ("probe_r2", "Physical-state probe (R2)"), |
| ("m_emp", "Empowerment m_emp"), ("veracity", " veracity"), |
| ("influence", " influence"), ("sobriety", " sobriety"), ("vis", "VIScore")] |
|
|
|
|
| def load(path: Path) -> list[dict]: |
| out = [] |
| for r in csv.DictReader(open(path)): |
| d = {k: (float(v) if v not in ("", "nan") else np.nan) |
| for k, v in r.items() if k not in ("run", "env")} |
| d.update(run=r["run"], env=r["env"]) |
| out.append(d) |
| return out |
|
|
|
|
| def arm(cells, key, probe): |
| """The cells as seen by one planner: its labels, and the sobriety of its own probe.""" |
| out = [] |
| for c in cells: |
| sob = c[f"sobriety_{probe}"] |
| out.append(dict(env=c["env"], sr=c[f"sr_{key}"], sobriety=sob, |
| vis=c["veracity"] * c["influence"] * sob, |
| **{m: c[m] for m in ("straightness", "probe_r2", "m_emp", |
| "veracity", "influence")})) |
| return [c for c in out if np.isfinite(c["sr"])] |
|
|
|
|
| def rho(cs, k): |
| x = np.array([c[k] for c in cs]); y = np.array([c["sr"] for c in cs]) |
| m = ~(np.isnan(x) | np.isnan(y)) |
| if m.sum() < 4 or len(set(np.round(x[m], 9))) < 2: |
| return np.nan |
| return float(spearmanr(x[m], y[m]).statistic) |
|
|
|
|
| def loto(cs, k): |
| errs = [] |
| for t in GRADED: |
| tr = [c for c in cs if c["env"] != t and np.isfinite(c[k])] |
| te = [c for c in cs if c["env"] == t and np.isfinite(c[k])] |
| if len(te) < 4 or len(tr) < 8: |
| continue |
| iso = IsotonicRegression(out_of_bounds="clip").fit([c[k] for c in tr], |
| [c["sr"] for c in tr]) |
| errs.append(np.mean(np.abs(iso.predict([c[k] for c in te]) |
| - np.array([c["sr"] for c in te])))) |
| return float(np.mean(errs)) if errs else np.nan |
|
|
|
|
| def resolvable(cs, env): |
| """sd between checkpoints against the binomial SE of one label: below one, unrankable.""" |
| y = [c["sr"] for c in cs if c["env"] == env] |
| if len(y) < 3: |
| return np.nan |
| p = np.clip(np.mean(y) / 100, 1e-6, 1 - 1e-6) |
| return float(np.std(y, ddof=1) / (100 * np.sqrt(p * (1 - p) / NUM_EVAL))) |
|
|
|
|
| def main() -> int: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--cells", default=str(Path(__file__).parent / "planner_cells.csv")) |
| ap.add_argument("--latex", action="store_true") |
| a = ap.parse_args() |
| cells = load(Path(a.cells)) |
| print(f"{len(cells)} checkpoints " |
| + ", ".join(f"{NAME[e]} {sum(1 for c in cells if c['env']==e)}" for e in GRADED)) |
|
|
| for key, probe, title in PLANNERS: |
| cs = arm(cells, key, probe) |
| print("=" * 96) |
| print(f"{title} [{probe} probe] n = {len(cs)}") |
| res = {e: resolvable(cs, e) for e in GRADED} |
| print(" label resolvability sd/SE: " |
| + " ".join(f"{NAME[e]} {res[e]:.1f}{'' if res[e] > 1 else ' (dagger)'}" |
| for e in GRADED)) |
| print(f" {'metric':26s}" + "".join(f"{NAME[e]:>11s}" for e in GRADED) |
| + f"{'Pooled':>9s}{'Calib':>8s}") |
| print("-" * 96) |
| for k, lab in ROWS: |
| line = f" {lab:26s}" |
| for e in GRADED: |
| r = rho([c for c in cs if c["env"] == e], k) |
| line += f"{r:>+11.2f}" if np.isfinite(r) else f"{'--':>11s}" |
| print(line + f"{rho(cs, k):>+9.2f}{loto(cs, k):>8.1f}") |
|
|
| if a.latex: |
| print("\n" + "=" * 96 + "\nLATEX\n") |
| for key, probe, title in PLANNERS: |
| cs = arm(cells, key, probe) |
| print(f" \\multicolumn{{6}}{{l}}{{\\emph{{{title}}}}} \\\\") |
| for k, lab in ROWS: |
| cols = [] |
| for e in GRADED: |
| r = rho([c for c in cs if c["env"] == e], k) |
| dag = "^{\\dagger}" if resolvable(cs, e) <= 1 else "" |
| cols.append("---" if not np.isfinite(r) else f"${r:+.2f}{dag}$") |
| hl = "\\rowcolor{green!10}" if k == "vis" else "" |
| nm = "VIScore" if k == "vis" else lab.replace(" ", "\;\;") |
| print(f" {hl}{nm} & {' & '.join(cols)} & ${rho(cs,k):+.2f}$ & " |
| f"${loto(cs,k):.1f}$ \\\\") |
| print(" \\midrule") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
