| """Sequential, resumable official evaluations. Default: one official-horizon instance. |
| |
| Run through the Python/environment configured by env.sh. --all is explicit to |
| avoid launching twenty expensive simulations during development. |
| """ |
| import argparse |
| import hashlib |
| import importlib.metadata |
| import json |
| import os |
| from pathlib import Path |
| import shutil |
| import socket |
| import subprocess |
| import sys |
| import time |
| import urllib.request |
|
|
| ROOT = Path(__file__).resolve().parent |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser() |
| p.add_argument('--indices', nargs='+', type=int, default=[0]) |
| p.add_argument('--all', action='store_true') |
| p.add_argument('--output', required=True) |
| p.add_argument('--max-steps', type=int) |
| p.add_argument('--port', type=int, help='Local port; default selects a free loopback port for this run') |
| p.add_argument('--scan-only', action='store_true') |
| p.add_argument('--write-video', action='store_true', help='Also encode full rollout videos; sensor snapshots are always saved') |
| p.add_argument('--navigation', choices=('validated', 'visual', 'prior'), default='prior') |
| args = p.parse_args() |
| automatic_port = args.port is None |
| if automatic_port: |
| with socket.socket() as listener: |
| listener.bind(('127.0.0.1', 0)) |
| args.port = listener.getsockname()[1] |
| indices = list(range(20)) if args.all else args.indices |
| if len(set(indices)) != len(indices) or any(i < 0 or i >= 20 for i in indices): |
| p.error('Indices must be distinct integers in 0–19') |
| root = Path(args.output).resolve() |
| root.mkdir(parents=True, exist_ok=True) |
| hashes = {str(f.relative_to(ROOT)): hashlib.sha256(f.read_bytes()).hexdigest() |
| for f in (ROOT / 'gpt6_b1k').glob('*.py')} |
| for f in (ROOT/'config').iterdir(): |
| if f.is_file(): |
| hashes[str(f.relative_to(ROOT))] = hashlib.sha256(f.read_bytes()).hexdigest() |
| extras = ('assets', 'third_party') if args.navigation == 'prior' else () |
| for directory in extras: |
| for f in sorted((ROOT/directory).rglob('*')): |
| if f.is_file() and not any(p in ('.git', '__pycache__') for p in f.parts): |
| hashes[str(f.relative_to(ROOT))] = hashlib.sha256(f.read_bytes()).hexdigest() |
| benchmark_files = {} |
| repository = os.environ.get('B1K_REPO') |
| if repository: |
| for name in ('eval.py', 'evaluator.py', 'r1pro.yaml'): |
| f = Path(repository)/'OmniGibson/omnigibson/eval'/name |
| benchmark_files[name] = hashlib.sha256(f.read_bytes()).hexdigest() |
| manifest = dict(task='picking_up_trash', indices=indices, instance_ids=[301+i for i in indices], |
| max_steps=args.max_steps, scan_only=args.scan_only, navigation=args.navigation, source_sha256=hashes, |
| write_video=args.write_video, |
| python=sys.executable, repository=os.environ.get('B1K_REPO'), seed=0, |
| benchmark_sha256=benchmark_files, |
| dependencies={name: importlib.metadata.version(name) for name in |
| (('numpy', 'scipy', 'opencv-python', 'msgpack', 'websockets')+ |
| (('torch', 'torchvision') if args.navigation == 'prior' else ()))}, |
| diagnostic=args.max_steps is not None or args.scan_only) |
| mf = root / 'manifest.json' |
| if mf.exists() and json.loads(mf.read_text()) != manifest: |
| p.error('Output already belongs to different code/settings; choose a new directory') |
| mf.write_text(json.dumps(manifest, indent=2)) |
| source = root / 'source' |
| for directory in ('gpt6_b1k', 'config', *extras): |
| shutil.copytree(ROOT/directory, source/directory, dirs_exist_ok=True, |
| ignore=shutil.ignore_patterns('__pycache__', '.git')) |
| child_env = os.environ.copy() |
| child_env['PYTHONPATH'] = str(source)+os.pathsep+child_env.get('PYTHONPATH', '') |
| child_env['PYTHONHASHSEED'] = '0' |
| completed = {r['instance_id'] for r in read_results(root)} |
| missing = [i for i in indices if 301+i not in completed] |
| if not missing: |
| summarize(root) |
| return |
| |
| |
| out = root / f'batch_{len(list(root.glob("batch_*"))):03d}' |
| out.mkdir() |
| (out/'transport.json').write_text(json.dumps(dict(host='127.0.0.1', port=args.port, |
| automatically_selected=automatic_port), indent=2)) |
| with (out / 'policy.log').open('w') as log: |
| command = [sys.executable, '-m', 'gpt6_b1k.server', '--port', str(args.port), '--output', str(out / 'policy')] |
| if args.scan_only: |
| command += ['--scan-only'] |
| command += ['--navigation', args.navigation] |
| policy = subprocess.Popen(command, stdout=log, stderr=subprocess.STDOUT, env=child_env, cwd=source) |
| try: |
| health_client = urllib.request.build_opener(urllib.request.ProxyHandler({})) |
| for _ in range(60): |
| if policy.poll() is not None: |
| raise RuntimeError('Policy exited before health check') |
| try: |
| with health_client.open(f'http://127.0.0.1:{args.port}/healthz', timeout=1): |
| break |
| except OSError: |
| time.sleep(1) |
| else: |
| raise RuntimeError('Policy did not become healthy') |
| command = [sys.executable, '-m', 'omnigibson.eval.eval', '--task-name', 'picking_up_trash', |
| '--mode', 'public_test', '--instance-indices', *map(str, missing), '--num-rollouts', '1', |
| '--host', '127.0.0.1', '--port', str(args.port), '--env-wrapper', |
| 'omnigibson.eval.wrappers.RGBDFullResWrapper', '--output-dir', str(out / 'evaluation'), |
| '--headless'] |
| if args.write_video: |
| command += ['--write-video'] |
| if args.max_steps is not None: |
| command += ['--max-steps', str(args.max_steps)] |
| (out / 'command.json').write_text(json.dumps(command, indent=2)) |
| print('START public indices', missing, flush=True) |
| with (out / 'evaluator.log').open('w') as evlog: |
| evaluator = subprocess.Popen(command, stdout=evlog, stderr=subprocess.STDOUT, env=child_env, cwd=source) |
| try: |
| previous = len(completed) |
| while evaluator.poll() is None: |
| time.sleep(5) |
| count = len(read_results(root)) |
| if count != previous: |
| summarize(root) |
| previous = count |
| code = evaluator.returncode |
| finally: |
| if evaluator.poll() is None: |
| evaluator.terminate() |
| try: |
| evaluator.wait(timeout=20) |
| except subprocess.TimeoutExpired: |
| evaluator.kill() |
| evaluator.wait() |
| (out / 'exit_code.txt').write_text(str(code)) |
| if code: |
| raise RuntimeError(f'Evaluator exited {code}; completed results remain resumable') |
| finally: |
| policy.terminate() |
| try: |
| policy.wait(timeout=10) |
| except subprocess.TimeoutExpired: |
| policy.kill() |
| policy.wait() |
| summarize(root) |
|
|
|
|
| def read_results(root): |
| rows = [] |
| for f in root.glob('*/evaluation/json/*.json'): |
| try: |
| rows.append(json.loads(f.read_text())) |
| except json.JSONDecodeError: |
| |
| |
| continue |
| ids = [r['instance_id'] for r in rows] |
| if len(ids) != len(set(ids)): |
| raise ValueError('Duplicate results: cannot count repeated instances as independent outcomes') |
| return sorted(rows, key=lambda r: r['instance_id']) |
|
|
|
|
| def summarize(root): |
| mf = json.loads((root / 'manifest.json').read_text()) |
| rows = read_results(root) |
| complete = len(rows) == len(mf['instance_ids']) and {r['instance_id'] for r in rows} == set(mf['instance_ids']) |
| result = dict(completed=len(rows), expected=len(mf['indices']), complete=complete, |
| diagnostic=mf['diagnostic'], mean_q=sum(r['q_score']['final'] for r in rows)/len(rows) if rows else None, |
| successes=sum(r['success'] for r in rows), |
| instances=[dict(id=r['instance_id'], q=r['q_score']['final'], steps=r['steps']) for r in rows]) |
| |
| |
| result['target_achieved'] = (complete and len(rows) == 20 and not mf['diagnostic'] |
| and result['mean_q'] > .7+1e-9) |
| (root / 'summary.json').write_text(json.dumps(result, indent=2)) |
| print(json.dumps(result, indent=2)) |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
