JackAILab's picture
Add files using upload-large-folder tool
6aa6c12 verified
Raw History Blame Contribute Delete
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
@property
def descriptor(self):
return BenchmarkDescriptor(name="calvin", version="debug-fixed-sequence-development",
protocol_version=PROTOCOL, source_revision=runtime.NATIVE_REVISION)
@property
def observation_spec(self):
return ObservationSpec(cameras=CAMERAS, modalities=("language", "rgb"), privileged=False)
@property
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)
@register_benchmark("calvin")
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)