#!/usr/bin/env python3 """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') # Addition order matters: reproduce each preceding setup's exact floats. 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): # Return expert-only allocations before Vulkan allocates render targets. 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() # All experts ran in a separate preparation process. Joint-position policy # execution needs MPlib TOPP and the CPU gripper interpolation only, not # CuRobo MotionGen or its CUDA graphs. Preserve planner objects/metadata so # Robot.reset and the exact official gripper function remain unchanged. 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: # The official client rejects candidates when expert planning # raises (e.g. no feasible grasp returns None). Keep setup, # asset, timeout, CUDA and Vulkan errors fatal; bound candidate # selection and retain the exact expert failure for audit. 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: # Instruction draw is fixed independently from policy inference RNG. 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()