| |
| """One RoboTwin task/setting process: shared expert seed preparation or policy eval. |
| |
| Uses the pinned official task classes, configuration, instructions, action mapping, |
| chunk loop and success check. The adapter adds fixed seeds, timing and resumption. |
| """ |
| import argparse |
| import importlib |
| import json |
| import os |
| from pathlib import Path |
| import random |
| import signal |
| import sys |
| import time |
| import traceback |
|
|
| from eval_common import ROOT, Telemetry, append_json, save_json |
| from eval_diagnostics import emit_startup, record_startup_failure |
|
|
| ROBOTWIN = ROOT / 'third_party/RoboTwin' |
| LINGBOT = ROOT / 'third_party/lingbot-vla-v2' |
| os.environ['XDG_CACHE_HOME'] = str(ROOT / '.cache') |
| os.environ['MPLCONFIGDIR'] = str(ROOT / '.cache/matplotlib') |
| os.environ['TORCH_EXTENSIONS_DIR'] = str(ROOT / '.cache/torch_extensions_sim') |
|
|
|
|
| def config(task, setting): |
| import yaml |
| root = ROBOTWIN / 'task_config' |
| cfg = yaml.safe_load((root / f'demo_{setting}.yml').read_text()) |
| embodiment = yaml.safe_load((root / '_embodiment_config.yml').read_text()) |
| cameras = yaml.safe_load((root / '_camera_config.yml').read_text()) |
| assert cfg['embodiment'] == ['aloha-agilex'] |
| robot_dir = embodiment['aloha-agilex']['file_path'] |
| robot_cfg = yaml.safe_load((ROBOTWIN / robot_dir / 'config.yml').read_text()) |
| camera = cameras[cfg['camera']['head_camera_type']] |
| cfg.update(task_name=task, task_config=f'demo_{setting}', eval_mode=True, |
| collect_data=False, save_data=False, render_freq=0, eval_video_log=False, |
| left_robot_file=robot_dir, right_robot_file=robot_dir, dual_arm_embodied=True, |
| left_embodiment_config=robot_cfg, right_embodiment_config=robot_cfg, |
| head_camera_h=camera['h'], head_camera_w=camera['w']) |
| return cfg |
|
|
|
|
| def observation(env): |
| import numpy as np |
| obs = env.get_obs() |
| for name in ('head_camera', 'left_camera', 'right_camera'): |
| image = np.asarray(obs['observation'][name]['rgb']) |
| if image.shape != (240, 320, 3) or not np.isfinite(image).all() or image.std() == 0: |
| raise RuntimeError(f'Invalid camera observation: {name}, {image.shape}') |
| return {'observation.images.cam_high': obs['observation']['head_camera']['rgb'], |
| 'observation.images.cam_left_wrist': obs['observation']['left_camera']['rgb'], |
| 'observation.images.cam_right_wrist': obs['observation']['right_camera']['rgb'], |
| 'observation.state': obs['joint_action']['vector'], 'task': env.get_instruction()} |
|
|
|
|
| def restore_scene_sequence(env, row): |
| """Make resumed v1 scenes match the original uninterrupted 0..9 sequence. |
| |
| Upstream get_cluttered_table mutates its x/y default lists in place on each |
| setup. Only these two tasks use a nonzero table offset. Passing fresh, |
| explicitly replayed bounds preserves the existing BF16 reference scenes, |
| including their upstream clutter drift, without depending on worker age. |
| This is v1 compatibility, NOT a correction of upstream scene generation. |
| """ |
| if row['task'] not in ('dump_bin_bigbin', 'put_bottles_dustbin') or row['setting'] != 'randomized': |
| return {} |
| sequence_index = row.get('scene_sequence_index', row['index']) |
| if not 0 <= sequence_index < 10: |
| raise ValueError('Invalid frozen episode index') |
| |
| xlim, ylim = [-0.59, 0.59], [-0.34, 0.34] |
| for _ in range(sequence_index): |
| xlim[0] += 0.3 |
| xlim[1] += 0.3 |
| from envs._base_task import Base_Task |
| def frozen_clutter(): |
| if list(env.table_xy_bias) != [0.3, 0]: |
| raise RuntimeError('Unexpected table offset for v1 scene restoration') |
| return Base_Task.get_cluttered_table(env, xlim=xlim.copy(), ylim=ylim.copy(), zlim=[0.741]) |
| env.get_cluttered_table = frozen_clutter |
| return {'protocol': 'v1_uninterrupted_cell_sequence', |
| 'prior_setups': sequence_index, 'xlim_before_setup': xlim, 'ylim_before_setup': ylim} |
|
|
|
|
| def restore_task_state(env, row): |
| """Restore deterministic pre-action fields normally left by play_once. |
| |
| The official client reuses its expert environment for policy evaluation. |
| Our separate workers must recreate these three tasks' success-check inputs |
| after EVERY setup, including later episodes in the same worker. |
| """ |
| task = row['task'] |
| if task not in ('open_laptop', 'place_object_scale', 'put_object_cabinet'): |
| return {} |
| from envs.utils import ArmTag, get_face_prod |
| if task == 'open_laptop': |
| face_prod = get_face_prod(env.laptop.get_pose().q, [1, 0, 0], [1, 0, 0]) |
| arm = 'left' if face_prod > 0 else 'right' |
| else: |
| arm = 'right' if env.object.get_pose().p[0] > 0 else 'left' |
| if arm != row['scene_info']['{a}']: |
| raise RuntimeError(f'Expert/policy scene arm mismatch: {task}, seed {row["seed"]}') |
| env.arm_tag = ArmTag(arm) |
| state = {'arm_tag': arm} |
| if task == 'put_object_cabinet': |
| env.origin_z = env.object.get_pose().p[2] |
| state['origin_z'] = float(env.origin_z) |
| return state |
|
|
|
|
| def release_unused_cuda_cache(env): |
| |
| import gc |
| import pickle |
| import torch |
| import numpy as np |
| def snapshot(): |
| return pickle.dumps((env.robot.get_left_arm_jointState(), env.robot.get_right_arm_jointState(), |
| [(a.get_name(), a.get_pose().p.tolist(), a.get_pose().q.tolist()) |
| for a in env.scene.get_all_actors()], np.random.get_state(), random.getstate())) |
| initial = snapshot() |
| before = torch.cuda.memory_reserved() |
| |
| |
| |
| |
| if env.robot.communication_flag: |
| raise RuntimeError('Expert-engine release is only validated for in-process Aloha planners') |
| def unavailable(*a, **kw): |
| raise RuntimeError('Policy rollout unexpectedly requested expert GPU planning') |
| for planner in (env.robot.left_planner, env.robot.right_planner): |
| for key in ('motion_gen', 'motion_gen_batch'): |
| if hasattr(planner, key): |
| delattr(planner, key) |
| planner.plan_path = unavailable |
| planner.plan_batch = unavailable |
| gc.collect() |
| torch.cuda.empty_cache() |
| if snapshot() != initial: |
| raise RuntimeError('Expert-engine release changed scene, joints or random state') |
| print(json.dumps({'event': 'release_unused_sim_cache', |
| 'reserved_before_mib': before/1024**2, |
| 'reserved_after_mib': torch.cuda.memory_reserved()/1024**2, |
| 'scene_joint_rng_unchanged': True}), flush=True) |
|
|
|
|
| def prepare(args, env, cfg): |
| from envs.utils.create_actor import UnStableError |
| from generate_episode_instructions import generate_episode_descriptions |
| import numpy as np |
| path = args.manifest_dir / f'{args.task}__{args.setting}.json' |
| if path.exists(): |
| previous = json.loads(path.read_text()) |
| if previous['status'] == 'ready' and len(previous['episodes']) == 10: |
| print('Reusing frozen seed manifest', path, flush=True) |
| return |
| raise RuntimeError('Partial manifest exists; inspect before replacing') |
| result = {'task': args.task, 'setting': args.setting, 'status': 'preparing', |
| 'start_seed': args.start_seed, 'candidate_limit': 200, |
| 'instruction_type': 'unseen', 'episodes': [], 'rejections': [], |
| 'policy_evaluation_during_selection': False} |
| started = time.monotonic() |
| try: |
| for seed in range(args.start_seed, args.start_seed+200): |
| signal.alarm(240) |
| t = time.monotonic() |
| random.seed(seed) |
| expert_error = None |
| try: |
| env.setup_demo(now_ep_num=len(result['episodes']), seed=seed, is_test=True, **cfg) |
| try: |
| info = env.play_once() |
| except (TypeError, ValueError, IndexError, AssertionError) as error: |
| |
| |
| |
| |
| expert_error = {'type': type(error).__name__, 'message': str(error), |
| 'traceback': traceback.format_exc()} |
| env.close_env() |
| accepted = expert_error is None and bool(env.plan_success and env.check_success()) |
| reason = ('expert_exception' if expert_error is not None else |
| None if accepted else 'expert_plan_or_success_failed') |
| except UnStableError as error: |
| accepted, reason = False, str(error) |
| env.close_env() |
| if accepted: |
| |
| random.seed(seed+9107) |
| descriptions = generate_episode_descriptions(args.task, [info['info']], 10) |
| if not descriptions or not descriptions[0]['unseen']: |
| raise RuntimeError('No unseen instructions') |
| instruction = str(np.random.RandomState(seed+9107).choice(descriptions[0]['unseen'])) |
| row = {'task': args.task, 'setting': args.setting, 'index': len(result['episodes']), |
| 'seed': seed, 'policy_seed': seed+42, 'instruction': instruction, |
| 'scene_info': info['info'], 'precheck_seconds': time.monotonic()-t} |
| result['episodes'].append(row) |
| else: |
| result['rejections'].append({'seed': seed, 'reason': reason, 'seconds': time.monotonic()-t, |
| **({'expert_error': expert_error} if expert_error else {})}) |
| signal.alarm(0) |
| print(json.dumps({'seed': seed, 'accepted': accepted, 'count': len(result['episodes']), |
| 'seconds': time.monotonic()-t}), flush=True) |
| save_json(args.output / 'precheck_progress.json', result) |
| if len(result['episodes']) == 10: |
| break |
| if len(result['episodes']) != 10: |
| raise RuntimeError('Fewer than 10 valid seeds within 200 candidates') |
| result['status'] = 'ready' |
| result['seconds'] = time.monotonic()-started |
| save_json(path, result) |
| finally: |
| signal.alarm(0) |
|
|
|
|
| def evaluate(args, env, cfg): |
| emit_startup(args.output, 'evaluation_imports_started') |
| import numpy as np |
| from deploy.websocket_client_policy import WebsocketClientPolicy |
| emit_startup(args.output, 'evaluation_imports_complete') |
| manifest = json.loads((args.manifest_dir / f'{args.task}__{args.setting}.json').read_text()) |
| assert manifest['status'] == 'ready' and len(manifest['episodes']) == 10 |
| rows = manifest['episodes'] |
| if args.indices: |
| wanted = {int(i) for i in args.indices.split(',')} |
| rows = [r for r in rows if r['index'] in wanted] |
| emit_startup(args.output, 'policy_client_connecting', port=args.port) |
| model = WebsocketClientPolicy(host='127.0.0.1', port=args.port) |
| metadata = model.get_server_metadata() |
| assert metadata['model'] == args.model and metadata['precision'] == args.precision, metadata |
| save_json(args.output / 'server_metadata.json', metadata) |
| emit_startup(args.output, 'policy_client_ready', model=args.model, precision=args.precision) |
| emit_startup(args.output, 'telemetry_initializing') |
| telemetry = Telemetry(args.output / 'gpu_samples.jsonl') |
| completed = [] |
| try: |
| emit_startup(args.output, 'worker_ready', startup_complete=True) |
| for row in rows: |
| args.output.mkdir(parents=True, exist_ok=True) |
| record_path = args.results_dir / f"{args.model}_{args.precision}" / f"{args.task}__{args.setting}__{row['index']:02d}.json" |
| if record_path.exists(): |
| saved = json.loads(record_path.read_text()) |
| assert saved['seed'] == row['seed'] and saved['status'] == 'completed' |
| continue |
| signal.alarm(900) |
| random.seed(row['seed']) |
| boundary = telemetry.sample() |
| start = boundary['monotonic'] |
| append_json(args.output / 'events.jsonl', {'event': 'episode_started', 'timestamp': time.time(), **row}) |
| scene_sequence = restore_scene_sequence(env, row) |
| env.setup_demo(now_ep_num=row['index'], seed=row['seed'], is_test=True, **cfg) |
| restored_state = restore_task_state(env, row) |
| release_unused_cuda_cache(env) |
| env.set_instruction(instruction=row['instruction']) |
| model.infer(dict(reset=True, robo_name='robotwin', policy_seed=row['policy_seed'])) |
| rollout_start = time.monotonic() |
| success = False |
| calls = 0 |
| latencies = [] |
| while env.take_action_cnt < env.step_lim and not success: |
| obs = observation(env) |
| call_start = time.monotonic() |
| response = model.infer(obs) |
| latencies.append(time.monotonic()-call_start) |
| calls += 1 |
| actions = np.asarray(response['action']) |
| if actions.shape != (50, 14) or not np.isfinite(actions).all(): |
| raise RuntimeError(f'Invalid actions: {actions.shape}') |
| for action in actions: |
| if env.take_action_cnt >= env.step_lim: |
| break |
| env.take_action(action) |
| if env.eval_success: |
| success = True |
| break |
| rollout_seconds = time.monotonic()-rollout_start |
| action_count, step_limit = env.take_action_cnt, env.step_lim |
| env.close_env(clear_cache=((row['index']+1) % cfg['clear_cache_freq'] == 0)) |
| end = telemetry.sample()['monotonic'] |
| result = {**row, 'model': args.model, 'precision': args.precision, |
| 'status': 'completed', 'success': success, |
| 'episode_wall_seconds': end-start, 'rollout_seconds': rollout_seconds, |
| 'actions': action_count, 'step_limit': step_limit, 'policy_calls': calls, |
| 'mean_policy_request_seconds': sum(latencies)/len(latencies), |
| 'monotonic_start': start, 'monotonic_end': end, |
| 'finished_at': time.time(), 'attempt_dir': str(args.output), |
| 'video': False, 'expert_gpu_engines_released': True, |
| 'render_shader': os.environ.get('EVAL_RENDER_SHADER', 'rt'), |
| 'evaluation_protocol': os.environ.get('EVAL_PROTOCOL', 'local_v1_rt'), |
| 'restored_task_state': restored_state, |
| 'restored_scene_sequence': scene_sequence, |
| **telemetry.summary(start, end)} |
| if result['memory_coverage'] < 0.98: |
| raise RuntimeError(f'Insufficient telemetry coverage: {result["memory_coverage"]}') |
| save_json(record_path, result) |
| append_json(args.output / 'events.jsonl', {'event': 'episode_finished', **result}) |
| completed.append(result) |
| print(json.dumps({'event': 'episode_finished', **result}), flush=True) |
| signal.alarm(0) |
| save_json(args.output / 'result.json', {'status': 'completed', 'episodes': completed}) |
| finally: |
| telemetry.close() |
| signal.alarm(0) |
|
|
|
|
| def main(): |
| p = argparse.ArgumentParser() |
| p.add_argument('--mode', choices=['prepare', 'evaluate'], required=True) |
| p.add_argument('--task', required=True) |
| p.add_argument('--setting', choices=['clean', 'randomized'], required=True) |
| p.add_argument('--start-seed', type=int, default=300000) |
| p.add_argument('--output', type=Path, required=True) |
| p.add_argument('--manifest-dir', type=Path, required=True) |
| p.add_argument('--results-dir', type=Path) |
| p.add_argument('--model', choices=['base', 'robotwin']) |
| p.add_argument('--precision', choices=['bf16', 'fp32']) |
| p.add_argument('--port', type=int, default=9340) |
| p.add_argument('--indices') |
| args = p.parse_args() |
| args.output = args.output.resolve() |
| args.manifest_dir = args.manifest_dir.resolve() |
| args.results_dir = args.results_dir.resolve() if args.results_dir else None |
| args.output.mkdir(parents=True, exist_ok=True) |
| args.manifest_dir.mkdir(parents=True, exist_ok=True) |
| def timeout(signum, frame): |
| raise TimeoutError('Per-seed/precheck or episode timeout') |
| env = None |
| try: |
| emit_startup(args.output, 'python_entry', role='worker', task=args.task, |
| setting=args.setting, mode=args.mode) |
| signal.signal(signal.SIGALRM, timeout) |
| os.chdir(ROBOTWIN) |
| sys.path[:0] = [str(ROBOTWIN), str(ROBOTWIN/'description/utils'), str(LINGBOT)] |
| emit_startup(args.output, 'sapien_binding_started') |
| from eval_device import bind_sapien |
| bind_sapien() |
| emit_startup(args.output, 'sapien_binding_complete') |
| emit_startup(args.output, 'task_import_started', task=args.task) |
| cls = getattr(importlib.import_module('envs.'+args.task), args.task) |
| emit_startup(args.output, 'task_import_complete') |
| emit_startup(args.output, 'environment_constructing') |
| env = cls() |
| emit_startup(args.output, 'environment_constructed') |
| emit_startup(args.output, 'config_loading') |
| cfg = config(args.task, args.setting) |
| emit_startup(args.output, 'config_loaded') |
| if args.mode == 'prepare': |
| emit_startup(args.output, 'preparation_ready', startup_complete=True) |
| prepare(args, env, cfg) |
| else: |
| evaluate(args, env, cfg) |
| except BaseException as error: |
| record_startup_failure(args.output, error) |
| save_json(args.output / 'error.json', {'type': type(error).__name__, 'message': str(error), |
| 'traceback': traceback.format_exc(), 'timestamp': time.time()}) |
| raise |
| finally: |
| signal.alarm(0) |
| try: |
| env.close_env() |
| except Exception: |
| pass |
| robot = getattr(env, 'robot', None) |
| for key in ('left_proc', 'right_proc'): |
| process = getattr(robot, key, None) |
| if process is not None and process.is_alive(): |
| process.terminate() |
| process.join(timeout=5) |
| if process.is_alive(): |
| process.kill() |
| process.join() |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
