assests / common /source /starBenchserver /benchmarks /simBenchmarks /Robotwin /bench_server /adapter.py
| """RoboTwin clean fixed-seed track: RGB, language and robot state to native qpos.""" | |
| from __future__ import annotations | |
| import gc | |
| import hashlib | |
| from pathlib import Path | |
| from typing import Any, Mapping, Sequence | |
| from benchkit.artifacts import append_jsonl, atomic_write_json | |
| from benchkit.contracts import (ActionSpec, BenchmarkDescriptor, EpisodeSpec, JsonValue, | |
| Observation, ObservationSpec, Transition) | |
| from benchkit.errors import CompatibilityError, ProtocolError | |
| from benchkit.registry import register_benchmark | |
| from benchmarks.simBenchmarks.Robotwin.environment import official, runtime | |
| CAMERAS = ("head_camera", "left_camera", "right_camera") | |
| IMAGE_SHAPE = (240, 320, 3) | |
| NATIVE_HORIZON = 400 | |
| PROTOCOL = "robotwin-local-content/clean-fixed-seed/qpos14-rgb320-state14/fast-v3" | |
| COMPAT_PROTOCOL = "robotwin-local-content/clean-fixed-seed/qpos14-rgb320-state14-oidn233/fast-v4" | |
| def policy_observation(raw: Any, step: int, instruction: str, state: Sequence[float]) -> Observation: | |
| import numpy as np | |
| if not isinstance(raw, Mapping) or not isinstance(raw.get("observation"), Mapping): | |
| raise ProtocolError("native RoboTwin observation must contain cameras") | |
| images = {} | |
| for camera in CAMERAS: | |
| item = raw["observation"].get(camera) | |
| frame = item.get("rgb") if isinstance(item, Mapping) else None | |
| if not isinstance(frame, np.ndarray) or frame.shape != IMAGE_SHAPE or frame.dtype != np.uint8: | |
| raise ProtocolError(f"RoboTwin {camera} must be native 240x320 uint8 RGB") | |
| images[camera] = np.array(frame, copy=True, order="C") | |
| # joint_action.vector is commanded drive targets, NOT measured encoders. | |
| # State is supplied separately by the declared native measured-state APIs. | |
| # No endpose, front view, calibration, task info, reset seed or native score. | |
| return Observation(step=step, instruction=instruction, images=images, | |
| state=runtime.validate_robot_state(state)) | |
| class RoboTwinEpisode: | |
| def __init__(self, benchmark: RoboTwinBenchmarkAdapter, episode: EpisodeSpec): | |
| self.benchmark, self.episode = benchmark, episode | |
| self.env = None | |
| self.scene_counter = None | |
| self.artifact_dir: Path | None = None | |
| self.writers = {} | |
| self.jit_cache = None | |
| self.step_count = self.native_steps = self.physics_ticks = 0 | |
| self.acknowledged_controls = 0 | |
| self.native_reset_returned = False | |
| self.reset_completed = False | |
| self.success = self.finished = self.reset_attempted = self.closed = self.finalized = False | |
| self.close_error: BaseException | None = None | |
| self.top_events = [] | |
| self.control_error = False | |
| self.provenance = None | |
| def bind_artifact_dir(self, path: Path) -> None: | |
| if self.artifact_dir is not None or self.reset_attempted or self.closed or self.finalized: | |
| raise ProtocolError("RoboTwin artifacts must be bound once before reset") | |
| path.mkdir(parents=True, exist_ok=True) | |
| self.artifact_dir = path.resolve() | |
| def _log(self, event: str, **values) -> None: | |
| if self.artifact_dir is not None: | |
| append_jsonl(self.artifact_dir / "native_events.jsonl", {"event": event, **values}) | |
| def reset(self) -> Observation: | |
| if self.reset_attempted or self.closed or self.finalized: | |
| raise ProtocolError("RoboTwin permits one reset attempt per predeclared episode") | |
| self.reset_attempted = True | |
| try: | |
| if self.artifact_dir is None: | |
| raise ProtocolError("RoboTwin native reset requires a model-owned artifact directory for its private JIT cache") | |
| self.jit_cache = self.artifact_dir / "cache" / "curobo-jit" | |
| self.jit_cache.mkdir(parents=True, exist_ok=False) | |
| if self.benchmark.deployment_track == official.TRACK: | |
| self.provenance = official.readiness(self.benchmark.source_root, | |
| self.benchmark.deployment_manifest_sha256) | |
| else: | |
| self.provenance = runtime.readiness(self.benchmark.source_root, | |
| self.benchmark.deployment_manifest_sha256, | |
| self.benchmark.renderer_runtime) | |
| self.provenance["protocol_version"] = self.benchmark.descriptor.protocol_version | |
| # Retain the verified runtime choice even if native import/setup fails. | |
| atomic_write_json(self.artifact_dir / "native_provenance.json", self.provenance) | |
| self._log("native_construction_start", task=self.episode.task, | |
| native_seed=self.benchmark.native_seed, expert_screening=False) | |
| with runtime.native_directory(self.benchmark.source_root, self.jit_cache): | |
| native_runtime = official if self.benchmark.deployment_track == official.TRACK else runtime | |
| self.env = native_runtime.create_native(self.benchmark.source_root, self.episode.task) | |
| runtime.verify_loaded_renderer(self.provenance, require_cuda_plugin=False) | |
| config = native_runtime.resolved_native_config(self.benchmark.source_root, self.episode.task) | |
| self._log("reset_start", native_seed=self.benchmark.native_seed, | |
| initialization="native setup_demo, homestate/open-gripper/planner initialization/stability checks; no expert play_once") | |
| self.env.setup_demo(now_ep_num=0, seed=self.benchmark.native_seed, is_test=True, **config) | |
| self.native_reset_returned = True | |
| self._log("reset_returned") | |
| compiled = runtime.verify_compiled_control(self.env) | |
| # Native initialization is unchanged. Only subsequent task-side | |
| # scene.step calls are counted; no C++ scene handle is replaced. | |
| self.scene_counter = runtime.SceneStepCounter(self.env.scene) | |
| self.env.scene = self.scene_counter | |
| for side in ("left", "right"): | |
| name = f"{side}_mplib_planner" | |
| setattr(self.env.robot, name, runtime.TOPPRecorder(getattr(self.env.robot, name), side, self.top_events)) | |
| self.provenance.update({"task": self.episode.task, "native_seed": self.benchmark.native_seed, | |
| "evaluation_mode": "fast", "sample_selection": "one predeclared unscreened native seed", | |
| "native_source_revision": self.benchmark.native_source_revision, "compiled_contract": compiled, | |
| "resolved_native_config": config, "protocol_version": self.benchmark.descriptor.protocol_version, | |
| "instruction_source": f"description/task_instruction/{self.episode.task}.json:full_description", | |
| "observation": {"cameras": list(CAMERAS), "shape": list(IMAGE_SHAPE), | |
| "image_transform": "none; copy native RGB bytes", | |
| "state": runtime.state_provenance()}, | |
| "initialization_physics_ticks": None, | |
| "initialization_count_note": "native setup includes stability settling; not instrumented or counted as model controls", | |
| "jit_cache": {"path": str(self.jit_cache), "source": "per-episode evaluator-owned TORCH_EXTENSIONS_DIR", | |
| "excluded_from_artifact_transfer": True, "identity": "derived native CUDA build cache; not loaded-memory attestation"}, | |
| "video_timebase": "10-fps presentation of one public frame per control, not physical control frequency"}) | |
| if self.artifact_dir is not None: | |
| atomic_write_json(self.artifact_dir / "native_provenance.json", self.provenance) | |
| self._log("reset_end", native_horizon=NATIVE_HORIZON, policy_controls=0) | |
| observation = self._observe() | |
| renderer_loaded = runtime.verify_loaded_renderer(self.provenance, require_cuda_plugin=True) | |
| if renderer_loaded: | |
| self.provenance["renderer_loaded_paths"] = renderer_loaded | |
| atomic_write_json(self.artifact_dir / "native_provenance.json", self.provenance) | |
| self.reset_completed = True | |
| return observation | |
| except BaseException: | |
| self.finished = True | |
| try: | |
| self.close() | |
| except Exception as exc: | |
| self._log("reset_cleanup_error", error_type=type(exc).__name__) | |
| raise | |
| def _observe(self) -> Observation: | |
| observation = policy_observation(self.env.get_obs(), self.step_count, self.episode.instruction, | |
| runtime.robot_state(self.env)) | |
| if self.artifact_dir is not None: | |
| import imageio.v2 as imageio | |
| from PIL import Image | |
| for camera, frame in observation.images.items(): | |
| path = self.artifact_dir / f"{camera}-{self.step_count:06d}.png" | |
| Image.fromarray(frame).save(path) | |
| if camera not in self.writers: | |
| self.writers[camera] = imageio.get_writer(str(self.artifact_dir / f"{camera}.mp4"), | |
| fps=10, codec="libx264", macro_block_size=1) | |
| self.writers[camera].append_data(frame) | |
| append_jsonl(self.artifact_dir / "frames.jsonl", { | |
| "camera": camera, "step": self.step_count, "control": self.step_count, "policy_physics_ticks": self.physics_ticks, | |
| "policy_simulated_seconds": self.physics_ticks / 250, "path": path.name, | |
| "sha256": hashlib.sha256(path.read_bytes()).hexdigest(), | |
| "rgb_sha256": hashlib.sha256(frame.tobytes()).hexdigest(), | |
| }) | |
| return observation | |
| def step(self, action: tuple[float, ...]) -> Transition: | |
| if self.env is None or self.closed or self.finished or self.finalized: | |
| raise ProtocolError("cannot control an uninitialized or finished RoboTwin episode") | |
| vector = self.benchmark.action_spec.validate(action) | |
| if self.native_steps >= NATIVE_HORIZON: | |
| raise ProtocolError("native RoboTwin control horizon exhausted") | |
| previous_top = len(self.top_events) | |
| self._log("action_start", control=self.step_count + 1, action=list(vector), action_type="qpos") | |
| try: | |
| with runtime.native_directory(self.benchmark.source_root, self.jit_cache): | |
| self.env.take_action(vector, action_type="qpos") | |
| self.native_steps = int(self.env.take_action_cnt) | |
| self.physics_ticks = self.scene_counter.steps | |
| if self.native_steps != self.step_count + 1 or type(self.env.eval_success) is not bool: | |
| raise ProtocolError("native RoboTwin control count or cached success differs") | |
| self.step_count += 1 | |
| self.success = self.env.eval_success # Native take_action checks success each physics tick. | |
| self.finished = self.success or self.native_steps >= NATIVE_HORIZON | |
| self._log("action_end", control=self.step_count, native_steps=self.native_steps, | |
| policy_physics_ticks=self.physics_ticks, native_success=self.success, | |
| native_topp=self.top_events[previous_top:]) | |
| observation = self._observe() | |
| transition = Transition(observation=observation, reward=float(self.success), terminated=self.success, | |
| truncated=self.finished and not self.success, | |
| info={"native_success": self.success, "native_steps": self.native_steps, | |
| "policy_physics_ticks": self.physics_ticks}) | |
| self.acknowledged_controls += 1 | |
| return transition | |
| except BaseException: | |
| self.finished = self.control_error = True | |
| self.native_steps = int(getattr(self.env, "take_action_cnt", self.native_steps)) | |
| self.physics_ticks = self.scene_counter.steps | |
| self._log("action_error", native_started_controls=self.native_steps, | |
| acknowledged_controls=self.acknowledged_controls, completed_physics_ticks=self.physics_ticks, | |
| native_topp=self.top_events[previous_top:], replay_allowed=False) | |
| raise | |
| def metrics(self) -> Mapping[str, JsonValue]: | |
| return {"success": self.success, "native_steps": self.native_steps, | |
| "acknowledged_controls": self.acknowledged_controls, "completed_native_controls": self.step_count, | |
| "native_horizon": NATIVE_HORIZON, "reset_attempted": self.reset_attempted, | |
| "native_reset_returned": self.native_reset_returned, "reset_completed": self.reset_completed, | |
| "policy_physics_ticks": self.physics_ticks, "policy_simulated_seconds": self.physics_ticks / 250, | |
| "initialization_physics_ticks": None, "native_source_revision": self.benchmark.native_source_revision, | |
| "reward_semantics": "wrapper numeric encoding of cached native success; no shaped reward", | |
| "control_error": self.control_error, | |
| "native_topp_fallbacks": sum(row["status"] != "native_path" for row in self.top_events), | |
| "counter_scope": "started native qpos targets and completed task-side physics steps; errored native calls are never replayed"} | |
| def _close_writers(self) -> None: | |
| writers, self.writers = self.writers, {} | |
| errors = [] | |
| for writer in writers.values(): | |
| try: | |
| writer.close() | |
| except BaseException as exc: | |
| errors.append(exc) | |
| if errors: | |
| raise ProtocolError("RoboTwin media finalization failed") from errors[0] | |
| def artifacts(self) -> Mapping[str, str]: | |
| self.finalized = True | |
| self._close_writers() | |
| if self.artifact_dir is None: | |
| return {} | |
| files = {f"{camera}_video": f"{camera}.mp4" for camera in CAMERAS} | |
| files.update({"frames": "frames.jsonl", "native_events": "native_events.jsonl", | |
| "native_provenance": "native_provenance.json", "native_cleanup": "native_cleanup.json"}) | |
| return {key: str(self.artifact_dir / name) for key, name in files.items() | |
| if (self.artifact_dir / name).is_file()} | |
| def close(self) -> None: | |
| if self.closed: | |
| if self.close_error is not None: | |
| raise ProtocolError("previous RoboTwin cleanup failed") from self.close_error | |
| return | |
| self.closed = True | |
| errors = [] | |
| try: | |
| self._close_writers() | |
| except BaseException as exc: | |
| errors.append(exc) | |
| env, self.env = self.env, None | |
| native_returned = False | |
| if env is not None: | |
| try: | |
| if self.scene_counter is not None: | |
| env.scene = self.scene_counter.scene | |
| with runtime.native_directory(self.benchmark.source_root, self.jit_cache): | |
| env.close_env() | |
| native_returned = True | |
| except BaseException as exc: | |
| errors.append(exc) | |
| self.scene_counter = None | |
| del env | |
| gc.collect() | |
| if self.artifact_dir is not None: | |
| try: | |
| atomic_write_json(self.artifact_dir / "native_cleanup.json", { | |
| "native_close_returned": native_returned, "python_references_released": True, | |
| "error_types": [type(exc).__name__ for exc in errors], | |
| "scope": "native close_env and reference release; native gym close does not attest GPU reclamation; stop this one-episode server process after result transfer", | |
| }) | |
| except BaseException as exc: | |
| errors.append(exc) | |
| if errors: | |
| self.close_error = errors[0] | |
| raise ProtocolError("RoboTwin native cleanup failed") from errors[0] | |
| class RoboTwinBenchmarkAdapter: | |
| budget_mode = "horizon" | |
| environment_step_cap = NATIVE_HORIZON | |
| def __init__(self, source_root: str, deployment_manifest_sha256: str, task: str = "lift_pot", | |
| native_seed: int = 100000, evaluation_mode: str = "fast", | |
| renderer_runtime: str = runtime.BUNDLED_RENDERER, | |
| deployment_track: str = "local_archive"): | |
| if (not isinstance(source_root, str) or not source_root or not Path(source_root).is_absolute() | |
| or ".." in Path(source_root).parts): | |
| raise ValueError("source_root must be an explicit absolute deployment path") | |
| if (not isinstance(deployment_manifest_sha256, str) or len(deployment_manifest_sha256) != 64 | |
| or any(c not in "0123456789abcdef" for c in deployment_manifest_sha256)): | |
| raise ValueError("deployment_manifest_sha256 must be 64 lowercase hexadecimal characters") | |
| if not isinstance(task, str) or task not in runtime.TASK_INSTRUCTIONS or evaluation_mode != "fast": | |
| raise ValueError("only explicit clean lift_pot/click_bell fast tasks are implemented; native full is unsupported") | |
| if type(native_seed) is not int or not 0 <= native_seed < 2**32: | |
| raise ValueError("native_seed must be an integer in [0, 2**32)") | |
| if not isinstance(renderer_runtime, str) or renderer_runtime not in runtime.RENDERER_RUNTIMES: | |
| raise ValueError("renderer_runtime must be a declared pinned track") | |
| if deployment_track not in ("local_archive", official.TRACK): | |
| raise ValueError("deployment_track must be a declared source/runtime track") | |
| if deployment_track == official.TRACK and renderer_runtime != runtime.BUNDLED_RENDERER: | |
| raise ValueError("official track cannot select an archived renderer overlay") | |
| self.source_root = Path(source_root) | |
| self.deployment_manifest_sha256 = deployment_manifest_sha256 | |
| self.task, self.native_seed = task, native_seed | |
| self.renderer_runtime = renderer_runtime | |
| self.deployment_track = deployment_track | |
| self.native_source_revision = official.REVISION if deployment_track == official.TRACK else None | |
| self.claimed = False | |
| def descriptor(self) -> BenchmarkDescriptor: | |
| if self.deployment_track == official.TRACK: | |
| return BenchmarkDescriptor(name="robotwin", version="official-2.0-clean-development", | |
| protocol_version=official.PROTOCOL, source_revision=official.REVISION) | |
| return BenchmarkDescriptor(name="robotwin", version="local-2.0-clean-development", | |
| protocol_version=(PROTOCOL if self.renderer_runtime == runtime.BUNDLED_RENDERER else COMPAT_PROTOCOL), | |
| source_revision=f"content-inventory-sha256:{runtime.NATIVE_INVENTORY_SHA256}") | |
| def observation_spec(self) -> ObservationSpec: | |
| return ObservationSpec(cameras=CAMERAS, state_names=runtime.STATE_NAMES, | |
| modalities=("language", "rgb", "joint_position", "gripper_command"), privileged=False) | |
| def action_spec(self) -> ActionSpec: | |
| names = (*runtime.JOINT_NAMES[:6], "left_gripper", *runtime.JOINT_NAMES[6:], "right_gripper") | |
| return ActionSpec(mode="robotwin_aloha_absolute_joint_targets", size=14, names=names, | |
| low=((-10.0,) * 6 + (0.0,)) * 2, high=((10.0,) * 6 + (1.0,)) * 2, | |
| control_hz=None, frame="absolute native Aloha arm joint coordinates in radians", | |
| rotation="joint coordinates; no EEF pose, IK or task planning interface", | |
| gripper="normalized absolute native gripper command: 0 closed, 1 open; native scale [-0.01,0.045] m") | |
| def episodes(self, seed: int, limit: int | None = None) -> Sequence[EpisodeSpec]: | |
| if type(seed) is not int or not 0 <= seed < 2**32: | |
| raise ValueError("harness seed must be an integer in [0, 2**32)") | |
| if limit is not None and (type(limit) is not int or limit != 1): | |
| raise ValueError("this single-task server permits exactly one episode") | |
| return (EpisodeSpec(id=f"{self.task}-native-seed{self.native_seed}-episode000", task=self.task, | |
| seed=seed, instruction=runtime.TASK_INSTRUCTIONS[self.task], metadata={ | |
| "evaluation_mode": "fast", "native_seed": self.native_seed, | |
| "task_config": "demo_clean", "native_horizon": NATIVE_HORIZON, | |
| "native_horizon_source": ("env_cfg/task_config/_eval_step_limit.yml" | |
| if self.deployment_track == official.TRACK else "task_config/_eval_step_limit.yml"), | |
| "native_source_revision": self.native_source_revision, "expert_screening": False, | |
| "instruction_selection": "fixed native full_description; no expert-derived placeholders", | |
| "sample_selection": "predeclared unscreened seed; one attempt; no retry", | |
| }),) | |
| def open_episode(self, episode: EpisodeSpec) -> RoboTwinEpisode: | |
| if episode not in self.episodes(episode.seed): | |
| raise ProtocolError("RoboTwin episode differs from its fixed schedule") | |
| if self.claimed: | |
| raise ProtocolError("RoboTwin one-episode service already claimed; start no automatic retry") | |
| self.claimed = True | |
| return RoboTwinEpisode(self, episode) | |
| def make_robotwin(parameters: Mapping[str, JsonValue]) -> RoboTwinBenchmarkAdapter: | |
| allowed = {"source_root", "deployment_manifest_sha256", "task", "native_seed", "evaluation_mode", "renderer_runtime", "deployment_track"} | |
| if set(parameters) - allowed: | |
| raise ValueError(f"unknown RoboTwin parameters: {sorted(set(parameters) - allowed)}") | |
| if not {"source_root", "deployment_manifest_sha256"}.issubset(parameters): | |
| raise ValueError("RoboTwin requires an explicit content-pinned deployment root and manifest digest") | |
| return RoboTwinBenchmarkAdapter(**parameters) | |