scripts/hybrid_worker.py

#!/usr/bin/env python3
"""A bounded RT episode for hybrid_v1; never writes the original v1 results."""
import argparse
import faulthandler
import hashlib
import importlib
import json
import os
from pathlib import Path
import pickle
import random
import re
import signal
import sys
import time
import traceback

from eval_common import ROOT, Telemetry, save_json
from eval_model_registry import MODEL_NAMES, validate_server_identity, validate_lora_identity
from eval_planner_optimization import evaluation_planner_setup
from eval_official_worker import (ROBOTWIN, LINGBOT, config, observation,
                                 restore_scene_sequence, restore_task_state,
                                 release_unused_cuda_cache)


def scene_hash(env):
    """Check exposed physical state and action counter around a blocking RPC."""
    value = (env.take_action_cnt, env.robot.get_left_arm_jointState(),
             env.robot.get_right_arm_jointState(),
             env.robot.left_entity.get_qpos().tolist(), env.robot.left_entity.get_qvel().tolist(),
             env.robot.right_entity.get_qpos().tolist(), env.robot.right_entity.get_qvel().tolist(),
             [(a.get_name(), a.get_pose().p.tolist(), a.get_pose().q.tolist())
              for a in env.scene.get_all_actors()])
    return hashlib.sha256(pickle.dumps(value)).hexdigest()


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument('--mode', choices=['capture', 'evaluate'], required=True)
    parser.add_argument('--task', default='adjust_bottle')
    parser.add_argument('--setting', choices=['clean', 'randomized'], required=True)
    parser.add_argument('--index', type=int, default=0)
    parser.add_argument('--condition', choices=['local', 'ssh_loopback', 'a100'], default='local')
    parser.add_argument('--model', choices=MODEL_NAMES, default='robotwin')
    parser.add_argument('--precision', choices=['bf16', 'fp32'], default='bf16')
    parser.add_argument('--planner-initialization', choices=['skip_unused', 'legacy'],
                        default='skip_unused',
                        help='Skip unused expert GPU planners; legacy retains original setup for comparisons')
    parser.add_argument('--evaluation-protocol', default='hybrid_v1_rt')
    parser.add_argument('--subset-id', default='')
    parser.add_argument('--subset-commit', default='')
    parser.add_argument('--manifest-dir', type=Path, default=ROOT / 'manifests/official_eval_1000')
    parser.add_argument('--port', type=int, default=19530)
    parser.add_argument('--output', type=Path, required=True)
    args = parser.parse_args()
    if not re.fullmatch(r'hybrid_[a-z0-9_]+_rt', args.evaluation_protocol):
        parser.error('Expected a named hybrid RT evaluation protocol')
    if bool(args.subset_id) != bool(args.subset_commit) or (args.subset_commit and
            not re.fullmatch('[0-9a-f]{40}', args.subset_commit)):
        parser.error('A frozen subset requires both its subset ID and full Git commit')
    args.output = args.output.resolve()
    args.output.mkdir(parents=True, exist_ok=True)
    if (args.output / 'result.json').exists():
        raise RuntimeError('Choose a new output directory; completed results are immutable')
    faulthandler.register(signal.SIGUSR1, all_threads=True)
    save_json(args.output / 'diagnostics_ready.json', {'pid': os.getpid(), 'signal': 'SIGUSR1'})
    if os.environ.get('EVAL_RENDER_SHADER', 'rt') != 'rt':
        raise RuntimeError('Hybrid evaluation requires the original local RT rendering')
    manifest_path = args.manifest_dir / f'{args.task}__{args.setting}.json'
    manifest = json.loads(manifest_path.read_text())
    row = next(r for r in manifest['episodes'] if r['index'] == args.index)
    if manifest['status'] != 'ready':
        raise RuntimeError('Manifest is not ready')
    env = client = telemetry = None
    def timeout(*_):
        raise TimeoutError('Hybrid episode exceeded its wall-time deadline')
    signal.signal(signal.SIGALRM, timeout)
    # The eager LoRA service is slower and six sessions share its serial GPU.
    # Keep exactly the same environment action limits and frozen episode seeds.
    signal.alarm(2400 if args.model == 'lora8' else 1200)
    try:
        import numpy as np
        os.chdir(ROBOTWIN)
        sys.path[:0] = [str(ROBOTWIN), str(ROBOTWIN / 'description/utils'), str(LINGBOT)]
        from eval_device import bind_sapien
        bind_sapien()
        cls = getattr(importlib.import_module('envs.' + args.task), args.task)
        env = cls()
        cfg = config(args.task, args.setting)
        telemetry = Telemetry(args.output / 'gpu_samples.jsonl')
        start = telemetry.sample()['monotonic']
        random.seed(row['seed'])
        scene_sequence = restore_scene_sequence(env, row)
        with evaluation_planner_setup(cfg, mode=args.planner_initialization,
                                      action_type='qpos', policy_execution='remote') as planner_setup:
            env.setup_demo(now_ep_num=row['index'], seed=row['seed'], is_test=True, **cfg)
            planner_setup.verify_environment(env)
        restored_state = restore_task_state(env, row)
        release_unused_cuda_cache(env)
        env.set_instruction(instruction=row['instruction'])
        setup_seconds = time.monotonic() - start
        import sapien
        shader_getter = getattr(sapien.render, 'get_camera_shader_dir', None)
        provenance = {**row, 'evaluation_protocol': args.evaluation_protocol,
                      'planner_initialization': args.planner_initialization,
                      'planner_setup': planner_setup.provenance(),
                      'noise_protocol': 'numpy_PCG64_SeedSequence_policy_seed_sequence_float32',
                      'condition': args.condition, 'model': args.model, 'precision': args.precision,
                      'manifest_sha256': hashlib.sha256(manifest_path.read_bytes()).hexdigest(),
                      'render_shader_requested': 'rt',
                      'render_shader_actual': str(shader_getter()) if shader_getter else 'getter_unavailable',
                      'render_device': str(env.scene.render_system.device),
                      'local_gpu_uuid': os.environ.get('EVAL_GPU_UUID'),
                      'restored_scene_sequence': scene_sequence, 'restored_task_state': restored_state,
                      'memory_scope': 'whole local GPU, includes desktop and any colocated policy',
                      'transport_route': ('local -> NSCC sshd -> local policy (double tunnel)' if
                                          args.condition == 'ssh_loopback' else args.condition)}
        if args.subset_id:
            provenance.update(subset_id=args.subset_id, subset_commit=args.subset_commit)
        save_json(args.output / 'provenance.json', provenance)
        first_observation_start = time.monotonic()
        first_obs = observation(env)
        first_observation_seconds = time.monotonic() - first_observation_start
        np.savez(args.output / 'initial_observation.npz', **first_obs)
        obs_hashes = {key: hashlib.sha256(np.ascontiguousarray(value).tobytes()).hexdigest()
                      for key, value in first_obs.items() if key != 'task'}
        save_json(args.output / 'observation_hashes.json', obs_hashes)
        if args.mode == 'capture':
            end = telemetry.sample()['monotonic']
            result = {**provenance, 'status': 'captured', 'setup_seconds': setup_seconds,
                      'observation_hashes': obs_hashes, **telemetry.summary(start, end)}
        else:
            from hybrid_transport import HybridClient, InfrastructureError
            client = HybridClient(port=args.port, timeout=120, log_path=args.output / 'requests.jsonl')
            metadata = client.get_server_metadata()
            if metadata['model'] != args.model or metadata['precision'] != args.precision:
                raise InfrastructureError('Server model/precision mismatch')
            if args.model == 'e5':
                validate_server_identity(metadata, ROOT)
            if args.model == 'lora8':
                validate_lora_identity(metadata, ROOT)
            if args.condition == 'a100' and 'A100' not in metadata.get('gpu_name', ''):
                raise InfrastructureError('A100 condition requires an actual A100 policy device')
            if (args.evaluation_protocol != 'hybrid_v1_rt' and
                    metadata.get('concurrency_protocol') != 'hybrid_concurrency_v1'):
                raise InfrastructureError('Capacity evaluation requires isolated concurrent server')
            save_json(args.output / 'server_metadata.json', metadata)
            client.reset(f'{args.task}/{args.setting}/{args.index}', row['policy_seed'])
            from e5_rollout_history import RolloutCombinedHistory
            episode_id = f'{args.task}/{args.setting}/{args.index}'
            history = RolloutCombinedHistory(episode_id, args.output, session_id=client._session_id) if args.model == 'e5' else None
            rollout_start = time.monotonic()
            success, calls = False, 0
            observation_seconds, action_seconds = first_observation_seconds, 0.0
            unchanged_waits = 0
            while env.take_action_cnt < env.step_lim and not success:
                tick = time.monotonic()
                obs = first_obs if calls == 0 else observation(env)
                observation_seconds += time.monotonic() - tick
                before = scene_hash(env)
                if history is not None:
                    obs = history.observe(obs, env.take_action_cnt, calls, session_id=client._session_id)
                response = client.infer(obs)
                if scene_hash(env) != before:
                    raise InfrastructureError('Physical state advanced during a blocking policy request')
                unchanged_waits += 1
                actions = np.asarray(response['action'])
                if actions.shape != (50, 14) or not np.isfinite(actions).all():
                    raise InfrastructureError(f'Invalid action chunk: {actions.shape}')
                np.save(args.output / f'actions_{calls:03d}.npy', actions)
                calls += 1
                tick = time.monotonic()
                for action in actions:
                    if env.take_action_cnt >= env.step_lim:
                        break
                    before_counter = env.take_action_cnt
                    env.take_action(action)
                    if history is not None:
                        history.record_completed(np.asarray(action)[None], before_counter=before_counter,
                            after_counter=env.take_action_cnt, episode_id=episode_id, session_id=client._session_id)
                    if env.eval_success:
                        success = True
                        break
                action_seconds += time.monotonic() - tick
                print(json.dumps({'event': 'chunk', 'calls': calls, 'actions': env.take_action_cnt,
                                  'success': success, 'rtt_ms': client.last_metrics['client_rtt_ms']}), flush=True)
            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']
            metrics = [m for m in client.metrics if m['operation'] == 'infer']
            means = {f'mean_{key}': sum(m[key] for m in metrics) / len(metrics)
                     for key in ('client_pack_ms', 'client_rtt_ms', 'client_unpack_ms',
                                 'server_infer_ms', 'request_bytes', 'response_bytes')}
            if args.evaluation_protocol != 'hybrid_v1_rt':
                for key in ('server_queue_ms', 'server_state_switch_ms', 'server_session_init_ms'):
                    means[f'mean_{key}'] = sum(m[key] for m in metrics) / len(metrics)
                    means[f'p95_{key}'] = float(np.percentile([m[key] for m in metrics], 95))
                means['p95_client_rtt_ms'] = float(np.percentile([m['client_rtt_ms'] for m in metrics], 95))
            result = {**provenance, 'status': 'completed', 'success': success,
                      'setup_seconds': setup_seconds, 'rollout_seconds': rollout_seconds,
                      'episode_wall_seconds': end - start, 'actions': action_count, 'step_limit': step_limit,
                      'policy_calls': calls, 'physical_state_unchanged_during_requests': unchanged_waits,
                      'observation_seconds': observation_seconds, 'action_execution_seconds': action_seconds,
                      'first_observation_seconds': first_observation_seconds,
                      'rollout_timing_scope': 'after initial observation/save/reset; includes state checks and action saves',
                      'observation_hashes': obs_hashes, **means, **telemetry.summary(start, end)}
            result['mean_transport_serialization_residual_ms'] = (
                means['mean_client_rtt_ms'] - means['mean_server_infer_ms'])
            if result['memory_coverage'] < 0.98:
                raise InfrastructureError('Insufficient GPU telemetry coverage')
        save_json(args.output / 'result.json', result)
        print(json.dumps({'event': 'finished', **result}), flush=True)
    except BaseException as error:
        save_json(args.output / 'infrastructure_error.json',
                  {'status': 'infrastructure_error', 'type': type(error).__name__, 'message': str(error),
                   'traceback': traceback.format_exc(), 'timestamp': time.time()})
        raise
    finally:
        signal.alarm(0)
        if client is not None:
            client.close()
        if telemetry is not None:
            try:
                telemetry.close()
            except Exception as error:
                save_json(args.output / 'telemetry_cleanup_error.json', {'message': str(error)})
        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(timeout=5)


if __name__ == '__main__':
    main()