| """Sample efficiency: environment steps needed to reach a common target. |
| |
| The paper claims ST-GFN "requires substantially fewer samples to reach target |
| performance across all tasks" (Sec 4.6, Table 1 'Steps' column). We define the |
| target as a fixed fraction of the best final score achieved by ANY method on |
| that environment/metric, then report the first logged point at which each method |
| reaches it (env steps and iterations), averaged over seeds. |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import glob |
| import json |
| import os |
| from collections import defaultdict |
|
|
| import numpy as np |
|
|
| METRIC = { |
| "hypergrid": ("modes_found", True), |
| "bitsequence": ("mean_reward", True), |
| "tictactoe": ("win_pct", True), |
| "singlecell_proxy": ("mean_reward", True), |
| } |
| ORDER = ["stgfn", "tb", "fm", "subtb", "db", "eflownet", "stochastic_gfn", |
| "tb_rnd", "tb_novelty", "tb_icm", "tb_cv"] |
| LABEL = {"stgfn": "ST-GFN (Ours)", "tb": "TB", "fm": "FM", "subtb": "SubTB", "db": "DB", |
| "eflownet": "EFlowNet", "stochastic_gfn": "Stochastic-GFN", "tb_rnd": "TB+RND", |
| "tb_novelty": "TB+Novelty", "tb_icm": "TB+ICM", "tb_cv": "TB+ControlVar"} |
|
|
|
|
| def load(out_dir): |
| data = defaultdict(lambda: defaultdict(list)) |
| for p in glob.glob(os.path.join(out_dir, "*.json")): |
| with open(p) as f: |
| r = json.load(f) |
| data[r["env"]][r["method"]].append(r) |
| return data |
|
|
|
|
| def steps_to(run, metric, thresh): |
| for c in run["curve"]: |
| v = c.get(metric) |
| if v is not None and v >= thresh: |
| return c.get("env_steps"), c.get("iter") |
| return None, None |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--out", default="../outputs/main") |
| ap.add_argument("--frac", type=float, default=0.9) |
| ap.add_argument("--save", default="../outputs/sample_efficiency.json") |
| args = ap.parse_args() |
|
|
| data = load(args.out) |
| result = {} |
| for env, (metric, _) in METRIC.items(): |
| if env not in data: |
| continue |
| best = max( |
| np.mean([r["final"].get(metric, 0) or 0 for r in runs]) |
| for runs in data[env].values() |
| ) |
| thresh = args.frac * best |
| print(f"\n{'='*76}\n{env.upper()} metric={metric} " |
| f"target={args.frac:.0%} of best final ({best:.3f}) = {thresh:.3f}\n{'='*76}") |
| print(f"{'Method':22s} {'env steps to target':>22s} {'iters':>10s} {'reached':>9s}") |
| result[env] = {"metric": metric, "target": thresh, "methods": {}} |
| for m in ORDER: |
| if m not in data[env]: |
| continue |
| steps, iters, hit = [], [], 0 |
| for r in data[env][m]: |
| s, i = steps_to(r, metric, thresh) |
| if s is not None: |
| steps.append(s); iters.append(i); hit += 1 |
| n = len(data[env][m]) |
| if steps: |
| txt = f"{np.mean(steps):22,.0f} {np.mean(iters):10,.0f} {hit}/{n:>7d}" |
| else: |
| txt = f"{'never':>22s} {'-':>10s} {0}/{n:>7d}" |
| print(f"{LABEL.get(m,m):22s} {txt}") |
| result[env]["methods"][m] = { |
| "mean_env_steps": float(np.mean(steps)) if steps else None, |
| "mean_iters": float(np.mean(iters)) if iters else None, |
| "n_reached": hit, "n_seeds": n, |
| } |
| with open(args.save, "w") as f: |
| json.dump(result, f, indent=2) |
| print(f"\nwrote {args.save}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
