assests / common /source /starBenchserver /benchmarks /simBenchmarks /SIMPLE /bench_server /adapter.py
| """SIMPLE declared-sensor humanoid tracks with a private native WBC worker. | |
| No simulator, torch, WBC training package, or native task module is imported here. | |
| The 36D public action is physical joint/nav targets, NOT a 7D arm delta action. | |
| """ | |
| from __future__ import annotations | |
| import hashlib | |
| import json | |
| import math | |
| from numbers import Real | |
| from pathlib import Path | |
| from typing import Any, Mapping, Sequence | |
| from benchkit.contracts import ( | |
| ActionSpec, BenchmarkDescriptor, EpisodeSpec, Observation, ObservationSpec, Transition, | |
| ) | |
| from benchkit.errors import CompatibilityError, ProtocolError | |
| from benchmarks.simBenchmarks.SIMPLE.bench_server.native_worker_client import NativeWorkerClient | |
| SIMPLE_REVISION = "5e3d6f84e85343e34e9bca8d157f0d7813231185" | |
| TRACK = "simple-native-wbc-development-v1" | |
| SEED = 20260907 | |
| TASKS = ("G1WholebodyBendPickMP-v0", "G1WholebodyOpenFaucetTeleop-v0") | |
| INSTRUCTIONS = ("bend to pick up the cracker box", "move forward to the faucet and open it") | |
| INVENTORY_PATH = Path(__file__).with_name("protocol") / "simple_released_tasks.json" | |
| TASK_INVENTORY = json.loads(INVENTORY_PATH.read_text()) | |
| INVENTORY_SHA256 = hashlib.sha256(INVENTORY_PATH.read_bytes()).hexdigest() | |
| TASK_CONFIGS = {row["task_id"]: row for row in TASK_INVENTORY["tasks"]} | |
| FULL_TASKS = tuple(TASK_CONFIGS) | |
| HORIZONS = {task: row["reference_native_horizon"] for task, row in TASK_CONFIGS.items()} | |
| def task_config(task: str, task_scope: str = "pilot") -> Mapping[str, Any]: | |
| """Select an explicit frozen scope without expanding legacy pilot defaults.""" | |
| if task_scope not in ("pilot", "released-12"): | |
| raise ValueError("task_scope must be pilot or released-12") | |
| if not isinstance(task, str) or task not in (TASKS if task_scope == "pilot" else FULL_TASKS): | |
| raise ValueError(f"task outside the frozen SIMPLE {task_scope} scope") | |
| config = TASK_CONFIGS[task] | |
| if config["backend_gate"] or config["backend"] not in ("amo", "sonic"): | |
| raise CompatibilityError(f"unsupported native SIMPLE backend: {config['backend_gate']}") | |
| return config | |
| ARM_SUFFIXES = ( | |
| "shoulder_pitch_joint", "shoulder_roll_joint", "shoulder_yaw_joint", "elbow_joint", | |
| "wrist_roll_joint", "wrist_pitch_joint", "wrist_yaw_joint", | |
| ) | |
| # These names explicitly preserve the aligned PSI0 codec's legacy left hand order. | |
| LEFT_HAND = tuple("left_hand_" + name + "_joint" for name in ( | |
| "thumb_0", "thumb_1", "thumb_2", "middle_0", "middle_1", "index_0", "index_1", | |
| )) | |
| RIGHT_HAND = tuple("right_hand_" + name + "_joint" for name in ( | |
| "thumb_0", "thumb_1", "thumb_2", "index_0", "index_1", "middle_0", "middle_1", | |
| )) | |
| ACTION_NAMES = ( | |
| *LEFT_HAND, *RIGHT_HAND, | |
| *("left_" + name for name in ARM_SUFFIXES), | |
| *("right_" + name for name in ARM_SUFFIXES), | |
| "waist_roll_joint", "waist_pitch_joint", "waist_yaw_joint", | |
| "base_height_m", "forward_velocity_m_s", "lateral_velocity_m_s", | |
| "native_turn_command", "target_yaw_rad", | |
| ) | |
| ACTION_SPEC = ActionSpec( | |
| mode="simple_physical_joint_nav_36", size=36, names=ACTION_NAMES, | |
| control_hz=50.0, frame="native G1 joint coordinates; native controller navigation frame", | |
| rotation="joint radians; waist roll,pitch,yaw; heading radians", | |
| gripper="14 individual dexterous hand joint position targets (radians)", | |
| ) | |
| def decode_action(values: Sequence[float]) -> dict[str, Any]: | |
| """Extract only physical commands; no normalization or learned statistics.""" | |
| vector = ACTION_SPEC.validate(values) | |
| return { | |
| "joint_positions": dict(zip(ACTION_NAMES[:31], vector[:31])), | |
| "base_height": vector[31], "navigate_cmd": (vector[32], vector[33], vector[34], vector[35]), | |
| } | |
| def amo_payload(values: Sequence[float], stabilized_torso_ypr: Sequence[float]) -> dict[str, Any]: | |
| """Aligned MP mapping: waist targets must NOT replace AMO torso orientation.""" | |
| command = decode_action(values) | |
| torso = tuple(float(value) for value in stabilized_torso_ypr) | |
| if len(torso) != 3 or not all(math.isfinite(value) for value in torso): | |
| raise ProtocolError("native stabilized AMO torso must be finite YPR") | |
| joints = command["joint_positions"] | |
| vx, vy, yaw_rate, target_yaw = command["navigate_cmd"] | |
| return { | |
| "target_qpos": {name: value for name, value in joints.items() if not name.startswith("waist_")}, | |
| "waist_qpos": {name: value for name, value in joints.items() if name.startswith("waist_")}, | |
| "action_command": [vx, target_yaw, vy, command["base_height"] - 0.75, *torso, yaw_rate], | |
| } | |
| def public_observation(raw: Mapping[str, Any], step: int, instruction: str, | |
| proprioception: bool = False) -> Observation: | |
| """RGB and optional named robot encoders; no task state, scores or native info.""" | |
| import numpy as np | |
| if "head_stereo_left" not in raw: | |
| raise ProtocolError("native observation omitted head_stereo_left") | |
| frame = np.asarray(raw["head_stereo_left"]) | |
| if frame.dtype != np.uint8 or frame.shape != (360, 640, 3): | |
| raise ProtocolError("head_stereo_left must be native 360x640 uint8 RGB") | |
| if not isinstance(instruction, str) or not instruction.strip(): | |
| raise ProtocolError("native language instruction is missing") | |
| state = None | |
| if proprioception: | |
| joints = raw.get("joint_positions") | |
| if not isinstance(joints, Mapping) or set(joints) != set(ACTION_NAMES[:31]): | |
| raise ProtocolError("proprioception requires exactly the 31 declared joint encoders") | |
| state = tuple(float(joints[name]) for name in ACTION_NAMES[:31]) | |
| if not all(math.isfinite(value) for value in state): | |
| raise ProtocolError("joint encoders must be finite") | |
| return Observation(step=step, instruction=instruction, images={"head_stereo_left": frame.copy()}, state=state) | |
| def validate_tick_result(message: Mapping[str, Any], expected_steps: int) -> tuple[bool, bool, bool, float]: | |
| """Fail closed on malformed worker fields; do not coerce RPC truthiness.""" | |
| for name in ("success", "terminated", "truncated"): | |
| if type(message.get(name)) is not bool: | |
| raise ProtocolError(f"native RPC {name} must be a JSON boolean") | |
| reward = message.get("reward") | |
| if isinstance(reward, bool) or not isinstance(reward, Real) or not math.isfinite(float(reward)): | |
| raise ProtocolError("native RPC reward must be a finite real number") | |
| if type(message.get("native_steps")) is not int or message["native_steps"] != expected_steps: | |
| raise ProtocolError("native RPC step counter differs from the requested single tick") | |
| return message["success"], message["terminated"], message["truncated"], float(reward) | |
| class SimpleHumanoidEpisode(NativeWorkerClient): | |
| def __init__(self, benchmark: SimpleHumanoidBenchmarkAdapter, episode: EpisodeSpec) -> None: | |
| super().__init__(benchmark, episode) | |
| self.steps = 0 | |
| self.success = False | |
| self.finished = False | |
| self.return_sum = 0.0 | |
| def _observation(self, message: Mapping[str, Any]) -> Observation: | |
| import numpy as np | |
| from PIL import Image | |
| assert self.artifact_dir is not None | |
| frame = (self.artifact_dir / str(message["frame"])).resolve() | |
| if not frame.is_relative_to(self.artifact_dir): | |
| raise ProtocolError("worker image path escaped this episode artifact directory") | |
| with Image.open(frame) as image: | |
| raw = {"head_stereo_left": np.asarray(image).copy()} | |
| if self.benchmark.proprioception: | |
| raw["joint_positions"] = message["joint_positions"] | |
| return public_observation(raw, self.steps, str(message["instruction"]), self.benchmark.proprioception) | |
| def reset(self) -> Observation: | |
| self._start_worker() | |
| source = self.benchmark.simple_root | |
| result = self._rpc({"op": "reset", "task": self.episode.task, "seed": self.episode.seed, | |
| "artifact_dir": str(self.artifact_dir), "simple_root": str(source), | |
| "eval_root": str(self.benchmark.eval_root), "diagnostic": self.benchmark.diagnostic, | |
| "budget_mode": self.benchmark.budget_mode, "environment_step_cap": self.benchmark.environment_step_cap, | |
| "max_policy_calls": self.benchmark.max_policy_calls, "replan_interval": self.benchmark.replan_interval, | |
| "proprioception": self.benchmark.proprioception, "protocol_version": self.benchmark.descriptor.protocol_version, | |
| "task_scope": self.benchmark.task_scope}) | |
| if result["native_horizon"] != HORIZONS[self.episode.task]: | |
| raise CompatibilityError("native task horizon changed") | |
| self.worker_artifacts = result.get("artifacts", {}) | |
| return self._observation(result) | |
| def step(self, action: Sequence[float]) -> Transition: | |
| if self.finished: | |
| raise ProtocolError("cannot step a finished SIMPLE episode") | |
| result = self._rpc({"op": "step", "action": self.benchmark.action_spec.validate(action)}) | |
| success, terminated, truncated, reward = validate_tick_result(result, self.steps + 1) | |
| self.steps += 1 | |
| self.success = success | |
| self.finished = terminated or truncated | |
| self.return_sum += reward | |
| return Transition(self._observation(result), reward, terminated, truncated, | |
| {"native_success": self.success, "native_steps": self.steps}) | |
| def diagnostic_hold(self) -> Transition: | |
| """Evaluator-only one-tick probe; never exposed to policy or rollout RPC.""" | |
| if not self.benchmark.diagnostic or self.steps: | |
| raise ProtocolError("hold is restricted to the first diagnostic tick") | |
| result = self._rpc({"op": "diagnostic_hold"}) | |
| success, terminated, truncated, reward = validate_tick_result(result, self.steps + 1) | |
| self.steps += 1 | |
| self.success = success | |
| self.finished = terminated or truncated | |
| self.return_sum += reward | |
| return Transition(self._observation(result), reward, terminated, truncated, | |
| {"native_success": self.success, "native_steps": self.steps}) | |
| def metrics(self) -> Mapping[str, Any]: | |
| return {"success": self.success, "native_steps": self.steps, "native_return": self.return_sum, | |
| "reference_native_horizon": HORIZONS[self.episode.task], | |
| "environment_step_cap": self.benchmark.environment_step_cap, | |
| "track": self.benchmark.descriptor.protocol_version, | |
| "diagnostic_only": self.benchmark.diagnostic} | |
| class SimpleHumanoidBenchmarkAdapter: | |
| """One native task/backend per runner; expansion requires an explicit scope.""" | |
| def __init__(self, simple_root: str = "/mnt/workspace/users/jinhuiye/SIMPLE-5e3d6f8", | |
| eval_root: str = "/mnt/workspace/users/jinhuiye/SIMPLE/data/evals", gpu_id: int = 4, | |
| task_names: Sequence[str] = (TASKS[0],), worker_timeout: float = 900, | |
| diagnostic: bool = False, proprioception: bool = True, budget_mode: str = "decisions", | |
| max_policy_calls: int = 200, replan_interval: int = 5, task_scope: str = "pilot") -> None: | |
| self.simple_root, self.eval_root = Path(simple_root).resolve(), Path(eval_root).resolve() | |
| if type(gpu_id) is not int or gpu_id < 0: | |
| raise ValueError("gpu_id must be a nonnegative integer") | |
| if isinstance(worker_timeout, bool) or not isinstance(worker_timeout, Real) or not math.isfinite(worker_timeout) or worker_timeout <= 0: | |
| raise ValueError("worker_timeout must be a positive finite number") | |
| if type(diagnostic) is not bool: | |
| raise ValueError("diagnostic must be an explicit boolean") | |
| self.gpu_id, self.worker_timeout, self.diagnostic = gpu_id, float(worker_timeout), diagnostic | |
| self.task_names = tuple(task_names) | |
| if len(self.task_names) != 1: | |
| raise ValueError("choose exactly one SIMPLE task/backend per adapter/runner") | |
| config = task_config(self.task_names[0], task_scope) | |
| self.task_scope = task_scope | |
| if budget_mode not in ("decisions", "horizon"): | |
| raise ValueError("budget_mode must be decisions or horizon") | |
| if type(max_policy_calls) is not int or max_policy_calls != 200 or type(replan_interval) is not int or replan_interval != 5: | |
| raise ValueError("this frozen development track requires 200 policy calls and prefix cap 5") | |
| if type(proprioception) is not bool: | |
| raise ValueError("proprioception must be an explicit boolean") | |
| if task_scope == "released-12" and (not proprioception or budget_mode != "decisions"): | |
| raise ValueError("released-12 requires RGB+qpos31 and the decision-200-prefix-5 track") | |
| self.proprioception, self.budget_mode = proprioception, budget_mode | |
| self.max_policy_calls, self.replan_interval = max_policy_calls, replan_interval | |
| self.native_horizon = HORIZONS[self.task_names[0]] | |
| self.environment_step_cap = 1000 if budget_mode == "decisions" else self.native_horizon | |
| backend = config["backend"] | |
| self.backend = backend | |
| names = list(ACTION_NAMES) | |
| names[34] = "turning_flag" if backend == "amo" else "turning_gate" | |
| self.action_spec = ActionSpec(mode=f"simple_{backend}_physical_joint_nav_36", size=36, | |
| names=tuple(names), control_hz=50.0, frame=ACTION_SPEC.frame, | |
| rotation=ACTION_SPEC.rotation, gripper=ACTION_SPEC.gripper) | |
| self.observation_spec = ObservationSpec(cameras=("head_stereo_left",), | |
| state_names=ACTION_NAMES[:31] if proprioception else (), | |
| modalities=("rgb", "language", "proprioception") if proprioception else ("rgb", "language")) | |
| modality = "rgb-qpos31" if proprioception else "rgb" | |
| budget = "decision-200-prefix-5" if budget_mode == "decisions" else f"native-horizon-{self.native_horizon}-200calls-prefix5" | |
| prefix = "simple" if task_scope == "pilot" else "simple/released-12" | |
| self.descriptor = BenchmarkDescriptor("simple_humanoid", "5e3d6f8-patched-native", | |
| f"{prefix}/{backend}/{modality}/{budget}/v2", SIMPLE_REVISION) | |
| def episodes(self, seed: int = SEED, limit: int | None = None) -> Sequence[EpisodeSpec]: | |
| if type(seed) is not int or seed != SEED: | |
| raise ProtocolError(f"frozen SIMPLE development seed is {SEED}") | |
| if limit is not None and (type(limit) is not int or limit <= 0): | |
| raise ValueError("episode limit must be a positive integer or None") | |
| episodes = tuple(EpisodeSpec(id=f"{task}/dr0/ep0", task=task, seed=SEED, | |
| instruction=TASK_CONFIGS[task]["instruction"], metadata={"dr_level": 0, "episode_index": 0, | |
| "reference_native_horizon": HORIZONS[task], "environment_step_cap": self.environment_step_cap, | |
| "budget_mode": self.budget_mode, "track": self.descriptor.protocol_version, | |
| **({"task_scope": self.task_scope, "task_inventory_sha256": INVENTORY_SHA256, | |
| "native_task_uid": TASK_CONFIGS[task]["task_uid"], "native_backend": self.backend, | |
| "reset_metadata_sha256": TASK_CONFIGS[task]["reset_metadata_sha256"], | |
| "environment_config_sha256": TASK_CONFIGS[task]["environment_config_sha256"]} | |
| if self.task_scope == "released-12" else {})}) for task in self.task_names) | |
| return episodes if limit is None else episodes[:limit] | |
| def open_episode(self, episode: EpisodeSpec) -> SimpleHumanoidEpisode: | |
| if episode not in self.episodes(): | |
| raise ProtocolError("episode differs from the frozen SIMPLE task manifest") | |
| return SimpleHumanoidEpisode(self, episode) | |
| def aggregate(self, metrics: Sequence[Mapping[str, Any]]) -> Mapping[str, Any]: | |
| count = len(metrics) | |
| return {"episodes": count, "successes": sum(bool(item["success"]) for item in metrics), | |
| "success_rate": sum(bool(item["success"]) for item in metrics) / count if count else 0.0} | |
| def make_simple_humanoid(parameters: Mapping[str, Any]) -> SimpleHumanoidBenchmarkAdapter: | |
| """CLI construction remains dependency-free; native imports happen at reset.""" | |
| return SimpleHumanoidBenchmarkAdapter(**dict(parameters)) | |