assests / common /source /starBenchserver /benchmarks /simBenchmarks /LIBERO-plus /bench_server /adapter.py
| """LIBERO-Plus native direct-control adapter, with no simulator import at startup.""" | |
| from __future__ import annotations | |
| import hashlib | |
| import importlib | |
| import importlib.metadata | |
| import json | |
| import os | |
| from pathlib import Path | |
| import subprocess | |
| import sys | |
| from typing import Any, Mapping, Sequence | |
| import xml.etree.ElementTree as ET | |
| 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 .protocol.catalog import COUNTS, HORIZONS, REVISION, file_sha256, native_files, task_catalog | |
| CAMERAS = ("agentview", "robot0_eye_in_hand") | |
| SETTLE_STEPS = 10 | |
| PACKAGE_PINS = {"robosuite": "1.4.0", "mujoco": "3.2.3", "numpy": "1.24.4", "torch": "2.5.1+cpu", | |
| "Wand": "0.6.13", "scikit-image": "0.24.0"} | |
| IMPORT_SUFFIXES = (".py", ".pyc", ".pyo", ".so", ".pyd", ".dll") | |
| def verify_native_import_inventory(root: Path, rows: Sequence[Mapping[str, Any]]) -> None: | |
| """Reject source/extension/cache overrides in the executed native package. | |
| Released assets and BDDL/reset data are checked by separate receipts. They | |
| are not recursively scanned as import code, nor is unused lifelong code. | |
| This is a filesystem inventory, not attestation of loaded Python memory. | |
| """ | |
| namespace, package = root / "libero", root / "libero/libero" | |
| for directory in (namespace, package): | |
| if directory.is_symlink() or not directory.is_dir(): | |
| raise CompatibilityError("native package must be a regular directory") | |
| # This pin intentionally has a namespace package at the outer libero level. | |
| # A new __init__.py or extension there would execute before origin checks. | |
| if any(path.name.endswith(IMPORT_SUFFIXES) for path in namespace.iterdir() if not path.is_dir()): | |
| raise CompatibilityError("unrecorded native namespace import file") | |
| expected = {row["path"] for row in rows if row["path"].endswith(".py")} | |
| actual = set() | |
| count = 0 | |
| for directory, children, filenames in os.walk(package, followlinks=False): | |
| if Path(directory) == package: | |
| children[:] = [name for name in children if name not in {"assets", "bddl_files", "init_files"}] | |
| for name in children: | |
| if (Path(directory) / name).is_symlink(): | |
| raise CompatibilityError("native import directory symlink is not pinned") | |
| count += len(children) + len(filenames) | |
| if count > 1000: | |
| raise CompatibilityError("native import inventory exceeds its bound") | |
| for name in filenames: | |
| if not name.endswith(IMPORT_SUFFIXES): | |
| continue | |
| path = Path(directory) / name | |
| relative = path.relative_to(root).as_posix() | |
| if path.is_symlink() or not path.is_file() or relative not in expected: | |
| raise CompatibilityError("unrecorded native source, bytecode or extension import file") | |
| actual.add(relative) | |
| if actual != expected: | |
| raise CompatibilityError("native Python import inventory differs from the frozen source manifest") | |
| def image_magick_receipt() -> dict: | |
| """Actual native sensor-noise backend, not just the Python Wand version.""" | |
| from wand import version | |
| return {"version": version.MAGICK_VERSION, "features": version.MAGICK_VERSION_FEATURES, | |
| "quantum_depth": version.QUANTUM_DEPTH, "hdri": version.MAGICK_HDRI, | |
| "scope": "loaded library reports; not binary or library-dependency attestation"} | |
| def policy_observation(raw: Mapping[str, Any], step: int, instruction: str) -> Observation: | |
| """Two independent RGB copies only; preserve upstream perturbations exactly.""" | |
| import numpy as np | |
| images = {} | |
| for camera in CAMERAS: | |
| frame = np.asarray(raw.get(camera + "_image")) | |
| if frame.dtype != np.uint8 or frame.shape != (256, 256, 3): | |
| raise ProtocolError("LIBERO-Plus requires two 256x256 uint8 RGB observations") | |
| images[camera] = np.ascontiguousarray(frame[::-1, ::-1]).copy() | |
| return Observation(step=step, instruction=instruction, images=images) | |
| def verify_native_source(root: Path) -> dict: | |
| """Verify bounded native source inputs before loading torch or the simulator.""" | |
| env = {**os.environ, "GIT_OPTIONAL_LOCKS": "0"} | |
| try: | |
| top = subprocess.run(["git", "-C", str(root), "rev-parse", "--show-toplevel"], | |
| capture_output=True, text=True, check=True, timeout=20, env=env).stdout.strip() | |
| revision = subprocess.run(["git", "-C", str(root), "rev-parse", "HEAD"], | |
| capture_output=True, text=True, check=True, timeout=20, env=env).stdout.strip() | |
| except (OSError, subprocess.SubprocessError) as exc: | |
| raise CompatibilityError("cannot verify the LIBERO-Plus native checkout") from exc | |
| if Path(top).resolve() != root or revision != REVISION: | |
| raise CompatibilityError(f"LIBERO-Plus requires its own native checkout at {REVISION}") | |
| manifest_path = Path(__file__).parents[1] / "environment" / "native_source_manifest.json" | |
| payload = json.loads(manifest_path.read_text()) | |
| if (payload.get("schema_version") != "starvla-rsi.libero-plus-native-source/v1" | |
| or payload.get("upstream_revision") != REVISION or not payload.get("files") | |
| or len(payload["files"]) > 200): | |
| raise CompatibilityError("native source inventory differs") | |
| verify_native_import_inventory(root, payload["files"]) | |
| for item in payload["files"]: | |
| path = (root / item["path"]).resolve() | |
| if (not path.is_relative_to(root) or path.stat().st_size != item["size_bytes"] | |
| or file_sha256(path, max_bytes=4 * 1024 * 1024) != item["sha256"]): | |
| raise CompatibilityError("native source differs from the frozen source inventory") | |
| return {"manifest_sha256": file_sha256(manifest_path), "files": payload["files"], "scope": payload["scope"]} | |
| def prepare_native_import(root: Path) -> dict: | |
| source = verify_native_source(root) | |
| for package, expected in PACKAGE_PINS.items(): | |
| try: | |
| actual = importlib.metadata.version(package) | |
| except importlib.metadata.PackageNotFoundError as exc: | |
| raise CompatibilityError(f"missing required LIBERO-Plus package {package}") from exc | |
| if actual != expected: | |
| raise CompatibilityError(f"LIBERO-Plus requires {package}=={expected}, got {actual}") | |
| config = os.environ.get("LIBERO_CONFIG_PATH") | |
| if not config or not (Path(config) / "config.yaml").is_file(): | |
| raise CompatibilityError("set LIBERO_CONFIG_PATH to an isolated, pre-created config directory") | |
| # Namespace packages are used by this pin. Never silently reuse a different | |
| # installed standard-LIBERO namespace or alter an already imported runtime. | |
| if "libero" in sys.modules: | |
| locations = tuple(Path(path).resolve() for path in getattr(sys.modules["libero"], "__path__", ())) | |
| if locations != (root / "libero",): | |
| raise CompatibilityError("another LIBERO namespace is already loaded in this process") | |
| if str(root) not in sys.path: | |
| sys.path.insert(0, str(root)) | |
| native = importlib.import_module("libero.libero") | |
| if Path(native.__file__).resolve() != root / "libero/libero/__init__.py": | |
| raise CompatibilityError("imported LIBERO namespace differs from the selected Plus checkout") | |
| for field, suffix in (("benchmark_root", ""), ("bddl_files", "bddl_files"), | |
| ("init_states", "init_files"), ("assets", "assets")): | |
| expected = root / "libero/libero" / suffix | |
| if Path(native.get_libero_path(field)).resolve() != expected or not expected.is_dir(): | |
| raise CompatibilityError(f"LIBERO-Plus {field} must resolve inside the pinned native checkout") | |
| return source | |
| def selected_asset_receipt(native_env: Any, root: Path, robosuite_root: Path) -> dict: | |
| """Hash only files explicitly referenced by the constructed native XML. | |
| This is not an attestation of all 16 GB of released assets or loaded GPU | |
| memory. The receipt never crosses the policy observation boundary. | |
| """ | |
| text = native_env.model.get_xml() | |
| if not isinstance(text, str) or len(text.encode()) > 8 * 1024 * 1024: | |
| raise CompatibilityError("native XML exceeds the asset-receipt bound") | |
| document = ET.fromstring(text) | |
| allowed = {"libero_plus_assets": root / "libero/libero/assets", | |
| "robosuite_assets": robosuite_root / "models/assets"} | |
| paths = {} | |
| unresolved = [] | |
| compiler = document.find("compiler") | |
| compiler = {} if compiler is None else compiler.attrib | |
| for element in document.findall(".//asset/*"): | |
| filename = element.get("file") | |
| if not filename: | |
| continue | |
| path = Path(filename) | |
| if not path.is_absolute(): | |
| directory = compiler.get("meshdir" if element.tag == "mesh" else "texturedir", "") | |
| path = Path(directory) / path | |
| if not path.is_absolute(): | |
| unresolved.append({"tag": element.tag, "file": filename}) | |
| continue | |
| path = path.resolve() | |
| match = next(((label, base) for label, base in allowed.items() if path.is_relative_to(base.resolve())), None) | |
| if match is None: | |
| raise CompatibilityError("native asset reference leaves the declared source/package asset roots") | |
| label, base = match | |
| key = label + "/" + path.relative_to(base.resolve()).as_posix() | |
| paths[key] = path | |
| if len(paths) > 2048 or sum(path.stat().st_size for path in paths.values()) > 2 * 1024**3: | |
| raise CompatibilityError("selected native asset receipt exceeds its declared bound") | |
| return {"scope": "constructed XML mesh/texture file references, not complete asset or GPU-memory attestation", | |
| "native_model_xml_sha256": hashlib.sha256(text.encode()).hexdigest(), | |
| "files": [{"path": name, "size_bytes": path.stat().st_size, | |
| "sha256": file_sha256(path, max_bytes=256 * 1024**2)} for name, path in sorted(paths.items())], | |
| "unresolved_relative_references": unresolved} | |
| class LiberoPlusEpisode: | |
| def __init__(self, adapter: LiberoPlusBenchmarkAdapter, episode: EpisodeSpec): | |
| self.benchmark, self.episode = adapter, episode | |
| self.env = None | |
| self.artifact_dir: Path | None = None | |
| self.writers: dict[str, Any] = {} | |
| self.step_count = 0 | |
| self.control_attempts = 0 | |
| self.settle_count = 0 | |
| self.settle_attempts = 0 | |
| self.uncertain_controls = 0 | |
| self.success = False | |
| self.finished = False | |
| self.reset_claimed = False | |
| self.initialized = False | |
| self.closed = False | |
| self.finalized = False | |
| self.close_error: Exception | None = None | |
| self.provenance: dict[str, Any] | None = None | |
| def bind_artifact_dir(self, path: Path) -> None: | |
| if self.artifact_dir is not None or self.reset_claimed or self.finalized or self.closed: | |
| raise ProtocolError("artifact directory must be bound once before reset") | |
| self.artifact_dir = path | |
| path.mkdir(parents=True, exist_ok=True) | |
| def reset(self) -> Observation: | |
| if self.reset_claimed or self.closed or self.finalized: | |
| raise ProtocolError("LIBERO-Plus session permits exactly one reset attempt") | |
| self.reset_claimed = True | |
| try: | |
| return self._reset_once() | |
| except Exception: | |
| self.finished = True | |
| raise | |
| def _reset_once(self) -> Observation: | |
| root = self.benchmark.upstream | |
| source = prepare_native_import(root) | |
| import numpy as np | |
| import robosuite | |
| from libero.libero import benchmark as native_benchmark | |
| from libero.libero.envs import OffScreenRenderEnv | |
| suite = native_benchmark.get_benchmark_dict()[self.benchmark.suite](task_order_index=0) | |
| task_id = self.episode.metadata["native_id"] | |
| task = suite.get_task(task_id) | |
| row = self.benchmark.catalog["tasks"][task_id] | |
| if (suite.n_tasks != COUNTS[self.benchmark.suite] or task.name != row["native_name"] | |
| or task.language != row["native_instruction"] or task.problem_folder != self.benchmark.suite | |
| or task.bddl_file != task.name + ".bddl" or task.init_states_file != task.name + ".pruned_init"): | |
| raise CompatibilityError("native LIBERO-Plus identity/order differs from frozen selection") | |
| paths = native_files(self.benchmark.suite, task.name) | |
| bddl = root / "libero/libero/bddl_files" / paths["bddl"] | |
| virtual_bddl = root / "libero/libero/bddl_files" / paths["virtual_bddl"] | |
| initial_file = root / "libero/libero/init_files" / row["initial_file"] | |
| if file_sha256(bddl) != row["bddl_sha256"] or file_sha256(initial_file) != row["initial_file_sha256"]: | |
| raise CompatibilityError("selected BDDL/reset file differs from the frozen catalog") | |
| initial_states = suite.get_task_init_states(task_id) | |
| if file_sha256(initial_file) != row["initial_file_sha256"]: | |
| raise CompatibilityError("reset file changed while the native loader read it") | |
| states = np.asarray(initial_states) | |
| if states.ndim != 2 or not 1 <= len(states) <= 1000 or not 1 <= states.shape[1] <= 10000 or not np.isfinite(states).all(): | |
| raise CompatibilityError("native initial states must be a finite bounded matrix") | |
| controller = robosuite.load_controller_config(default_controller="OSC_POSE") | |
| if (controller["input_min"] != -1 or controller["input_max"] != 1 | |
| or controller["output_max"] != [0.05, 0.05, 0.05, 0.5, 0.5, 0.5] | |
| or controller["output_min"] != [-0.05, -0.05, -0.05, -0.5, -0.5, -0.5] | |
| or controller["control_delta"] is not True): | |
| raise CompatibilityError("native OSC_POSE controller differs from declared normalized control") | |
| self.provenance = {"upstream_revision": REVISION, "native_source": source, | |
| "suite": self.benchmark.suite, "task_order_index": 0, "native_id": task_id, | |
| "native_name": task.name, "category": row["category"], "difficulty_level": row["difficulty_level"], | |
| "native_filename_instruction": task.language, "public_instruction_source": "backing BDDL :language", | |
| "initial_state_index": 0, "available_initial_states": len(states), "reset_seed": self.episode.seed, | |
| "bddl_file": paths["bddl"], "virtual_bddl_file": paths["virtual_bddl"], | |
| "bddl_sha256": row["bddl_sha256"], "initial_file": row["initial_file"], | |
| "initial_file_sha256": row["initial_file_sha256"], | |
| "selected_state_sha256": hashlib.sha256(states[0].tobytes()).hexdigest(), | |
| "declared_settle_steps": SETTLE_STEPS, "controller": controller, | |
| "native_engine_horizon": self.benchmark.native_engine_horizon, | |
| "image_transform": "native RGB[::-1,::-1] copied; native sensor perturbations untouched", | |
| "image_magick": image_magick_receipt(), | |
| "versions": {name: importlib.metadata.version(name) for name in (*PACKAGE_PINS, "Pillow", "imageio", "imageio-ffmpeg", "PyOpenGL")}, | |
| **self.benchmark.budget_metadata()} | |
| self._write_provenance() | |
| np.random.seed(self.episode.seed) | |
| self._event("native_construct_start") | |
| self.env = OffScreenRenderEnv(bddl_file_name=str(virtual_bddl), camera_heights=256, camera_widths=256, | |
| camera_names=list(CAMERAS), camera_depths=False, camera_segmentations=None, control_freq=20, | |
| horizon=self.benchmark.native_engine_horizon, render_gpu_device_id=self.benchmark.render_gpu_device_id) | |
| self._event("native_construct_end") | |
| low, high = self.env.env.action_spec | |
| if not np.array_equal(low, np.full(7, -1.0)) or not np.array_equal(high, np.full(7, 1.0)): | |
| raise CompatibilityError("native action bounds must be 7D [-1, 1]") | |
| self.env.seed(self.episode.seed) | |
| self._event("native_reset_start") | |
| self.env.reset() | |
| self._event("native_reset_end") | |
| self._event("native_initial_state_start") | |
| raw = self.env.set_init_state(initial_states[0]) | |
| self._event("native_initial_state_end") | |
| self.provenance["selected_assets"] = selected_asset_receipt(self.env.env, root, Path(robosuite.__file__).resolve().parent) | |
| self._write_provenance() | |
| for _ in range(SETTLE_STEPS): | |
| raw, _reward, done, _info = self._native_control([0.0] * 6 + [-1.0], settle=True) | |
| if bool(done): | |
| raise ProtocolError("native success occurred during initialization before a policy action") | |
| observation = self._observe(raw) | |
| self.initialized = True | |
| return observation | |
| def _event(self, event: str, **fields) -> None: | |
| if self.artifact_dir is not None: | |
| append_jsonl(self.artifact_dir / "native_events.jsonl", {"event": event, **fields}) | |
| def _native_control(self, action, *, settle=False): | |
| phase = "settle" if settle else "policy" | |
| index = (self.settle_attempts if settle else self.control_attempts) + 1 | |
| self._event("native_control_start", phase=phase, attempt=index, action=list(action)) | |
| if settle: | |
| self.settle_attempts += 1 | |
| else: | |
| self.control_attempts += 1 | |
| try: | |
| returned = self.env.step(list(action)) | |
| except Exception: | |
| # The native call may have partly advanced before raising. Do not | |
| # guess how much or permit the same action to be replayed. | |
| self.uncertain_controls += 1 | |
| self.finished = True | |
| raise | |
| if settle: | |
| self.settle_count += 1 | |
| else: | |
| self.step_count += 1 | |
| self._event("native_control_end", phase=phase, attempt=index, | |
| completed_controls=self.settle_count if settle else self.step_count) | |
| return returned | |
| def _write_provenance(self) -> None: | |
| if self.artifact_dir is not None and self.provenance is not None: | |
| atomic_write_json(self.artifact_dir / "native_provenance.json", self.provenance) | |
| def _observe(self, raw: Mapping[str, Any]) -> Observation: | |
| observation = policy_observation(raw, self.step_count, self.episode.instruction) | |
| 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=20, 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, | |
| "path": path.name, "sha256": file_sha256(path), "instruction": self.episode.instruction}) | |
| return observation | |
| def step(self, action: tuple[float, ...]) -> Transition: | |
| if self.env is None or not self.initialized or self.finished or self.closed or self.finalized: | |
| raise ProtocolError("cannot step an uninitialized/finished LIBERO-Plus session") | |
| action = self.benchmark.action_spec.validate(action) | |
| try: | |
| raw, reward, done, _private_info = self._native_control(action) | |
| # BDDLBaseDomain.step already assigns done = _check_success(). No | |
| # extra scorer query or privileged field is used. | |
| self.success = bool(done) | |
| truncated = self.step_count >= self.benchmark.environment_step_cap and not self.success | |
| self.finished = self.success or truncated | |
| return Transition(observation=self._observe(raw), reward=float(reward), terminated=self.success, | |
| truncated=truncated, info={"native_success": self.success, "native_steps": self.step_count}) | |
| except Exception: | |
| self.finished = True | |
| raise | |
| def metrics(self) -> Mapping[str, JsonValue]: | |
| return {"success": self.success, "native_steps": self.step_count, "settle_steps": self.settle_count, | |
| "declared_settle_steps": SETTLE_STEPS, "native_control_attempts": self.control_attempts, | |
| "settle_control_attempts": self.settle_attempts, "uncertain_native_controls": self.uncertain_controls, | |
| **self.benchmark.budget_metadata()} | |
| def _close_writers(self) -> None: | |
| errors = [] | |
| for camera, writer in list(self.writers.items()): | |
| try: | |
| writer.close() | |
| except Exception as exc: | |
| errors.append(exc) | |
| finally: | |
| del self.writers[camera] | |
| if errors: | |
| raise errors[0] | |
| def artifacts(self) -> Mapping[str, str]: | |
| self.finalized = True | |
| self._close_writers() | |
| if self.artifact_dir is None: | |
| return {} | |
| names = {camera + "_video": camera + ".mp4" for camera in CAMERAS} | |
| names.update(frames="frames.jsonl", native_provenance="native_provenance.json", native_events="native_events.jsonl") | |
| return {key: str(self.artifact_dir / name) for key, name in names.items() if (self.artifact_dir / name).is_file()} | |
| def close(self) -> None: | |
| if self.closed: | |
| if self.close_error is not None: | |
| raise self.close_error | |
| return | |
| self.closed = True | |
| self.finalized = True | |
| self.finished = True | |
| errors = [] | |
| try: | |
| self._close_writers() | |
| except Exception as exc: | |
| errors.append(exc) | |
| if self.env is not None: | |
| native, self.env = self.env, None | |
| try: | |
| native.close() | |
| except Exception as exc: | |
| errors.append(exc) | |
| if errors: | |
| self.close_error = errors[0] | |
| raise self.close_error | |
| class LiberoPlusBenchmarkAdapter: | |
| """One explicit fast subset, native order, state 0, one attempt per task.""" | |
| def __init__(self, *, upstream: str, suite: str = "libero_spatial", task_ids: Sequence[int] = (0,), | |
| evaluation_mode: str = "fast", render_gpu_device_id: int = 0, | |
| budget_mode: str = "horizon", max_policy_calls: int | None = None, | |
| replan_interval: int | None = None): | |
| if not isinstance(upstream, str) or not Path(upstream).is_absolute(): | |
| raise ValueError("upstream must be an absolute server-local native checkout path") | |
| if evaluation_mode != "fast": | |
| raise ValueError("only explicit fast selections are supported; full native parity is not validated") | |
| self.catalog = task_catalog(suite) | |
| if (not isinstance(task_ids, (list, tuple)) or not task_ids | |
| or any(type(index) is not int or not 0 <= index < COUNTS[suite] for index in task_ids) | |
| or list(task_ids) != sorted(set(task_ids))): | |
| raise ValueError("task_ids must be a nonempty unique increasing subset of native indices") | |
| if type(render_gpu_device_id) is not int or render_gpu_device_id < 0: | |
| raise ValueError("render_gpu_device_id must be a nonnegative integer") | |
| if budget_mode not in ("horizon", "decisions"): | |
| raise ValueError("budget_mode must be horizon or decisions") | |
| if budget_mode == "decisions": | |
| if any(type(value) is not int or not 1 <= value <= 10000 for value in (max_policy_calls, replan_interval)): | |
| raise ValueError("decision budgets require positive bounded max_policy_calls and replan_interval") | |
| cap = max_policy_calls * replan_interval | |
| if cap > 10000: | |
| raise ValueError("maximum declared environment controls is 10000") | |
| else: | |
| if max_policy_calls is not None or replan_interval is not None: | |
| raise ValueError("adapter decision parameters require budget_mode=decisions") | |
| cap = HORIZONS[suite] | |
| self.upstream = Path(upstream).resolve() | |
| self.suite, self.task_ids = suite, tuple(task_ids) | |
| self.render_gpu_device_id = render_gpu_device_id | |
| self.budget_mode, self.max_policy_calls, self.replan_interval = budget_mode, max_policy_calls, replan_interval | |
| self.environment_step_cap = self.evaluation_horizon = cap | |
| self.native_engine_horizon = max(1000, cap + SETTLE_STEPS) | |
| self.opened: set[tuple[str, int]] = set() | |
| budget = f"decision-{max_policy_calls}-prefix-{replan_interval}" if budget_mode == "decisions" else "reference-horizon" | |
| self.descriptor = BenchmarkDescriptor(name="libero_plus", version="0.1.0", | |
| protocol_version=f"libero-plus-fast/{suite}/rgb/{budget}/v1", source_revision=REVISION) | |
| self.observation_spec = ObservationSpec(cameras=CAMERAS, modalities=("language", "rgb")) | |
| self.action_spec = ActionSpec(mode="normalized_osc_delta_pose", size=7, | |
| names=("dx_scaled", "dy_scaled", "dz_scaled", "rx_scaled", "ry_scaled", "rz_scaled", "gripper"), | |
| low=(-1.0,) * 7, high=(1.0,) * 7, control_hz=20.0, | |
| frame="world: translation component 1 means +0.05 m", | |
| rotation="world axis-angle delta: rotation component 1 means +0.5 rad", | |
| gripper="-1 open; +1 close; 0 hold native gripper target") | |
| def budget_metadata(self) -> dict[str, JsonValue]: | |
| return {"evaluation_mode": "fast", "budget_mode": self.budget_mode, | |
| "max_policy_calls": self.max_policy_calls, "replan_interval": self.replan_interval, | |
| "environment_step_cap": self.environment_step_cap, "native_horizon": HORIZONS[self.suite], | |
| "native_horizon_source": "retained_starvla_libero_plus_evaluator_reference", | |
| "evaluation_horizon": self.evaluation_horizon} | |
| 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("seed must be a predeclared uint32 integer") | |
| if limit is not None and (type(limit) is not int or not 1 <= limit <= len(self.task_ids)): | |
| raise ValueError("limit must select a nonempty prefix without repeats") | |
| rows = [self.catalog["tasks"][index] for index in self.task_ids[:limit]] | |
| return [EpisodeSpec(id=f"{self.suite}-task{row['native_id']:04d}-init00", seed=seed, | |
| task=f"{self.suite}/task-{row['native_id']}", instruction=row["instruction"], | |
| metadata={"suite": self.suite, "native_id": row["native_id"], "native_name": row["native_name"], | |
| "category": row["category"], "difficulty_level": row["difficulty_level"], | |
| "task_order_index": 0, "initial_state_index": 0, "attempt": 1, | |
| "settle_steps": SETTLE_STEPS, **self.budget_metadata()}) for row in rows] | |
| def open_episode(self, episode: EpisodeSpec) -> LiberoPlusEpisode: | |
| key = (episode.id, episode.seed) | |
| if episode not in self.episodes(episode.seed) or key in self.opened: | |
| raise ProtocolError("episode differs from selection or was already attempted") | |
| self.opened.add(key) | |
| return LiberoPlusEpisode(self, episode) | |
| def make_libero_plus(parameters: Mapping[str, JsonValue]) -> LiberoPlusBenchmarkAdapter: | |
| allowed = {"upstream", "suite", "task_ids", "evaluation_mode", "render_gpu_device_id", | |
| "budget_mode", "max_policy_calls", "replan_interval"} | |
| if not isinstance(parameters, Mapping) or set(parameters) - allowed: | |
| raise ValueError("unknown LIBERO-Plus adapter parameters") | |
| return LiberoPlusBenchmarkAdapter(**parameters) | |