assests / common /source /starBenchserver /benchmarks /simBenchmarks /calvin /bench_server /adapter.py
Download common/source/starBenchserver/benchmarks/simBenchmarks/calvin/bench_server/adapter.py from JackAILab/assests: direct link, hf CLI and curl.
- Browser
- Download file 21.9 kB
-
https://huggingface.co/datasets/JackAILab/assests/resolve/main/common/source/starBenchserver/benchmarks/simBenchmarks/calvin/bench_server/adapter.py
- Command line
-
hf download hf://datasets/JackAILab/assests/common/source/starBenchserver/benchmarks/simBenchmarks/calvin/bench_server/adapter.py
-
curl -L -o adapter.py https://huggingface.co/datasets/JackAILab/assests/resolve/main/common/source/starBenchserver/benchmarks/simBenchmarks/calvin/bench_server/adapter.py
21.9 kB
| """One frozen CALVIN debug sequence: public RGB/language to native relative control.""" | |
| from __future__ import annotations | |
| 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 ProtocolError | |
| from benchkit.registry import register_benchmark | |
| from benchmarks.simBenchmarks.calvin.environment import runtime | |
| CAMERAS = ("rgb_static", "rgb_gripper") | |
| SHAPES = {"rgb_static": (200, 200, 3), "rgb_gripper": (84, 84, 3)} | |
| SUBTASK_HORIZON = 360 | |
| SEQUENCE_LENGTH = 5 | |
| NATIVE_HORIZON = SUBTASK_HORIZON * SEQUENCE_LENGTH | |
| PROTOCOL = "calvin-fa03f01/debug-sequence0/rgb-relative7/prefix1/fast-v1" | |
| def policy_observation(raw: Any, step: int, instruction: str) -> Observation: | |
| import numpy as np | |
| if not isinstance(raw, Mapping) or not isinstance(raw.get("rgb_obs"), Mapping): | |
| raise ProtocolError("CALVIN native observation must contain rgb_obs") | |
| images = {} | |
| for camera in CAMERAS: | |
| frame = raw["rgb_obs"].get(camera) | |
| if not isinstance(frame, np.ndarray) or frame.shape != SHAPES[camera] or frame.dtype != np.uint8: | |
| raise ProtocolError(f"CALVIN {camera} must be native {SHAPES[camera]} uint8 RGB") | |
| images[camera] = np.array(frame, copy=True, order="C") | |
| # No depth, scene_obs, robot_obs, task oracle, future language or reset metadata. | |
| return Observation(step=step, instruction=instruction, images=images) | |
| def native_action(vector): | |
| import numpy as np | |
| action = np.array(vector, dtype=np.float64, copy=True) | |
| action[-1] = 1 if action[-1] > 0 else -1 # Retained RGB evaluator's sign convention. | |
| # Native relative_to_absolute mutates its array slices. Never alias the | |
| # normalized action record or return its scaled values to the actor. | |
| return action | |
| class CalvinEpisode: | |
| def __init__(self, benchmark: CalvinBenchmarkAdapter, episode: EpisodeSpec): | |
| self.benchmark, self.episode = benchmark, episode | |
| self.native = self.trace = None | |
| self.artifact_dir: Path | None = None | |
| self.writers = {} | |
| self.reset_attempted = self.native_reset_returned = self.reset_completed = False | |
| self.finished = self.closed = self.finalized = self.success = self.control_error = False | |
| self.close_error: BaseException | None = None | |
| self.step_count = self.started_controls = self.acknowledged_controls = 0 | |
| self.depth = self.subtask_index = self.subtask_controls = 0 | |
| self.completed_subtasks = [] | |
| self.native_outcome = "not_started" | |
| self.start_info = None | |
| def bind_artifact_dir(self, path: Path): | |
| if self.artifact_dir is not None or self.reset_attempted or self.closed or self.finalized: | |
| raise ProtocolError("CALVIN artifacts must be bound once before reset") | |
| path.mkdir(parents=True, exist_ok=True) | |
| # Preserve the service's lexical root (e.g. macOS /var -> /private/var) | |
| # so its relative artifact export does not reject a canonicalized alias. | |
| self.artifact_dir = path.absolute() | |
| def _log(self, event, **values): | |
| if self.artifact_dir is not None: | |
| append_jsonl(self.artifact_dir / "native_events.jsonl", {"event": event, **values}) | |
| def reset(self): | |
| if self.reset_attempted or self.closed or self.finalized: | |
| raise ProtocolError("CALVIN permits one reset attempt for its predeclared sequence") | |
| self.reset_attempted = True | |
| try: | |
| if self.artifact_dir is None: | |
| raise ProtocolError("CALVIN reset requires a model-owned artifact directory") | |
| provenance = runtime.readiness(self.benchmark.source_root, self.benchmark.dataset_root) | |
| self.native = runtime.prepare_native(self.benchmark.source_root, self.benchmark.dataset_root) | |
| self.trace = self.native.trace | |
| provenance.update({"protocol_version": PROTOCOL, "evaluation_mode": "fast", "track": "debug-sequence0", | |
| "native_subtask_horizon": SUBTASK_HORIZON, "native_horizon": NATIVE_HORIZON, | |
| "physics_hz": 240, "control_hz": 30, "physics_ticks_per_control": 8, | |
| "interface_required_replan_interval": 1, | |
| "policy_memory": "one sequence-level policy; no per-subtask Policy.reset hook; not native model-reset parity", | |
| "observation": {"cameras": list(CAMERAS), "shapes": SHAPES, | |
| "image_transform": "none; exact native RGB copies", "state": None}, | |
| "action": {"mode": self.benchmark.action_spec.mode, "dtype": "float64 writable copy", | |
| "translation_m_per_unit": 0.02, "euler_rad_per_unit": 0.05, | |
| "reference": "previous commanded target pose, world coordinates", | |
| "gripper": "positive opens, zero/negative closes", | |
| "bounds": "development protocol restricts all 7 inputs to [-1,1]; native itself does not clip first six", | |
| "controller": "native PyBullet numerical IK, use_ik_fast=False; no task planner"}, | |
| "configuration_overrides": {"omit_camera": "tactile", "show_gui": False, | |
| "use_vr": False, "use_scene_info": True}, | |
| "video": {"codec": "OpenCV mp4v", "fps": 30, "frames": "reset plus one per completed control", | |
| "encoding_conversion": "RGB to BGR for OpenCV only; no flip/crop/resize"}}) | |
| atomic_write_json(self.artifact_dir / "native_provenance.json", provenance) | |
| self._log("native_construction_start", expert_screening=False) | |
| self.native.construct() | |
| self._log("native_construction_end", physics_ticks=self.trace.completed_ticks["construction"], | |
| initialization="native robot/scene load; fixed episode state applied next") | |
| import numpy as np | |
| sequence = self.benchmark.sequence | |
| self.trace.phase = "reset" | |
| self._log("reset_start", sequence_index=0, reset_attempt=1) | |
| raw = self.native.env.reset(robot_obs=np.array(sequence["robot_obs"], dtype=np.float64), | |
| scene_obs=np.array(sequence["scene_obs"], dtype=np.float64)) | |
| self.native_reset_returned = True | |
| if self.trace.completed_ticks["reset"] != 1: | |
| raise ProtocolError("CALVIN native fixed reset must complete exactly one physics tick") | |
| self.start_info = self.native.env.get_info() | |
| self.native_outcome = "in_progress" | |
| self._log("subtask_start", index=0, task=sequence["tasks"][0], instruction=sequence["instructions"][0]) | |
| observation = self._observe(raw) | |
| self.reset_completed = True | |
| self._log("reset_end", physics_ticks=self.trace.completed_ticks["reset"], policy_controls=0) | |
| return observation | |
| except BaseException: | |
| self.finished = True | |
| self.native_outcome = "reset_error" | |
| try: | |
| self.close() | |
| except BaseException as exc: | |
| self._log("reset_cleanup_error", error_type=type(exc).__name__) | |
| raise | |
| def _observe(self, raw): | |
| instruction = self.benchmark.sequence["instructions"][self.subtask_index] | |
| observation = policy_observation(raw, self.step_count, instruction) | |
| if self.artifact_dir is not None: | |
| import cv2 | |
| for camera, frame in observation.images.items(): | |
| path = self.artifact_dir / f"{camera}-{self.step_count:06d}.png" | |
| bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) | |
| if not cv2.imwrite(str(path), bgr): | |
| raise ProtocolError("CALVIN PNG writer failed") | |
| if camera not in self.writers: | |
| writer = cv2.VideoWriter(str(self.artifact_dir / f"{camera}.mp4"), | |
| cv2.VideoWriter_fourcc(*"mp4v"), 30, (frame.shape[1], frame.shape[0])) | |
| if not writer.isOpened(): | |
| writer.release() | |
| raise ProtocolError("CALVIN MP4 writer failed to open") | |
| self.writers[camera] = writer | |
| self.writers[camera].write(bgr) | |
| append_jsonl(self.artifact_dir / "frames.jsonl", { | |
| "camera": camera, "step": self.step_count, "path": path.name, | |
| "sha256": hashlib.sha256(path.read_bytes()).hexdigest(), | |
| "rgb_sha256": hashlib.sha256(frame.tobytes()).hexdigest(), | |
| "policy_physics_ticks": self.trace.completed_ticks["control"], | |
| }) | |
| return observation | |
| def step(self, action: tuple[float, ...]) -> Transition: | |
| if self.native is None or not self.reset_completed or self.closed or self.finished or self.finalized: | |
| raise ProtocolError("cannot control an uninitialized or finished CALVIN sequence") | |
| vector = self.benchmark.action_spec.validate(action) | |
| self.trace.phase = "control" | |
| before = self.trace.completed_ticks["control"] | |
| self.started_controls += 1 | |
| index = self.subtask_index | |
| task = self.benchmark.sequence["tasks"][index] | |
| self._log("action_start", control=self.started_controls, subtask_index=index, action=list(vector)) | |
| try: | |
| raw, reward, done, current_info = self.native.env.step(native_action(vector)) | |
| self.step_count += 1 | |
| self.subtask_controls += 1 | |
| if reward != 0 or done is not False or self.trace.completed_ticks["control"] - before != 8: | |
| raise ProtocolError("CALVIN native step contract differs") | |
| achieved = self.native.oracle.get_task_info_for_set(self.start_info, current_info, {task}) | |
| if not isinstance(achieved, set) or not achieved.issubset({task}): | |
| raise ProtocolError("CALVIN native oracle returned an invalid task result") | |
| if achieved: | |
| self.depth += 1 | |
| row = {"index": index, "task": task, "controls": self.subtask_controls, | |
| "completion_control": self.step_count, "native_success": True} | |
| self.completed_subtasks.append(row) | |
| self._log("subtask_end", **row) | |
| if self.depth == SEQUENCE_LENGTH: | |
| self.finished = self.success = True | |
| self.native_outcome = "sequence_success" | |
| else: | |
| self.subtask_index += 1 | |
| self.subtask_controls = 0 | |
| # Native evaluator takes a new private baseline, not a scene | |
| # reset. Prefix=1 guarantees the next action sees new language. | |
| self.start_info = self.native.env.get_info() | |
| self._log("subtask_start", index=self.subtask_index, | |
| task=self.benchmark.sequence["tasks"][self.subtask_index], | |
| instruction=self.benchmark.sequence["instructions"][self.subtask_index]) | |
| elif self.subtask_controls >= SUBTASK_HORIZON: | |
| self.finished = True | |
| self.native_outcome = "subtask_horizon_failure" | |
| self._log("subtask_end", index=index, task=task, controls=self.subtask_controls, | |
| native_success=False, stop_reason=self.native_outcome) | |
| self._log("action_end", control=self.step_count, subtask_index=index, | |
| native_subtask_success=bool(achieved), completion_depth=self.depth, | |
| policy_physics_ticks=self.trace.completed_ticks["control"]) | |
| observation = self._observe(raw) | |
| result = Transition(observation=observation, reward=float(bool(achieved)), | |
| terminated=self.success, truncated=self.finished and not self.success, | |
| info={"native_completion_depth": self.depth, "native_steps": self.step_count}) | |
| self.acknowledged_controls += 1 | |
| return result | |
| except BaseException: | |
| self.finished = self.control_error = True | |
| self.native_outcome = "control_error" | |
| self._log("action_error", started_controls=self.started_controls, | |
| completed_controls=self.step_count, acknowledged_controls=self.acknowledged_controls, | |
| physics_ticks=self.trace.completed_ticks["control"], replay_allowed=False) | |
| raise | |
| def metrics(self) -> Mapping[str, JsonValue]: | |
| ticks = dict(self.trace.completed_ticks) if self.trace is not None else {"construction": 0, "reset": 0, "control": 0} | |
| started_ticks = dict(self.trace.started_ticks) if self.trace is not None else dict(ticks) | |
| return {"success": self.success, "completion_depth": self.depth, | |
| "success_at_depth": {str(depth): self.depth >= depth for depth in range(1, 6)}, | |
| "native_steps": self.step_count, "started_controls": self.started_controls, | |
| "acknowledged_controls": self.acknowledged_controls, | |
| "current_subtask_index": self.subtask_index, "current_subtask_controls": self.subtask_controls, | |
| "completed_subtasks": list(self.completed_subtasks), "native_outcome": self.native_outcome, | |
| "native_subtask_horizon": SUBTASK_HORIZON, "native_horizon": NATIVE_HORIZON, | |
| "policy_physics_ticks": ticks["control"], "policy_simulated_seconds": ticks["control"] / 240, | |
| "initialization_physics_ticks": ticks["construction"] + ticks["reset"], | |
| "completed_physics_ticks_by_phase": ticks, "started_physics_ticks_by_phase": started_ticks, | |
| "reset_attempted": self.reset_attempted, | |
| "native_reset_returned": self.native_reset_returned, "reset_completed": self.reset_completed, | |
| "control_error": self.control_error, "track": "debug-sequence0", | |
| "aggregate_scope": "one debug sequence; not native 1000-sequence/full D validation score", | |
| "reward_semantics": "wrapper numeric encoding of current native subtask completion; no native shaped reward"} | |
| def _close_writers(self): | |
| writers, self.writers = self.writers, {} | |
| errors = [] | |
| for camera, writer in writers.items(): | |
| try: | |
| writer.release() | |
| path = self.artifact_dir / f"{camera}.mp4" | |
| if not path.is_file() or path.stat().st_size == 0: | |
| raise ProtocolError("CALVIN video finalization produced no bytes") | |
| except BaseException as exc: | |
| errors.append(exc) | |
| if errors: | |
| raise ProtocolError("CALVIN media finalization failed") from errors[0] | |
| def artifacts(self): | |
| self.finalized = True | |
| self._close_writers() | |
| if self.artifact_dir is None: | |
| return {} | |
| if self.native_outcome == "in_progress": | |
| self.native_outcome = "externally_stopped_incomplete" | |
| atomic_write_json(self.artifact_dir / "native_metrics.json", self.metrics()) | |
| 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", | |
| "native_metrics": "native_metrics.json"}) | |
| return {key: str(self.artifact_dir / name) for key, name in files.items() | |
| if (self.artifact_dir / name).is_file()} | |
| def close(self): | |
| if self.closed: | |
| if self.close_error is not None: | |
| raise ProtocolError("previous CALVIN cleanup failed") from self.close_error | |
| return | |
| self.closed = True | |
| errors = [] | |
| try: | |
| self._close_writers() | |
| except BaseException as exc: | |
| errors.append(exc) | |
| native, self.native = self.native, None | |
| receipt = {"constructed": False, "native_close_returned": False, "clients": []} | |
| if native is not None: | |
| try: | |
| receipt, native_errors = native.close() | |
| errors.extend(native_errors) | |
| except BaseException as exc: | |
| errors.append(exc) | |
| if self.native_outcome == "in_progress": | |
| self.native_outcome = "externally_stopped_incomplete" | |
| receipt["error_types"] = [type(exc).__name__ for exc in errors] | |
| if self.artifact_dir is not None: | |
| try: | |
| atomic_write_json(self.artifact_dir / "native_cleanup.json", receipt) | |
| # The shared service deliberately denies metrics RPC after a | |
| # reset/control fault. Persist counters for final artifact | |
| # transfer, even when no successful reset response existed. | |
| atomic_write_json(self.artifact_dir / "native_metrics.json", self.metrics()) | |
| except BaseException as exc: | |
| errors.append(exc) | |
| if errors: | |
| self.close_error = errors[0] | |
| raise ProtocolError("CALVIN native/media cleanup failed") from errors[0] | |
| class CalvinBenchmarkAdapter: | |
| budget_mode = "horizon" | |
| # Sequence upper bound; the native 360-control per-subtask limit still | |
| # terminates unsuccessful subtasks earlier. | |
| environment_step_cap = NATIVE_HORIZON | |
| required_replan_interval = 1 | |
| def __init__(self, source_root: str, dataset_root: str, track: str = "debug-sequence0", | |
| evaluation_mode: str = "fast"): | |
| for name, value in (("source_root", source_root), ("dataset_root", dataset_root)): | |
| if (not isinstance(value, str) or not value or not Path(value).is_absolute() | |
| or ".." in Path(value).parts): | |
| raise ValueError(f"{name} must be an explicit absolute path") | |
| if track != "debug-sequence0" or evaluation_mode != "fast": | |
| raise ValueError("only debug-sequence0 fast is implemented; native full validation is unsupported") | |
| self.source_root, self.dataset_root = Path(source_root), Path(dataset_root) | |
| self.sequence = runtime.frozen_sequence() | |
| self.claimed = False | |
| def descriptor(self): | |
| return BenchmarkDescriptor(name="calvin", version="debug-fixed-sequence-development", | |
| protocol_version=PROTOCOL, source_revision=runtime.NATIVE_REVISION) | |
| def observation_spec(self): | |
| return ObservationSpec(cameras=CAMERAS, modalities=("language", "rgb"), privileged=False) | |
| def action_spec(self): | |
| return ActionSpec(mode="calvin_native_relative_euler7_debug_normalized", size=7, | |
| names=("dx", "dy", "dz", "droll", "dpitch", "dyaw", "gripper"), | |
| low=(-1.0,) * 7, high=(1.0,) * 7, control_hz=30, | |
| frame="world-frame increments to previous commanded target; 0.02 m per input unit", | |
| rotation="native Euler xyz additive increments; 0.05 rad per input unit", | |
| gripper="positive opens, zero/negative closes; mapped to native +1/-1") | |
| 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("CALVIN debug service permits one fixed sequence episode") | |
| return (EpisodeSpec(id="debug-sequence0-episode000", task="long_horizon_manipulation", seed=seed, | |
| instruction=self.sequence["instructions"][0], metadata={ | |
| "evaluation_mode": "fast", "track": "debug-sequence0", | |
| "native_horizon": NATIVE_HORIZON, "native_subtask_horizon": SUBTASK_HORIZON, | |
| "native_horizon_source": "native evaluate_policy.py EP_LEN=360, five-subtask fixed sequence", | |
| "sequence_sha256": runtime.SEQUENCE_SHA256, "native_environment_seed": 0, | |
| "sample_selection": "one predeclared frozen sequence; no seed search, retries or success screening", | |
| "policy_memory": "sequence-level; no per-subtask policy reset hook", | |
| }),) | |
| def open_episode(self, episode): | |
| if episode not in self.episodes(episode.seed): | |
| raise ProtocolError("CALVIN episode differs from its frozen schedule") | |
| if self.claimed: | |
| raise ProtocolError("CALVIN one-sequence service already claimed; no automatic retry") | |
| self.claimed = True | |
| return CalvinEpisode(self, episode) | |
| def make_calvin(parameters: Mapping[str, JsonValue]): | |
| allowed = {"source_root", "dataset_root", "track", "evaluation_mode"} | |
| if set(parameters) - allowed: | |
| raise ValueError(f"unknown CALVIN parameters: {sorted(set(parameters) - allowed)}") | |
| if not {"source_root", "dataset_root"}.issubset(parameters): | |
| raise ValueError("CALVIN needs explicit pinned native source and official debug dataset paths") | |
| return CalvinBenchmarkAdapter(**parameters) | |