| """Dependency-free diagnostic world, never a participant capability benchmark.""" |
|
|
| from __future__ import annotations |
|
|
| import random |
| from typing import Mapping, Sequence |
|
|
| from benchkit.contracts import ( |
| ActionChunk, |
| ActionSpec, |
| BenchmarkDescriptor, |
| EpisodeContext, |
| EpisodeSpec, |
| JsonValue, |
| Observation, |
| ObservationSpec, |
| PolicyDecision, |
| PolicyDescriptor, |
| Transition, |
| ) |
| from benchkit.registry import register_benchmark, register_policy |
|
|
|
|
| class ReachEpisode: |
| """Tiny absolute-position world with native success and reward signals.""" |
|
|
| def __init__(self, spec: EpisodeSpec) -> None: |
| self.spec = spec |
| self.position = 0.0 |
| self.target = 0.0 |
| self.done = False |
| self._reward = 0.0 |
|
|
| def reset(self) -> Observation: |
| randomizer = random.Random(self.spec.seed) |
| self.target = randomizer.uniform(-0.8, 0.8) |
| self.position = -0.8 if self.target >= 0 else 0.8 |
| self.done = False |
| return self._observation(0) |
|
|
| def _observation(self, step: int) -> Observation: |
| return Observation( |
| step=step, |
| instruction=self.spec.instruction, |
| state=(self.position,), |
| metadata={"target": self.target}, |
| ) |
|
|
| def step(self, action: tuple[float, ...]) -> Transition: |
| if self.done: |
| raise RuntimeError("cannot step a completed episode") |
| self.position = action[0] |
| distance = abs(self.target - self.position) |
| self.done = distance <= 0.05 |
| self._reward = max(0.0, 1.0 - distance) |
| return Transition( |
| observation=self._observation(1), |
| reward=self._reward, |
| terminated=self.done, |
| info={"distance": distance}, |
| ) |
|
|
| def metrics(self) -> Mapping[str, JsonValue]: |
| return {"success": self.done, "final_distance": abs(self.target - self.position)} |
|
|
| def artifacts(self) -> Mapping[str, str]: |
| return {} |
|
|
| def close(self) -> None: |
| return None |
|
|
|
|
| class ReachBenchmark: |
| """Benchmark adapter for the tiny reach world.""" |
|
|
| descriptor = BenchmarkDescriptor( |
| name="smoke-reach", |
| version="1", |
| protocol_version="starvla-rsi.smoke/v1", |
| source_revision="builtin", |
| ) |
| observation_spec = ObservationSpec(state_names=("position",), modalities=("language", "state")) |
| action_spec = ActionSpec( |
| mode="joint_position", |
| size=1, |
| names=("position",), |
| low=(-1.0,), |
| high=(1.0,), |
| control_hz=10.0, |
| ) |
|
|
| def episodes(self, seed: int, limit: int | None = None) -> Sequence[EpisodeSpec]: |
| count = 3 if limit is None else limit |
| return [ |
| EpisodeSpec( |
| id=f"reach-{index:03d}", |
| task="reach", |
| seed=seed + index, |
| instruction="Move the joint to the target position.", |
| ) |
| for index in range(count) |
| ] |
|
|
| def open_episode(self, episode: EpisodeSpec) -> ReachEpisode: |
| return ReachEpisode(episode) |
|
|
|
|
| class ScriptedReachPolicy: |
| """Reference policy proving that runner wiring, not task skill, is functional.""" |
|
|
| descriptor = PolicyDescriptor(name="smoke-scripted", kind="scripted", version="1") |
|
|
| def compatibility_errors( |
| self, observation_spec: ObservationSpec, action_spec: ActionSpec |
| ) -> Sequence[str]: |
| errors: list[str] = [] |
| if action_spec.mode != "joint_position" or action_spec.size != 1: |
| errors.append("smoke-scripted requires a 1-D joint_position action") |
| if not observation_spec.state_names: |
| errors.append("smoke-scripted requires proprioceptive state") |
| return errors |
|
|
| def start_episode(self, context: EpisodeContext) -> None: |
| return None |
|
|
| def act(self, observation: Observation) -> PolicyDecision: |
| target = float(observation.metadata["target"]) |
| return PolicyDecision( |
| action=ActionChunk.from_steps(((target,),)), |
| note="Move directly to the target in the mock world.", |
| ) |
|
|
| def end_episode(self) -> None: |
| return None |
|
|
|
|
| @register_benchmark("smoke") |
| def make_smoke_benchmark(parameters: Mapping[str, JsonValue]) -> ReachBenchmark: |
| if parameters: |
| raise ValueError(f"smoke benchmark has no parameters: {sorted(parameters)}") |
| return ReachBenchmark() |
|
|
|
|
| @register_policy("scripted") |
| def make_scripted_policy(parameters: Mapping[str, JsonValue]) -> ScriptedReachPolicy: |
| if parameters: |
| raise ValueError(f"scripted policy has no parameters: {sorted(parameters)}") |
| return ScriptedReachPolicy() |
|
|
