| """Bounded, synchronous, uncompressed policy transport for hybrid evaluation. |
| |
| There is deliberately no reconnect/retry path: a lost connection invalidates the |
| current rollout. Session/sequence checks protect against executing stale actions. |
| """ |
| import asyncio |
| import hashlib |
| import http |
| import json |
| import math |
| from pathlib import Path |
| import socket |
| import sys |
| import threading |
| import time |
| import uuid |
|
|
| import numpy as np |
|
|
| UPSTREAM = Path(__file__).resolve().parents[1] / 'third_party/lingbot-vla-v2' |
| if str(UPSTREAM) not in sys.path: |
| sys.path.insert(0, str(UPSTREAM)) |
| from deploy.msgpack_numpy import Packer, unpackb |
|
|
| PROTOCOL = 'hybrid_v1' |
|
|
|
|
| class InfrastructureError(RuntimeError): |
| """Abort this episode; restarting requires restoring the complete scene.""" |
|
|
|
|
| def append_record(path, value): |
| if path is not None: |
| path = Path(path) |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open('a') as stream: |
| stream.write(json.dumps(value, sort_keys=True) + '\n') |
| stream.flush() |
|
|
|
|
| def noise_sha256(noise): |
| return hashlib.sha256(np.ascontiguousarray(noise).tobytes()).hexdigest() |
|
|
|
|
| def generate_noise(policy_seed, sequence_id, shape): |
| """Canonical CPU float32 noise; this is an explicitly new RNG protocol.""" |
| rng = np.random.Generator(np.random.PCG64(np.random.SeedSequence( |
| [int(policy_seed), int(sequence_id)]))) |
| return rng.standard_normal(tuple(shape), dtype=np.float32) |
|
|
|
|
| def validate_noise(noise, shape): |
| if not isinstance(noise, np.ndarray) or noise.dtype != np.float32: |
| raise InfrastructureError('Noise must be a CPU float32 NumPy array') |
| if tuple(noise.shape) != tuple(shape) or not np.isfinite(noise).all(): |
| raise InfrastructureError('Invalid noise shape or nonfinite noise') |
| return np.ascontiguousarray(noise) |
|
|
|
|
| def infer_with_noise(policy, observation, noise, torch_module=None): |
| """Inject noise through the upstream API without changing upstream files.""" |
| if noise is None: |
| return policy.infer(observation) |
| if torch_module is None: |
| import torch as torch_module |
| original = policy.sample_actions_fn |
| calls = 0 |
|
|
| def sample(*args, **kwargs): |
| nonlocal calls |
| calls += 1 |
| if calls != 1 or kwargs.get('noise') is not None: |
| raise InfrastructureError('Expected exactly one upstream noise injection') |
| state = args[4] if len(args) > 4 else kwargs['state'] |
| |
| tensor = torch_module.from_numpy(noise.copy()).to( |
| device=state.device, dtype=state.dtype).clone() |
| kwargs['noise'] = tensor |
| return original(*args, **kwargs) |
|
|
| policy.sample_actions_fn = sample |
| try: |
| result = policy.infer(observation) |
| if calls != 1: |
| raise InfrastructureError('The policy did not consume explicit noise') |
| return result |
| finally: |
| policy.sample_actions_fn = original |
|
|
|
|
| class ProtocolSession: |
| """One connection owns one policy; completed request IDs are idempotent.""" |
| def __init__(self, infer, noise_shape, synchronize=lambda: None): |
| self.infer = infer |
| self.noise_shape = tuple(noise_shape) |
| self.synchronize = synchronize |
| self.session_id = None |
| self.episode_id = None |
| self.sequence_id = -1 |
| self.cache = {} |
| self.seen_sessions = set() |
|
|
| def process(self, request, digest): |
| if not isinstance(request, dict) or request.get('protocol') != PROTOCOL: |
| raise InfrastructureError('Unsupported hybrid protocol') |
| session = request.get('session_id') |
| episode = request.get('episode_id') |
| sequence = request.get('sequence_id') |
| if (not isinstance(session, str) or not 1 <= len(session) <= 128 or |
| not isinstance(episode, str) or not 1 <= len(episode) <= 256 or |
| type(sequence) is not int or sequence < 0): |
| raise InfrastructureError('Invalid request identity') |
| operation = request.get('operation') |
| if session == self.session_id and sequence in self.cache: |
| cached_hash, cached_response = self.cache[sequence] |
| if episode != self.episode_id or digest != cached_hash: |
| raise InfrastructureError('Reused sequence has different payload or episode') |
| return cached_response, True |
| if operation == 'reset': |
| seed = request.get('policy_seed') |
| if (sequence != 0 or session in self.seen_sessions or |
| type(seed) is not int or not 0 <= seed < 2**32): |
| raise InfrastructureError('A new episode requires a new session and sequence zero') |
| observation = {'reset': True, 'robo_name': 'robotwin', 'policy_seed': seed} |
| noise = None |
| elif operation == 'infer': |
| if (session != self.session_id or episode != self.episode_id or |
| sequence != self.sequence_id + 1): |
| raise InfrastructureError('Missing reset, stale session, or out-of-order request') |
| observation = request.get('observation') |
| if not isinstance(observation, dict) or observation.get('reset'): |
| raise InfrastructureError('Invalid inference observation') |
| noise = validate_noise(request.get('noise'), self.noise_shape) |
| else: |
| raise InfrastructureError('Unsupported operation') |
| self.synchronize() |
| started = time.perf_counter() |
| action = self.infer(observation, noise) |
| self.synchronize() |
| infer_ms = (time.perf_counter() - started) * 1000 |
| if not isinstance(action, dict): |
| raise InfrastructureError('Policy returned an invalid response') |
| response = {'protocol': PROTOCOL, 'session_id': session, |
| 'episode_id': episode, 'sequence_id': sequence, |
| 'request_sha256': digest, 'result': action, |
| 'server_infer_ms': infer_ms, |
| 'noise_sha256': noise_sha256(noise) if noise is not None else None} |
| if operation == 'reset': |
| self.session_id, self.episode_id = session, episode |
| self.cache = {} |
| self.seen_sessions.add(session) |
| self.sequence_id = sequence |
| self.cache[sequence] = (digest, response) |
| return response, False |
|
|
|
|
| class HybridPolicyServer: |
| def __init__(self, policy, host='127.0.0.1', port=None, metadata=None, |
| log_path=None, synchronize=None, hardware=None): |
| if host != '127.0.0.1': |
| raise ValueError('Hybrid server must bind to loopback; use an SSH tunnel') |
| self.policy, self.host, self.port = policy, host, port |
| self.log_path = log_path |
| self.noise_shape = (1, policy.config.n_action_steps, policy.config.max_action_dim) |
| if synchronize is None: |
| import torch |
| synchronize = torch.cuda.synchronize |
| properties = torch.cuda.get_device_properties(torch.cuda.current_device()) |
| hardware = {'gpu_name': properties.name, |
| 'gpu_memory_bytes': properties.total_memory, |
| 'gpu_capability': list(torch.cuda.get_device_capability()), |
| 'gpu_uuid': str(getattr(properties, 'uuid', 'unavailable')), |
| 'torch_version': torch.__version__, 'cuda_version': torch.version.cuda} |
| self.synchronize = synchronize |
| self.metadata = {**(metadata or {}), **(hardware or {}), |
| 'protocol': PROTOCOL, 'evaluation_protocol': PROTOCOL, |
| 'noise_shape': list(self.noise_shape), |
| 'noise_protocol': 'numpy_PCG64_SeedSequence_policy_seed_sequence_float32', |
| 'transport_compression': None, 'reconnect_policy': 'abort_episode'} |
| self._active = False |
|
|
| def serve_forever(self): |
| asyncio.run(self.run()) |
|
|
| async def run(self): |
| from websockets.asyncio.server import serve |
| async with serve(self._handler, self.host, self.port, compression=None, |
| max_size=None, ping_interval=None, process_request=self._health_check) as server: |
| await server.serve_forever() |
|
|
| @staticmethod |
| def _health_check(connection, request): |
| if request.path == '/healthz': |
| return connection.respond(http.HTTPStatus.OK, 'OK\n') |
|
|
| async def _handler(self, websocket): |
| from websockets.exceptions import ConnectionClosed |
| packer = Packer() |
| if self._active: |
| await websocket.close(code=1013, reason='A policy client already owns this server') |
| return |
| self._active = True |
| session = ProtocolSession( |
| lambda observation, noise: infer_with_noise(self.policy, observation, noise), |
| self.noise_shape, self.synchronize) |
| try: |
| await websocket.send(packer.pack(self.metadata)) |
| while True: |
| raw = await websocket.recv() |
| if not isinstance(raw, bytes): |
| raise InfrastructureError('Expected a binary request') |
| started = time.perf_counter() |
| request = unpackb(raw) |
| unpack_ms = (time.perf_counter() - started) * 1000 |
| digest = hashlib.sha256(raw).hexdigest() |
| response, duplicate = session.process(request, digest) |
| started = time.perf_counter() |
| payload = packer.pack(response) |
| pack_ms = (time.perf_counter() - started) * 1000 |
| started = time.perf_counter() |
| await websocket.send(payload) |
| send_ms = (time.perf_counter() - started) * 1000 |
| append_record(self.log_path, { |
| 'timestamp': time.time(), 'session_id': response['session_id'], |
| 'episode_id': response['episode_id'], 'sequence_id': response['sequence_id'], |
| 'operation': request['operation'], 'duplicate': duplicate, |
| 'request_sha256': digest, 'noise_sha256': response['noise_sha256'], |
| 'request_bytes': len(raw), 'response_bytes': len(payload), |
| 'server_unpack_ms': unpack_ms, 'server_pack_ms': pack_ms, |
| 'server_send_ms': send_ms, 'server_infer_ms': response['server_infer_ms']}) |
| except ConnectionClosed: |
| pass |
| except Exception as error: |
| append_record(self.log_path, {'timestamp': time.time(), |
| 'event': 'infrastructure_error', 'error': str(error)}) |
| try: |
| await websocket.send(packer.pack({'protocol': PROTOCOL, 'error': str(error)})) |
| await websocket.close(code=1011, reason='Episode invalidated') |
| except ConnectionClosed: |
| pass |
| finally: |
| self._active = False |
|
|
|
|
| class HybridClient: |
| def __init__(self, host='127.0.0.1', port=9340, timeout=120, |
| log_path=None, _connection=None): |
| if not 0 < timeout <= 120: |
| raise ValueError('timeout must be in (0,120] seconds') |
| from websockets.sync.client import connect |
| self.timeout, self.log_path = timeout, log_path |
| self._packer = Packer() |
| self._ws = None |
| self._broken = False |
| self._session_id = self._episode_id = None |
| self._sequence = 0 |
| self._seed = None |
| self.metrics, self.last_metrics = [], None |
| try: |
| self._ws = _connection or connect( |
| f'ws://{host}:{port}', compression=None, max_size=None, |
| open_timeout=timeout, close_timeout=2, ping_interval=None) |
| metadata = unpackb(self._ws.recv(timeout=timeout)) |
| if metadata.get('protocol') != PROTOCOL: |
| raise InfrastructureError('Unexpected server protocol') |
| shape = metadata.get('noise_shape') |
| if not isinstance(shape, list) or len(shape) != 3 or any(type(x) is not int or x <= 0 for x in shape): |
| raise InfrastructureError('Invalid server noise shape') |
| self._metadata = metadata |
| except Exception as error: |
| self.close() |
| raise InfrastructureError(f'Policy connection failed: {error}') from error |
|
|
| def get_server_metadata(self): |
| return dict(self._metadata) |
|
|
| def reset(self, episode_id, policy_seed): |
| if self._broken: |
| raise InfrastructureError('Connection invalidated; restore scene and create a new client') |
| self._session_id = uuid.uuid4().hex |
| self._episode_id = str(episode_id) |
| self._sequence, self._seed = 0, int(policy_seed) |
| return self._request('reset', policy_seed=self._seed) |
|
|
| def infer(self, observation, noise=None): |
| if self._session_id is None: |
| raise InfrastructureError('reset() is required before inference') |
| sequence = self._sequence + 1 |
| if noise is None: |
| noise = generate_noise(self._seed, sequence, self._metadata['noise_shape']) |
| noise = validate_noise(noise, self._metadata['noise_shape']) |
| self._sequence = sequence |
| return self._request('infer', observation=observation, noise=noise) |
|
|
| def _request(self, operation, **values): |
| if self._broken or self._ws is None: |
| raise InfrastructureError('Connection invalidated; no automatic retry is permitted') |
| request = {'protocol': PROTOCOL, 'session_id': self._session_id, |
| 'episode_id': self._episode_id, 'sequence_id': self._sequence, |
| 'operation': operation, **values} |
| started = time.perf_counter() |
| raw = self._packer.pack(request) |
| pack_ms = (time.perf_counter() - started) * 1000 |
| digest = hashlib.sha256(raw).hexdigest() |
| started = time.perf_counter() |
| |
| |
| def abort_socket(): |
| connection_socket = getattr(self._ws, 'socket', None) |
| if connection_socket is not None: |
| try: |
| connection_socket.shutdown(socket.SHUT_RDWR) |
| except OSError: |
| pass |
| connection_socket.close() |
| watchdog = threading.Timer(self.timeout, abort_socket) |
| watchdog.daemon = True |
| watchdog.start() |
| try: |
| self._ws.send(raw) |
| remaining = self.timeout - (time.perf_counter() - started) |
| if remaining <= 0: |
| raise TimeoutError('Policy request deadline expired during send') |
| response_raw = self._ws.recv(timeout=remaining) |
| rtt_ms = (time.perf_counter() - started) * 1000 |
| if not isinstance(response_raw, bytes): |
| raise InfrastructureError('Expected a binary response') |
| started = time.perf_counter() |
| response = unpackb(response_raw) |
| unpack_ms = (time.perf_counter() - started) * 1000 |
| if response.get('error'): |
| raise InfrastructureError(response['error']) |
| for key in ('protocol', 'session_id', 'episode_id', 'sequence_id'): |
| if response.get(key) != request[key]: |
| raise InfrastructureError(f'Response identity mismatch: {key}') |
| if response.get('request_sha256') != digest: |
| raise InfrastructureError('Response request hash mismatch') |
| noise_hash = noise_sha256(values['noise']) if 'noise' in values else None |
| if response.get('noise_sha256') != noise_hash: |
| raise InfrastructureError('Response noise hash mismatch') |
| if not isinstance(response.get('result'), dict): |
| raise InfrastructureError('Invalid policy result') |
| for key in ('server_queue_ms', 'server_state_switch_ms', 'server_session_init_ms'): |
| if key in response and (type(response[key]) not in (int, float) or |
| not math.isfinite(response[key]) or response[key] < 0): |
| raise InfrastructureError('Invalid server timing: ' + key) |
| except Exception as error: |
| self._broken = True |
| self.close() |
| raise InfrastructureError(f'Policy request failed; episode must restart: {error}') from error |
| finally: |
| watchdog.cancel() |
| metric = {'timestamp': time.time(), 'session_id': self._session_id, |
| 'episode_id': self._episode_id, 'sequence_id': self._sequence, |
| 'operation': operation, 'request_sha256': digest, |
| 'noise_sha256': noise_hash, 'client_pack_ms': pack_ms, |
| 'client_rtt_ms': rtt_ms, 'client_unpack_ms': unpack_ms, |
| 'request_bytes': len(raw), 'response_bytes': len(response_raw), |
| 'server_infer_ms': response['server_infer_ms']} |
| for key in ('server_queue_ms', 'server_state_switch_ms', 'server_session_init_ms', |
| 'server_fifo_index', 'server_pending_at_enqueue', 'concurrency_protocol'): |
| if key in response: |
| metric[key] = response[key] |
| self.last_metrics = metric |
| self.metrics.append(metric) |
| append_record(self.log_path, metric) |
| return response['result'] |
|
|
| def close(self): |
| if self._ws is not None: |
| try: |
| self._ws.close() |
| except Exception: |
| pass |
| self._ws = None |
|
|
|
|
| HybridClientPolicy = HybridClient |
|
|
