| """Evaluate a policy pool on a goal set under nominal ROM and TR variants (Sim2Sim, ROM side). |
| |
| Usage: python run_rom.py --set A --pool explore --variants all |
| Writes results/rom_<set>/<variant>.npz (success, time_s, terminal/min distance [policy, goal, trial]; sampled |
| parameters [goal, trial]) and results/rom_<set>/<variant>.json (manifest: spec, K, seeds, policies, hashes). |
| Common random numbers: the same sampled parameters and noise stream for every policy. |
| """ |
| import argparse |
| import json |
| import time |
| import zlib |
|
|
| import numpy as np |
| import torch |
|
|
| import rom_batch |
| import variants as V |
| from common import RESULTS, Actor, make_goal_set, policy_registry, rel_path, sha256 |
|
|
| POOLS = { |
| 'explore': ['rel1', 'rel2', 'rel3', 'rel4'] + [f'{c}_s{s}' for c in ('nonoise', 'release', 'robust') for s in (1001, 1002, 1003, 1004)], |
| 'confirm': [f'{c}_s{s}' for c in ('nonoise', 'release', 'robust') for s in (2001, 2002, 2003, 2004)], |
| 'released': ['rel1', 'rel2', 'rel3', 'rel4'], |
| } |
| POOLS['confirm16'] = POOLS['confirm'] + POOLS['released'] |
| N_PER_RANGE = {'A': 50, 'B': 75} |
|
|
|
|
| def seed_of(*parts): |
| return zlib.crc32(':'.join(map(str, parts)).encode()) |
|
|
|
|
| def run_variant(name, K, spec, goals, policies, reg, out_dir, set_name, device): |
| G = len(goals) |
| rng = np.random.default_rng(seed_of(set_name, name, 'params')) |
| params = V.sample(spec, G * K, rng) |
| noise_seed = seed_of(set_name, name, 'noise') |
| gxy = np.repeat(np.array([[g['x'], g['y']] for g in goals]), K, axis=0) |
| shape = (len(policies), G, K) |
| res = {k: np.zeros(shape, dtype=np.float32) for k in ('time_s', 'terminal_distance_m', 'min_distance_m')} |
| res['success'] = np.zeros(shape, dtype=bool) |
| t0 = time.time() |
| for i, p in enumerate(policies): |
| actor = Actor(reg[p]['path']).to_device(device) |
| o = rom_batch.simulate(actor, gxy, params, noise_seed=noise_seed, device=device) |
| for k in res: |
| res[k][i] = o[k].reshape(G, K) |
| np.savez_compressed(out_dir / f'{name}.npz', policies=np.array(policies), goal_ids=np.array([g['goal_id'] for g in goals]), |
| **res, **{f'param_{k}': v.reshape(G, K).astype(np.float32) for k, v in params.items()}) |
| man = dict(variant=name, trials_per_goal=K, spec={k: list(v) for k, v in spec.items()}, goal_set=set_name, goals=G, |
| param_seed=seed_of(set_name, name, 'params'), noise_seed=noise_seed, device=device, |
| policies={p: dict(path=rel_path(reg[p]['path']), sha256=sha256(reg[p]['path'])) for p in policies}, |
| wall_s=time.time() - t0) |
| (out_dir / f'{name}.json').write_text(json.dumps(man, indent=1) + '\n') |
| return res |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument('--set', choices=['A', 'B'], required=True) |
| ap.add_argument('--pool', choices=list(POOLS), required=True) |
| ap.add_argument('--variants', default='all', help='comma list or all (EXPLORE table, or the fixed design with --table fixed)') |
| ap.add_argument('--device', default='cpu') |
| ap.add_argument('--tag', default='') |
| ap.add_argument('--table', choices=['explore', 'fixed'], default='explore') |
| a = ap.parse_args() |
| torch.set_num_threads(2) |
| if a.set == 'B' and a.table != 'fixed': |
| raise SystemExit('goal set B is the held-out set: use --table fixed') |
| if a.table == 'fixed': |
| import fixed_design |
| table = fixed_design.CONDITIONS |
| else: |
| table = V.EXPLORE |
| names = list(table) if a.variants == 'all' else a.variants.split(',') |
| goals = make_goal_set(a.set, N_PER_RANGE[a.set]) |
| reg = policy_registry() |
| policies = POOLS[a.pool] |
| out_dir = RESULTS / f'rom_{a.set}_{a.pool}{a.tag}' |
| out_dir.mkdir(parents=True, exist_ok=True) |
| (out_dir / 'goals.json').write_text(json.dumps(goals, indent=1) + '\n') |
| for n in names: |
| K, spec = table[n] |
| r = run_variant(n, K, spec, goals, policies, reg, out_dir, a.set, a.device) |
| sr = r['success'].mean((1, 2)) |
| print(f'{n:18s} K={K:2d} success ' + ' '.join(f'{p}:{s:.2f}' for p, s in zip(policies, sr)), flush=True) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
