From ea59d41d424fa7a61ccdc99cef380d087ab664b7 Mon Sep 17 00:00:00 2001
From: TaylorSwift222 <179662524+TaylorSwift222@users.noreply.github.com>
Date: Sun, 30 Aug 2026 20:30:28 +0800
Subject: [PATCH 1/2] fix(robotwin): unify cross-family benchmark evaluation
---
.gitignore | 1 +
examples/robotwin/client_policy.py | 181 +++++++++++++++--
examples/robotwin/deploy_policy.py | 50 ++++-
examples/robotwin/evaluator.py | 136 +++++++++++++
examples/robotwin/multigpu_rollout.py | 182 +++++++++++++++---
examples/robotwin/policy_server.py | 3 +
examples/robotwin/robotwin_worker.py | 137 ++++++++++++-
.../run_streamingwam_robotwin_benchmark.sh | 84 ++++++++
examples/robotwin/timing.py | 148 +++++++++++++-
streamingwam/inference/ac_stream.py | 16 ++
tests/test_robotwin_inference_modes.py | 73 +++++++
11 files changed, 955 insertions(+), 56 deletions(-)
create mode 100644 examples/robotwin/evaluator.py
create mode 100644 examples/robotwin/scripts/run_streamingwam_robotwin_benchmark.sh
diff --git a/.gitignore b/.gitignore
index 126722d..6345b91 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,7 @@ wandb/
runs/
outputs/
checkpoints/
+/packages/
*.ckpt
*.pt
*.pth
diff --git a/examples/robotwin/client_policy.py b/examples/robotwin/client_policy.py
index 3cab78a..685f093 100644
--- a/examples/robotwin/client_policy.py
+++ b/examples/robotwin/client_policy.py
@@ -65,6 +65,42 @@ def _is_none_like(value: Any) -> bool:
return False
+def _take_environment_action(
+ task_env: Any,
+ action: np.ndarray,
+ *,
+ defer_render: bool,
+) -> tuple[int, int]:
+ """Execute one action while suppressing redundant renders during D8 overlap."""
+
+ original_update_render = None
+ original_get_obs = None
+ if defer_render:
+ original_update_render = task_env._update_render
+ original_get_obs = task_env.get_obs
+
+ def skip_update_render(*_args, **_kwargs):
+ return None
+
+ def get_obs_with_render(*args, **kwargs):
+ task_env._update_render = original_update_render
+ try:
+ return original_get_obs(*args, **kwargs)
+ finally:
+ task_env._update_render = skip_update_render
+
+ task_env._update_render = skip_update_render
+ task_env.get_obs = get_obs_with_render
+ started_ns = time.perf_counter_ns()
+ try:
+ task_env.take_action(action, action_type="qpos")
+ finally:
+ if original_update_render is not None:
+ task_env._update_render = original_update_render
+ task_env.get_obs = original_get_obs
+ return started_ns, time.perf_counter_ns()
+
+
class RemoteStreamingWAMModel:
"""Talks to the Streaming-WAM inference server; manages the replan queue locally."""
@@ -94,9 +130,16 @@ def __init__(
self._timing_records: list[dict[str, Any]] = []
self._episode_records: list[dict[str, Any]] = []
self._episode_started_ns: int | None = None
+ self._terminal_action_completion_ns: int | None = None
+ self._timing_hook_active = False
+ self._active_timing_metadata: dict[str, Any] = {}
self._episode_index = 0
self._replan_index = 0
+ @property
+ def needs_prewarm(self) -> bool:
+ return self.prewarm and not self._prewarmed
+
def _connect(self, timeout: float) -> socket.socket:
deadline = time.time() + timeout
last_err: Optional[Exception] = None
@@ -252,15 +295,24 @@ def _prewarm_once(self, task_env: Any, observation: Dict[str, Any] | None) -> No
self._prewarmed = True
self._replan_index = 0
- def _start_episode(self) -> None:
+ def _start_episode(self, *, started_ns: int | None = None) -> None:
if self._episode_started_ns is None:
- self._episode_started_ns = time.perf_counter_ns()
+ self._episode_started_ns = (
+ time.perf_counter_ns() if started_ns is None else int(started_ns)
+ )
+ self._terminal_action_completion_ns = None
self._replan_index = 0
- def finish_episode(self, success: bool | None = None) -> None:
+ def finish_episode(
+ self,
+ success: bool | None = None,
+ *,
+ ended_ns: int | None = None,
+ ) -> None:
if self._episode_started_ns is None:
return
- elapsed = (time.perf_counter_ns() - self._episode_started_ns) / 1e9
+ completed_ns = time.perf_counter_ns() if ended_ns is None else int(ended_ns)
+ elapsed = (completed_ns - self._episode_started_ns) / 1e9
self._episode_records.append({
"record_type": "episode",
"task": self.current_task,
@@ -268,8 +320,12 @@ def finish_episode(self, success: bool | None = None) -> None:
"episode": self._episode_index,
"success": success,
"total_time_s": elapsed,
+ **self._active_timing_metadata,
})
self._episode_started_ns = None
+ self._terminal_action_completion_ns = None
+ self._timing_hook_active = False
+ self._active_timing_metadata = {}
# Drain a terminal episode's final D8 request before the worker changes
# task identity. The elapsed value above excludes this post-terminal
# cleanup, while the launched chunk remains represented in timing.
@@ -282,16 +338,24 @@ def step(self, task_env: Any, observation: Optional[Dict[str, Any]]) -> None:
self._prewarm_once(task_env, observation)
self._start_episode()
if self.inference_mode == "ac-stream":
- if observation is None:
- raise ValueError("AC-Stream requires an observation at every action step")
- snapshot = self._snapshot(task_env, observation)
if self._ac_stream_controller is None:
+ if observation is None:
+ raise ValueError("AC-Stream D0 requires an observation")
+ snapshot = self._snapshot(task_env, observation)
self._ac_stream_controller = ACStreamController(self._predict_remote)
self._ac_stream_controller.start_episode(snapshot)
+ elif self._ac_stream_controller.observation_required:
+ if observation is None:
+ raise ValueError("AC-Stream D8 launch requires an observation")
+ snapshot = self._snapshot(task_env, observation)
+ else:
+ snapshot = None
action = self._ac_stream_controller.next_action(snapshot)
- started_ns = time.perf_counter_ns()
- task_env.take_action(action, action_type="qpos")
- completed_ns = time.perf_counter_ns()
+ started_ns, completed_ns = _take_environment_action(
+ task_env,
+ action,
+ defer_render=self._ac_stream_controller.inference_in_flight,
+ )
self._ac_stream_controller.mark_action_executed(
started_ns=started_ns,
completed_ns=completed_ns,
@@ -311,11 +375,71 @@ def step(self, task_env: Any, observation: Optional[Dict[str, Any]]) -> None:
for i in range(min(self.replan_steps, chunk.shape[0])):
self.pending_actions.append(np.asarray(chunk[i], dtype=np.float32))
if self.pending_actions:
- task_env.take_action(self.pending_actions.popleft(), action_type="qpos")
- if bool(getattr(task_env, "eval_success", False)):
- self.finish_episode(success=True)
- elif int(getattr(task_env, "take_action_cnt", 0)) >= int(getattr(task_env, "step_lim", 1 << 30)):
- self.finish_episode(success=False)
+ _, completed_ns = _take_environment_action(
+ task_env,
+ self.pending_actions.popleft(),
+ defer_render=False,
+ )
+ succeeded = bool(getattr(task_env, "eval_success", False))
+ exhausted = int(getattr(task_env, "take_action_cnt", 0)) >= int(
+ getattr(task_env, "step_lim", 1 << 30)
+ )
+ if succeeded or exhausted:
+ self._terminal_action_completion_ns = completed_ns
+ if not self._timing_hook_active:
+ self.finish_episode(
+ success=succeeded,
+ ended_ns=self._terminal_action_completion_ns,
+ )
+
+ def should_request_observation(self) -> bool:
+ if self.inference_mode != "ac-stream":
+ return not self.pending_actions
+ if self._ac_stream_controller is None:
+ return True
+ return self._ac_stream_controller.observation_required
+
+ def prepare_instruction(self, instruction: str) -> None:
+ self._request_id += 1
+ _send_msg(
+ self._conn,
+ {
+ "cmd": "prepare_instruction",
+ "request_id": self._request_id,
+ "instruction": str(instruction),
+ },
+ )
+ response = _recv_msg(self._conn)
+ if "error" in response:
+ raise RuntimeError(f"policy server error:\n{response['error']}")
+ if response.get("request_id") != self._request_id:
+ raise RuntimeError(
+ f"policy response ID mismatch: expected {self._request_id}, "
+ f"got {response.get('request_id')}"
+ )
+
+ def prewarm_model(self, task_env: Any, observation: Dict[str, Any]) -> None:
+ self._prewarm_once(task_env, observation)
+
+ def begin_timing_trajectory(self, metadata: dict[str, Any]) -> None:
+ if self._episode_started_ns is not None:
+ raise RuntimeError("a timed RoboTwin trajectory is already active")
+ self._timing_hook_active = True
+ self._active_timing_metadata = dict(metadata)
+ self._start_episode(started_ns=time.perf_counter_ns())
+
+ def end_timing_trajectory(
+ self,
+ success: bool,
+ metadata: dict[str, Any],
+ ) -> None:
+ if not self._timing_hook_active or self._episode_started_ns is None:
+ raise RuntimeError("no timed RoboTwin trajectory is active")
+ ended_ns = self._terminal_action_completion_ns
+ if ended_ns is None:
+ ended_ns = time.perf_counter_ns()
+ self._active_timing_metadata.update(metadata)
+ self.finish_episode(success=bool(success), ended_ns=ended_ns)
def reset(self) -> None:
self.finish_episode(success=None)
@@ -372,5 +496,32 @@ def reset_model(model: RemoteStreamingWAMModel) -> None:
model.reset()
+def prepare_instruction(task_env: Any, model: RemoteStreamingWAMModel) -> None:
+ model.prepare_instruction(task_env.get_instruction())
+
+
+def prewarm_model(
+ task_env: Any,
+ model: RemoteStreamingWAMModel,
+ observation: Dict[str, Any],
+) -> None:
+ model.prewarm_model(task_env, observation)
+
+
+def begin_timing_trajectory(
+ model: RemoteStreamingWAMModel,
+ metadata: dict[str, Any],
+) -> None:
+ model.begin_timing_trajectory(metadata)
+
+
+def end_timing_trajectory(
+ model: RemoteStreamingWAMModel,
+ success: bool,
+ metadata: dict[str, Any],
+) -> None:
+ model.end_timing_trajectory(success, metadata)
+
+
def _finish_episode(model: RemoteStreamingWAMModel) -> None:
model.finish_episode(success=None)
diff --git a/examples/robotwin/deploy_policy.py b/examples/robotwin/deploy_policy.py
index d409830..0d87982 100644
--- a/examples/robotwin/deploy_policy.py
+++ b/examples/robotwin/deploy_policy.py
@@ -68,7 +68,31 @@ def _load_adapter(mode: str):
def get_model(usr_args: Dict[str, Any]):
mode = _infer_mode(usr_args)
- return _load_adapter(mode).get_model(usr_args)
+ adapter = _load_adapter(mode)
+ model = adapter.get_model(usr_args)
+ # Keep the selected adapter on the model so every public deploy-policy
+ # hook is forwarded through the same implementation. RoboTwin imports
+ # this module as the stable entry point; evaluators must not depend on a
+ # concrete client/local adapter module.
+ model._streamingwam_robotwin_adapter = adapter
+ return model
+
+
+def _adapter(model: Any):
+ adapter = getattr(model, "_streamingwam_robotwin_adapter", None)
+ if adapter is None:
+ raise RuntimeError("model was not created by deploy_policy.get_model")
+ return adapter
+
+
+def _required_hook(model: Any, name: str, *args: Any) -> Any:
+ hook = getattr(_adapter(model), name, None)
+ if not callable(hook):
+ raise AttributeError(
+ f"RoboTwin policy adapter {_adapter(model).__name__!r} "
+ f"does not implement required hook {name!r}"
+ )
+ return hook(*args)
def eval(TASK_ENV: Any, model: Any, observation: Optional[Dict[str, Any]]) -> None:
@@ -79,6 +103,30 @@ def reset_model(model: Any) -> None:
model.reset()
+def prepare_instruction(task_env: Any, model: Any) -> None:
+ _required_hook(model, "prepare_instruction", task_env, model)
+
+
+def prewarm_model(
+ task_env: Any,
+ model: Any,
+ observation: Dict[str, Any],
+) -> None:
+ _required_hook(model, "prewarm_model", task_env, model, observation)
+
+
+def begin_timing_trajectory(model: Any, metadata: Dict[str, Any]) -> None:
+ _required_hook(model, "begin_timing_trajectory", model, metadata)
+
+
+def end_timing_trajectory(
+ model: Any,
+ success: bool,
+ metadata: Dict[str, Any],
+) -> None:
+ _required_hook(model, "end_timing_trajectory", model, success, metadata)
+
+
def _finish_episode(model: Any) -> None:
finish = getattr(model, "finish_episode", None)
if callable(finish):
diff --git a/examples/robotwin/evaluator.py b/examples/robotwin/evaluator.py
new file mode 100644
index 0000000..3f43799
--- /dev/null
+++ b/examples/robotwin/evaluator.py
@@ -0,0 +1,136 @@
+"""Canonical one-episode RoboTwin evaluation used by the public benchmark."""
+
+from __future__ import annotations
+
+import importlib
+import traceback
+from typing import Any
+
+import numpy as np
+
+
+def evaluate_one_episode(
+ *,
+ official: Any,
+ task_name: str,
+ task_env: Any,
+ settings: dict[str, Any],
+ model: Any,
+ start_seed: int,
+ trial: int,
+ instruction_type: str = "unseen",
+ policy_module: Any | None = None,
+) -> tuple[int, int]:
+ """Run one accepted RoboTwin episode with canonical trajectory timing.
+
+ Scene construction, expert validation, instruction preparation, and model
+ warmup are outside the timer. Timing begins immediately before the first
+ policy observation and ends when the terminal action call returns.
+ """
+
+ if getattr(task_env, "eval_video_path", None) is not None:
+ raise RuntimeError("benchmark timing requires eval_video_log=false")
+
+ if policy_module is None:
+ policy_module = importlib.import_module(str(settings["policy_name"]))
+ reset_model = getattr(policy_module, "reset_model")
+ prepare_instruction = getattr(policy_module, "prepare_instruction")
+ prewarm_model = getattr(policy_module, "prewarm_model")
+ begin_timing = getattr(policy_module, "begin_timing_trajectory")
+ end_timing = getattr(policy_module, "end_timing_trajectory")
+
+ task_env.suc = 0
+ task_env.test_num = 0
+ now_seed = int(start_seed)
+ settings["eval_mode"] = True
+
+ while True:
+ render_freq = settings["render_freq"]
+ settings["render_freq"] = 0
+ try:
+ task_env.setup_demo(
+ now_ep_num=0,
+ seed=now_seed,
+ is_test=True,
+ **settings,
+ )
+ episode_info = task_env.play_once()
+ task_env.close_env()
+ except official.UnStableError:
+ task_env.close_env()
+ now_seed += 1
+ settings["render_freq"] = render_freq
+ continue
+ except Exception:
+ traceback.print_exc()
+ task_env.close_env()
+ now_seed += 1
+ settings["render_freq"] = render_freq
+ continue
+
+ if not (task_env.plan_success and task_env.check_success()):
+ now_seed += 1
+ settings["render_freq"] = render_freq
+ continue
+
+ settings["render_freq"] = render_freq
+ try:
+ task_env.setup_demo(
+ now_ep_num=0,
+ seed=now_seed,
+ is_test=True,
+ **settings,
+ )
+ except official.UnStableError:
+ task_env.close_env()
+ now_seed += 1
+ continue
+
+ descriptions = official.generate_episode_descriptions(
+ settings["task_name"],
+ [episode_info["info"]],
+ 1,
+ )
+ instruction = np.random.choice(descriptions[0][instruction_type])
+ task_env.set_instruction(instruction=instruction)
+
+ prepare_instruction(task_env, model)
+ if bool(getattr(model, "needs_prewarm", False)):
+ prewarm_model(task_env, model, task_env.get_obs())
+ reset_model(model)
+
+ metadata = {
+ "task": str(task_name),
+ "config": str(settings["task_config"]),
+ "trial": int(trial),
+ "accepted_seed": int(now_seed),
+ }
+ begin_timing(model, metadata)
+ success = False
+ while task_env.take_action_cnt < task_env.step_lim:
+ observation = (
+ task_env.get_obs()
+ if bool(model.should_request_observation())
+ else None
+ )
+ policy_module.eval(task_env, model, observation)
+ if task_env.eval_success:
+ success = True
+ break
+ end_timing(
+ model,
+ success,
+ {
+ **metadata,
+ "environment_action_count": int(task_env.take_action_cnt),
+ "environment_step_limit": int(task_env.step_lim),
+ },
+ )
+
+ if success:
+ task_env.suc = 1
+ task_env.test_num = 1
+ task_env.close_env()
+ if task_env.render_freq:
+ task_env.viewer.close()
+ return now_seed + 1, int(success)
diff --git a/examples/robotwin/multigpu_rollout.py b/examples/robotwin/multigpu_rollout.py
index adc7528..c25c2f3 100644
--- a/examples/robotwin/multigpu_rollout.py
+++ b/examples/robotwin/multigpu_rollout.py
@@ -27,6 +27,29 @@ def _csv(value: str) -> list[str]:
return [item.strip() for item in value.split(",") if item.strip()]
+def resolve_sampling_steps(
+ checkpoint_format: str,
+ inference_mode: str,
+ video_steps: int | None,
+ action_steps: int | None,
+) -> tuple[int, int]:
+ """Resolve the released RoboTwin recipes while preserving CLI overrides."""
+
+ if video_steps is None:
+ if checkpoint_format == "fastwam" and inference_mode == "baseline":
+ video_steps = 10
+ elif checkpoint_format == "starwam" and inference_mode == "baseline":
+ video_steps = 4
+ else:
+ video_steps = 1
+ if action_steps is None:
+ if checkpoint_format in {"fastwam", "streamingwam"} and inference_mode != "baseline":
+ action_steps = 2
+ else:
+ action_steps = video_steps
+ return int(video_steps), int(action_steps)
+
+
def _build_arg_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description="Streaming-WAM RoboTwin multi-GPU evaluation")
parser.add_argument("--config", required=True)
@@ -39,14 +62,31 @@ def _build_arg_parser() -> argparse.ArgumentParser:
parser.add_argument("--inference-python", required=True)
parser.add_argument("--simulator-python", required=True)
parser.add_argument("--inference-mode", choices=("baseline", "cd", "ac-stream"), required=True)
+ parser.add_argument("--num-inference-steps", type=int, default=None)
+ parser.add_argument("--action-num-inference-steps", type=int, default=None)
backend = parser.add_mutually_exclusive_group()
backend.add_argument("--ac-stream-accelerated", action="store_true")
backend.add_argument("--ac-stream-eager", action="store_true")
parser.add_argument("--gpu-ids", default=os.environ.get("GPU_IDS", "0,1,2,3"))
+ parser.add_argument("--inference-gpu-ids", default=None)
+ parser.add_argument("--simulator-gpu-ids", default=None)
+ parser.add_argument("--require-gpu-isolation", action="store_true")
parser.add_argument("--tasks", default=None)
parser.add_argument("--configs", default="demo_clean,demo_randomized")
parser.add_argument("--num-trials", type=int, default=1)
- parser.add_argument("--seed", type=int, default=42)
+ parser.add_argument("--replan-steps", type=int, default=16)
+ parser.add_argument(
+ "--seed",
+ type=int,
+ default=42,
+ help="model inference/noise seed; keep fixed across benchmark retries",
+ )
+ parser.add_argument(
+ "--episode-seed",
+ type=int,
+ default=None,
+ help="RoboTwin scene seed chain; defaults to --seed for compatibility",
+ )
parser.add_argument("--port-base", type=int, default=18765)
parser.add_argument("--job-timeout-seconds", type=float, default=1200.0)
parser.add_argument("--output-dir", default=None)
@@ -63,13 +103,19 @@ def build_server_command(args: argparse.Namespace, *, port: int) -> list[str]:
accelerated=accelerated,
eager=args.ac_stream_eager,
)
+ video_steps, action_steps = resolve_sampling_steps(
+ args.checkpoint_format,
+ args.inference_mode,
+ args.num_inference_steps,
+ args.action_num_inference_steps,
+ )
command = [
args.inference_python, "-m", "examples.robotwin.policy_server",
"--config", args.config, "--checkpoint", args.checkpoint,
"--checkpoint-format", args.checkpoint_format,
"--inference-mode", args.inference_mode,
- "--num-inference-steps", "4" if args.inference_mode == "baseline" else "1",
- "--action-num-inference-steps", "4" if args.inference_mode == "baseline" else "1",
+ "--num-inference-steps", str(video_steps),
+ "--action-num-inference-steps", str(action_steps),
"--seed", str(args.seed),
"--device", "cuda:0", "--host", "127.0.0.1", "--port", str(port),
"--override",
@@ -150,7 +196,7 @@ def _select_pending_jobs(jobs, output_dir: Path) -> tuple[list, list[dict]]:
except (OSError, json.JSONDecodeError):
pending.append(job)
continue
- if result.get("status") in {"completed", "skipped_timeout", "infrastructure_error"}:
+ if result.get("status") == "completed":
existing.append(result)
else:
pending.append(job)
@@ -197,6 +243,19 @@ def _atomic_json(path: Path, payload: dict) -> None:
temporary.replace(path)
+def _ensure_run_config(path: Path, current: dict) -> None:
+ """Prevent a resumed output directory from mixing benchmark protocols."""
+
+ if path.is_file():
+ previous = json.loads(path.read_text(encoding="utf-8"))
+ if previous != current:
+ raise RuntimeError(
+ f"run configuration mismatch in {path}; use a new --output-dir"
+ )
+ return
+ _atomic_json(path, current)
+
+
def _read_phase(path: Path) -> str:
try:
return str(json.loads(path.read_text(encoding="utf-8")).get("phase", "unknown"))
@@ -298,18 +357,19 @@ def launch(item: dict, job) -> None:
status_output.unlink(missing_ok=True)
_atomic_json(job_file, job.__dict__)
log = open(job_dir / "worker.log", "w", encoding="utf-8")
- replan_steps = 16 if args.inference_mode == "ac-stream" else 32
command = [
args.simulator_python, "-m", "examples.robotwin.robotwin_worker",
"--gpu-id", gpu, "--robotwin-home", args.robotwin_home,
"--policy-dir", str(_ROOT / "examples" / "robotwin"),
"--server-port", str(item["port"]),
"--inference-mode", args.inference_mode,
- "--replan-steps", str(replan_steps),
+ "--replan-steps", str(args.replan_steps),
"--job-file", str(job_file),
"--output", str(worker_output),
"--status-output", str(status_output),
- "--seed", str(args.seed),
+ "--seed", str(
+ args.seed if args.episode_seed is None else args.episode_seed
+ ),
"--prewarm" if not warmed[gpu] else "--no-prewarm",
]
try:
@@ -454,7 +514,8 @@ def _terminate_processes(processes: list) -> None:
def _start_server_group(
args: argparse.Namespace,
- gpu_ids: list[str],
+ inference_gpu_ids: list[str],
+ simulator_gpu_ids: list[str],
output_dir: Path,
*,
popen=subprocess.Popen,
@@ -464,21 +525,31 @@ def _start_server_group(
group: list[dict] = []
try:
- for worker_index, gpu in enumerate(gpu_ids):
- worker_dir = output_dir / f"worker_gpu{gpu}"
+ for worker_index, (inference_gpu, simulator_gpu) in enumerate(
+ zip(inference_gpu_ids, simulator_gpu_ids)
+ ):
+ worker_dir = output_dir / (
+ f"pair_{worker_index}_inference_gpu{inference_gpu}_"
+ f"simulator_gpu{simulator_gpu}"
+ )
worker_dir.mkdir(parents=True, exist_ok=True)
port = args.port_base + worker_index
- environment = os.environ.copy()
- environment["CUDA_VISIBLE_DEVICES"] = gpu
- environment["PYTHONPATH"] = (
- str(_ROOT) + os.pathsep + environment.get("PYTHONPATH", "")
+ server_environment = os.environ.copy()
+ server_environment["CUDA_VISIBLE_DEVICES"] = inference_gpu
+ server_environment["PYTHONPATH"] = (
+ str(_ROOT) + os.pathsep + server_environment.get("PYTHONPATH", "")
+ )
+ simulator_environment = os.environ.copy()
+ simulator_environment["CUDA_VISIBLE_DEVICES"] = simulator_gpu
+ simulator_environment["PYTHONPATH"] = (
+ str(_ROOT) + os.pathsep + simulator_environment.get("PYTHONPATH", "")
)
log = open(worker_dir / "server.log", "w", encoding="utf-8")
try:
process = popen(
build_server_command(args, port=port),
cwd=_ROOT,
- env=environment,
+ env=server_environment,
stdout=log,
stderr=subprocess.STDOUT,
start_new_session=True,
@@ -487,10 +558,11 @@ def _start_server_group(
log.close()
raise
group.append({
- "gpu": gpu,
+ "gpu": simulator_gpu,
+ "inference_gpu": inference_gpu,
"port": port,
"worker_dir": worker_dir,
- "environment": environment,
+ "environment": simulator_environment,
"process": process,
"log": log,
})
@@ -506,7 +578,25 @@ def _start_server_group(
def main() -> None:
args = _build_arg_parser().parse_args()
- gpu_ids = _csv(args.gpu_ids)
+ inference_gpu_ids = _csv(args.inference_gpu_ids or args.gpu_ids)
+ simulator_gpu_ids = _csv(args.simulator_gpu_ids or args.gpu_ids)
+ if len(inference_gpu_ids) != len(simulator_gpu_ids):
+ raise ValueError(
+ "--inference-gpu-ids and --simulator-gpu-ids must contain the same "
+ "number of GPUs"
+ )
+ if not inference_gpu_ids:
+ raise ValueError("At least one inference/simulator GPU pair is required")
+ overlap = sorted(set(inference_gpu_ids) & set(simulator_gpu_ids))
+ if args.require_gpu_isolation and overlap:
+ raise ValueError(
+ "canonical timing requires disjoint inference and simulator GPUs; "
+ f"overlap={overlap}"
+ )
+ if args.inference_mode == "ac-stream" and args.replan_steps != 16:
+ raise ValueError("AC-Stream has fixed H=32, s=16, d=8 geometry")
+ if not 1 <= args.replan_steps <= 32:
+ raise ValueError("--replan-steps must be in [1, 32]")
jobs = build_workload(
num_trials=args.num_trials,
tasks=_csv(args.tasks) if args.tasks else None,
@@ -515,16 +605,48 @@ def main() -> None:
stamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
output_dir = Path(args.output_dir or (_ROOT / "outputs" / f"robotwin_multigpu_{stamp}")).resolve()
output_dir.mkdir(parents=True, exist_ok=True)
+ _ensure_run_config(
+ output_dir / "run_config.json",
+ {
+ "config": str(Path(args.config).resolve()),
+ "checkpoint": str(Path(args.checkpoint).resolve()),
+ "checkpoint_format": args.checkpoint_format,
+ "stats_path": str(Path(args.stats_path).resolve()),
+ "backbone_path": str(Path(args.backbone_path).resolve()),
+ "inference_mode": args.inference_mode,
+ "num_inference_steps": args.num_inference_steps,
+ "action_num_inference_steps": args.action_num_inference_steps,
+ "replan_steps": args.replan_steps,
+ "num_trials": args.num_trials,
+ "seed": args.seed,
+ **(
+ {"episode_seed": args.episode_seed}
+ if args.episode_seed is not None
+ and args.episode_seed != args.seed
+ else {}
+ ),
+ "tasks": list(dict.fromkeys(job.task for job in jobs)),
+ "configs": list(dict.fromkeys(job.config for job in jobs)),
+ "ac_stream_accelerated": bool(args.ac_stream_accelerated),
+ "ac_stream_eager": bool(args.ac_stream_eager),
+ },
+ )
server_group: list[dict] = []
try:
pending, existing = _select_pending_jobs(jobs, output_dir)
if pending:
print(
- f"Starting {len(gpu_ids)} inference servers on GPUs "
- f"{','.join(gpu_ids)} ...",
+ f"Starting {len(inference_gpu_ids)} inference servers on GPUs "
+ f"{','.join(inference_gpu_ids)}; simulator GPUs "
+ f"{','.join(simulator_gpu_ids)} ...",
flush=True,
)
- server_group = _start_server_group(args, gpu_ids, output_dir)
+ server_group = _start_server_group(
+ args,
+ inference_gpu_ids,
+ simulator_gpu_ids,
+ output_dir,
+ )
print(
f"All {len(server_group)} inference servers are ready; "
f"dynamically scheduling {len(pending)} RoboTwin jobs ...",
@@ -576,13 +698,27 @@ def main() -> None:
})
results_path = output_dir / "results.json"
_atomic_json(results_path, {
- "mode": mode_label, "gpu_ids": gpu_ids,
+ "mode": mode_label,
+ "inference_gpu_ids": inference_gpu_ids,
+ "simulator_gpu_ids": simulator_gpu_ids,
+ "replan_steps": args.replan_steps,
+ "num_inference_steps": args.num_inference_steps,
+ "action_num_inference_steps": args.action_num_inference_steps,
"backend": backend_values,
"runtime": runtime_values[0] if runtime_values else {},
"summary": summary, "jobs": task_results, "timing": records,
})
+ _atomic_json(output_dir / "per_task_summary.json", summary["by_task"])
+ _atomic_json(output_dir / "per_setting_summary.json", summary["by_setting"])
print(format_summary(
- mode=mode_label, gpu_ids=gpu_ids, jobs=len(jobs),
+ mode=mode_label,
+ gpu_ids=[
+ f"{inference}->{simulator}"
+ for inference, simulator in zip(
+ inference_gpu_ids, simulator_gpu_ids
+ )
+ ],
+ jobs=len(jobs),
summary=summary, results_path=results_path,
completed=completed,
skipped=skipped + infrastructure_errors,
diff --git a/examples/robotwin/policy_server.py b/examples/robotwin/policy_server.py
index 8502f18..5cfb5f9 100644
--- a/examples/robotwin/policy_server.py
+++ b/examples/robotwin/policy_server.py
@@ -128,6 +128,9 @@ def handle_request(policy: StreamingWAMPolicy, req: dict) -> dict:
if cmd == "reset":
policy.reset()
return {"ok": True, "request_id": request_id}
+ if cmd == "prepare_instruction":
+ policy._encode_context(str(req["instruction"]))
+ return {"ok": True, "request_id": request_id}
if cmd != "infer":
raise ValueError(f"unsupported policy command {cmd!r}")
server_started_ns = time.perf_counter_ns()
diff --git a/examples/robotwin/robotwin_worker.py b/examples/robotwin/robotwin_worker.py
index ce1b66c..494458e 100644
--- a/examples/robotwin/robotwin_worker.py
+++ b/examples/robotwin/robotwin_worker.py
@@ -4,10 +4,11 @@
import argparse
import faulthandler
-import importlib
+import importlib.util
import json
import os
import signal
+import subprocess
import sys
import traceback
from pathlib import Path
@@ -15,6 +16,80 @@
import yaml
+def _normalize_pci_bus_id(value: str) -> str:
+ value = value.strip().lower()
+ domain, bus, device_function = value.split(":")
+ device, function = device_function.split(".", 1)
+ return (
+ f"{int(domain, 16):04x}:{int(bus, 16):02x}:"
+ f"{int(device, 16):02x}.{int(function, 16):x}"
+ )
+
+
+def _sapien_render_device_alias(gpu_id: str) -> str:
+ override = os.environ.get("STREAMINGWAM_SAPIEN_RENDER_DEVICE")
+ if override and override.lower() != "auto":
+ return override
+ completed = subprocess.run(
+ [
+ "nvidia-smi",
+ "-i",
+ str(gpu_id),
+ "--query-gpu=pci.bus_id",
+ "--format=csv,noheader",
+ ],
+ check=True,
+ capture_output=True,
+ text=True,
+ )
+ return f"pci:{_normalize_pci_bus_id(completed.stdout.strip().splitlines()[0])}"
+
+
+def _bind_sapien3_renderer(gpu_id: str) -> None:
+ """Bind RoboTwin's Vulkan renderer to the requested physical GPU."""
+
+ import sapien as sapien_package
+ import sapien.core as sapien
+
+ version = str(getattr(sapien_package, "__version__", ""))
+ if not version.startswith("3."):
+ return
+ alias = _sapien_render_device_alias(gpu_id)
+ device = sapien.Device(alias)
+ if not device.can_render():
+ raise RuntimeError(f"SAPIEN device {alias} cannot render")
+ logged = False
+
+ def create_renderer(**_kwargs):
+ return sapien.render.SapienRenderer(device)
+
+ def create_scene(_engine, config=None):
+ nonlocal logged
+ config = sapien.SceneConfig() if config is None else config
+ sapien.physx.set_scene_config(config)
+ scene = sapien.Scene(
+ [sapien.physx.PhysxCpuSystem(), sapien.render.RenderSystem(device)]
+ )
+ selected = scene.render_system.device
+ if selected.pci_string != device.pci_string:
+ raise RuntimeError(
+ "SAPIEN render device mismatch: "
+ f"requested={device.pci_string}, selected={selected.pci_string}"
+ )
+ if not logged:
+ print(
+ f"[robotwin worker] renderer={selected.pci_string} "
+ f"cuda_id={selected.cuda_id}",
+ flush=True,
+ )
+ logged = True
+ return scene
+
+ sapien.SapienRenderer = create_renderer
+ sapien_package.SapienRenderer = create_renderer
+ sapien.Engine.create_scene = create_scene
+
+
def _parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser()
parser.add_argument("--gpu-id", required=True)
@@ -53,6 +128,37 @@ def write_job_status(path: Path, job: dict, *, phase: str, **extra) -> None:
_atomic_json(path, {**job, "phase": str(phase), **extra})
+def load_policy_module(policy_dir: Path):
+ """Load this checkout's deploy policy without top-level-name ambiguity."""
+
+ path = (policy_dir / "deploy_policy.py").resolve()
+ if not path.is_file():
+ raise FileNotFoundError(f"RoboTwin deploy policy does not exist: {path}")
+ module_name = f"_streamingwam_robotwin_deploy_policy_{os.getpid()}"
+ spec = importlib.util.spec_from_file_location(module_name, path)
+ if spec is None or spec.loader is None:
+ raise ImportError(f"cannot load RoboTwin deploy policy from {path}")
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ required = (
+ "get_model",
+ "eval",
+ "reset_model",
+ "prepare_instruction",
+ "prewarm_model",
+ "begin_timing_trajectory",
+ "end_timing_trajectory",
+ "_finish_episode",
+ )
+ missing = [name for name in required if not callable(getattr(module, name, None))]
+ if missing:
+ raise AttributeError(
+ f"deploy policy {path} is missing required hooks: {', '.join(missing)}"
+ )
+ print(f"[robotwin worker] deploy_policy={path}", flush=True)
+ return module
+
+
def main() -> int:
args = _parser().parse_args()
for stream in (sys.stdout, sys.stderr):
@@ -61,6 +167,7 @@ def main() -> int:
reconfigure(line_buffering=True)
faulthandler.register(signal.SIGUSR1, file=sys.stderr, all_threads=True)
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu_id)
+ _bind_sapien3_renderer(str(args.gpu_id))
robotwin = Path(args.robotwin_home).resolve()
policy_dir = Path(args.policy_dir).resolve()
output = Path(args.output).resolve()
@@ -72,9 +179,14 @@ def main() -> int:
str(policy_dir), str(robotwin), str(robotwin / "script"),
str(robotwin / "description" / "utils"),
]
- from eval_policy import class_decorator, eval_policy, get_camera_config, get_embodiment_config
+ import eval_policy as official_eval
+ from examples.robotwin.evaluator import evaluate_one_episode
+
+ class_decorator = official_eval.class_decorator
+ get_camera_config = official_eval.get_camera_config
+ get_embodiment_config = official_eval.get_embodiment_config
- policy_module = importlib.import_module("deploy_policy")
+ policy_module = load_policy_module(policy_dir)
model = policy_module.get_model({
"server_host": "127.0.0.1",
"server_port": args.server_port,
@@ -116,11 +228,16 @@ def environment_args(task: str, config: str) -> dict:
write_job_status(status_output, job, phase="environment_and_policy", gpu_id=args.gpu_id)
try:
task_environment = class_decorator(task)
- _, successes = eval_policy(
- task, task_environment, environment_args(task, config), model,
- 100000 * (1 + args.seed) + trial,
- test_num=1, video_size=None, instruction_type="unseen",
- skip_get_obs_within_replan=False,
+ _, successes = evaluate_one_episode(
+ official=official_eval,
+ task_name=task,
+ task_env=task_environment,
+ settings=environment_args(task, config),
+ model=model,
+ start_seed=100000 * (1 + args.seed) + trial,
+ trial=trial,
+ instruction_type="unseen",
+ policy_module=policy_module,
)
result = {
**job, "status": "completed", "success": int(successes),
@@ -138,6 +255,10 @@ def environment_args(task: str, config: str) -> dict:
policy_module._finish_episode(model)
model.close()
timing = list(model._timing_records) + list(model._episode_records)
+ for record in timing:
+ record.setdefault("task", task)
+ record.setdefault("config", config)
+ record.setdefault("trial", trial)
_atomic_json(output, {"gpu_id": args.gpu_id, "result": result, "timing": timing})
write_job_status(
status_output, job, phase="complete", gpu_id=args.gpu_id,
diff --git a/examples/robotwin/scripts/run_streamingwam_robotwin_benchmark.sh b/examples/robotwin/scripts/run_streamingwam_robotwin_benchmark.sh
new file mode 100644
index 0000000..6d4b3be
--- /dev/null
+++ b/examples/robotwin/scripts/run_streamingwam_robotwin_benchmark.sh
@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# Canonical RoboTwin benchmark: fixed trials, R16, per-task success/Chunk/Total Time.
+# CHECKPOINT_FORMAT and MODE select released family defaults; explicit
+# NUM_INFERENCE_STEPS/ACTION_NUM_INFERENCE_STEPS always take precedence.
+set -euo pipefail
+
+ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)
+cd "$ROOT"
+
+MODE=${MODE:?set MODE=baseline|cd|ac-stream}
+CKPT=${CKPT:?set CKPT}
+CHECKPOINT_FORMAT=${CHECKPOINT_FORMAT:?set CHECKPOINT_FORMAT=fastwam|starwam|streamingwam}
+CONFIG=${CONFIG:?set CONFIG to the RoboTwin recipe}
+STATS_PATH=${STATS_PATH:?set STATS_PATH}
+BACKBONE_PATH=${BACKBONE_PATH:?set BACKBONE_PATH}
+ROBOTWIN_HOME=${ROBOTWIN_HOME:?set ROBOTWIN_HOME}
+INFERENCE_PYTHON=${INFERENCE_PYTHON:?set INFERENCE_PYTHON}
+SIMULATOR_PYTHON=${SIMULATOR_PYTHON:?set SIMULATOR_PYTHON}
+
+GPU_TOPOLOGY=${GPU_TOPOLOGY:-colocated}
+GPU_IDS=${GPU_IDS:-0,1,2,3}
+NUM_TRIALS=${NUM_TRIALS:-100}
+REPLAN_STEPS=${REPLAN_STEPS:-16}
+MODEL_SEED=${MODEL_SEED:-${SEED:-42}}
+EPISODE_SEED=${EPISODE_SEED:-$MODEL_SEED}
+TEXT_CACHE_PATH=${TEXT_CACHE_PATH:-/inspire/qb-ilm/project/qproject-fundationmodel/yangyi-253108120173/yzy/starwam/cache/text_embeds_cache}
+OUTPUT_DIR=${OUTPUT_DIR:-$ROOT/outputs/robotwin_${MODE}_${CHECKPOINT_FORMAT}_r${REPLAN_STEPS}_${NUM_TRIALS}trials_$(date +%Y%m%d_%H%M%S)}
+
+command=(
+ "$INFERENCE_PYTHON" examples/robotwin/multigpu_rollout.py
+ --config "$CONFIG"
+ --checkpoint "$CKPT"
+ --checkpoint-format "$CHECKPOINT_FORMAT"
+ --stats-path "$STATS_PATH"
+ --backbone-path "$BACKBONE_PATH"
+ --text-cache-path "$TEXT_CACHE_PATH"
+ --robotwin-home "$ROBOTWIN_HOME"
+ --inference-python "$INFERENCE_PYTHON"
+ --simulator-python "$SIMULATOR_PYTHON"
+ --inference-mode "$MODE"
+ --num-trials "$NUM_TRIALS"
+ --replan-steps "$REPLAN_STEPS"
+ --seed "$MODEL_SEED"
+ --episode-seed "$EPISODE_SEED"
+ --output-dir "$OUTPUT_DIR"
+)
+
+case "$GPU_TOPOLOGY" in
+ colocated)
+ # One inference server and one isolated simulator worker share each GPU.
+ # D8 action execution suppresses redundant SAPIEN renders while inference
+ # is in flight, so the four-GPU path keeps four jobs active in parallel.
+ command+=(--gpu-ids "$GPU_IDS")
+ ;;
+ split)
+ INFERENCE_GPU_IDS=${INFERENCE_GPU_IDS:-0,1}
+ SIMULATOR_GPU_IDS=${SIMULATOR_GPU_IDS:-2,3}
+ command+=(
+ --inference-gpu-ids "$INFERENCE_GPU_IDS"
+ --simulator-gpu-ids "$SIMULATOR_GPU_IDS"
+ --require-gpu-isolation
+ )
+ ;;
+ *)
+ echo "GPU_TOPOLOGY must be colocated or split, got: $GPU_TOPOLOGY" >&2
+ exit 2
+ ;;
+esac
+
+if [[ -n "${NUM_INFERENCE_STEPS:-}" ]]; then
+ command+=(--num-inference-steps "$NUM_INFERENCE_STEPS")
+fi
+if [[ -n "${ACTION_NUM_INFERENCE_STEPS:-}" ]]; then
+ command+=(--action-num-inference-steps "$ACTION_NUM_INFERENCE_STEPS")
+fi
+if [[ "$MODE" == "ac-stream" ]]; then
+ if [[ "${AC_STREAM_BACKEND:-accelerated}" == "eager" ]]; then
+ command+=(--ac-stream-eager)
+ else
+ command+=(--ac-stream-accelerated)
+ fi
+fi
+
+exec "${command[@]}" "$@"
diff --git a/examples/robotwin/timing.py b/examples/robotwin/timing.py
index 3e70f1f..1641ade 100644
--- a/examples/robotwin/timing.py
+++ b/examples/robotwin/timing.py
@@ -1,30 +1,160 @@
-"""Small, benchmark-facing RoboTwin timing aggregation helpers."""
+"""Benchmark-facing RoboTwin success, Chunk Time, and Total Time aggregation."""
from __future__ import annotations
+from collections import defaultdict
import statistics
from typing import Iterable
-def aggregate_evaluation(records: Iterable[dict]) -> dict:
- records = list(records)
- chunks = [
- float(record["model_inference_ms"])
+def _mean(values: list[float]) -> float | None:
+ return statistics.fmean(values) if values else None
+
+
+def _chunk_records(records: list[dict]) -> list[dict]:
+ inference = [
+ record
for record in records
if record.get("record_type") == "inference"
and not bool(record.get("warmup"))
and "model_inference_ms" in record
]
+ d8 = [record for record in inference if record.get("regime") == "d8"]
+ return d8 or inference
+
+
+def aggregate_evaluation(records: Iterable[dict]) -> dict:
+ """Aggregate fixed-episode results without hiding task-level variation.
+
+ Chunk Time is the CUDA-synchronized model call (D8 for AC-Stream, sync for
+ baseline/CD). Total Time uses successful trajectories only, averages each
+ task/config setting first, and then weights every covered setting equally.
+ Failed trajectories remain in the success-rate denominator.
+ """
+
+ records = list(records)
+ selected_chunks = _chunk_records(records)
episodes = [
record
for record in records
if record.get("record_type") == "episode" and "total_time_s" in record
]
- episode_times = [float(record["total_time_s"]) for record in episodes]
+ successful = [record for record in episodes if record.get("success") is True]
+
+ setting_episodes: dict[tuple[str, str], list[dict]] = defaultdict(list)
+ successful_times: dict[tuple[str, str], list[float]] = defaultdict(list)
+ setting_chunks: dict[tuple[str, str], list[float]] = defaultdict(list)
+ for record in episodes:
+ key = (str(record.get("config")), str(record.get("task")))
+ setting_episodes[key].append(record)
+ for record in successful:
+ key = (str(record.get("config")), str(record.get("task")))
+ successful_times[key].append(float(record["total_time_s"]))
+ for record in selected_chunks:
+ key = (str(record.get("config")), str(record.get("task")))
+ setting_chunks[key].append(float(record["model_inference_ms"]))
+
+ by_setting = {}
+ for key, selected in sorted(setting_episodes.items()):
+ config, task = key
+ successes = sum(record.get("success") is True for record in selected)
+ attempts = len(selected)
+ times = successful_times.get(key, [])
+ by_setting[f"{config}/{task}"] = {
+ "task": task,
+ "config": config,
+ "successes": successes,
+ "episodes": attempts,
+ "success_rate": successes / attempts if attempts else None,
+ "total_time_success_s": _mean(times),
+ "successful_timed_episodes": len(times),
+ "chunk_time_ms": _mean(setting_chunks.get(key, [])),
+ }
+
+ task_settings: dict[str, list[tuple[str, str]]] = defaultdict(list)
+ for key in setting_episodes:
+ task_settings[key[1]].append(key)
+ by_task = {}
+ for task, keys in sorted(task_settings.items()):
+ selected = [record for key in keys for record in setting_episodes[key]]
+ successes = sum(record.get("success") is True for record in selected)
+ attempts = len(selected)
+ setting_means = [
+ mean
+ for key in keys
+ if (mean := _mean(successful_times.get(key, []))) is not None
+ ]
+ by_task[task] = {
+ "successes": successes,
+ "episodes": attempts,
+ "success_rate": successes / attempts if attempts else None,
+ "total_time_success_s": _mean(setting_means),
+ "covered_configs": len(setting_means),
+ }
+
+ config_settings: dict[str, list[tuple[str, str]]] = defaultdict(list)
+ for key in setting_episodes:
+ config_settings[key[0]].append(key)
+ by_config = {}
+ for config, keys in sorted(config_settings.items()):
+ selected = [record for key in keys for record in setting_episodes[key]]
+ successes = sum(record.get("success") is True for record in selected)
+ attempts = len(selected)
+ setting_time_means = [
+ mean
+ for key in keys
+ if (mean := _mean(successful_times.get(key, []))) is not None
+ ]
+ config_chunk_values = [
+ value for key in keys for value in setting_chunks.get(key, [])
+ ]
+ by_config[config] = {
+ "successes": successes,
+ "episodes": attempts,
+ "success_rate": successes / attempts if attempts else None,
+ "total_time_success_s": _mean(setting_time_means),
+ "covered_settings": len(setting_time_means),
+ "chunk_time_ms": _mean(config_chunk_values),
+ }
+
+ setting_means = [
+ mean
+ for values in successful_times.values()
+ if (mean := _mean(values)) is not None
+ ]
+ chunks = [float(record["model_inference_ms"]) for record in selected_chunks]
+ all_inference = [
+ record
+ for record in records
+ if record.get("record_type") == "inference"
+ and not bool(record.get("warmup"))
+ and "model_inference_ms" in record
+ ]
+ by_regime = {
+ regime: _mean(
+ [
+ float(record["model_inference_ms"])
+ for record in all_inference
+ if record.get("regime") == regime
+ ]
+ )
+ for regime in ("sync", "d0", "d8")
+ if any(record.get("regime") == regime for record in all_inference)
+ }
+
return {
- "chunk_time_ms": statistics.fmean(chunks) if chunks else None,
- "total_time_per_episode_s": statistics.fmean(episode_times) if episode_times else None,
+ "chunk_time_ms": _mean(chunks),
+ "chunk_time_by_regime_ms": by_regime,
+ "total_time_per_episode_s": _mean(setting_means),
+ "successful_episode_time_s": _mean(
+ [float(record["total_time_s"]) for record in successful]
+ ),
"chunks": len(chunks),
- "successes": sum(record.get("success") is True for record in episodes),
+ "successes": len(successful),
"episodes": len(episodes),
+ "success_rate": len(successful) / len(episodes) if episodes else None,
+ "timed_settings": len(setting_means),
+ "by_config": by_config,
+ "by_task": by_task,
+ "by_setting": by_setting,
}
diff --git a/streamingwam/inference/ac_stream.py b/streamingwam/inference/ac_stream.py
index 52b7f72..4658e8e 100644
--- a/streamingwam/inference/ac_stream.py
+++ b/streamingwam/inference/ac_stream.py
@@ -538,6 +538,22 @@ def __init__(
def cursor(self) -> int:
return self._cursor
+ @property
+ def observation_required(self) -> bool:
+ """Whether the next action request launches an observation-conditioned chunk."""
+
+ if self._current is None:
+ return True
+ return (
+ self._future is None
+ and self._cursor >= self._next_launch_cursor
+ and self._cursor < self._window_end_cursor
+ )
+
+ @property
+ def inference_in_flight(self) -> bool:
+ return self._future is not None
+
def start_episode(self, observation: Any) -> ACStreamPrediction:
if self._closed:
raise RuntimeError("AC-Stream controller is closed")
diff --git a/tests/test_robotwin_inference_modes.py b/tests/test_robotwin_inference_modes.py
index a2c592e..a5b874f 100644
--- a/tests/test_robotwin_inference_modes.py
+++ b/tests/test_robotwin_inference_modes.py
@@ -5,7 +5,10 @@
import torch
from streamingwam.eval.policy import StreamingWAMPolicy
+from streamingwam.inference.ac_stream import ACStreamController, ACStreamPrediction
from examples.robotwin.runtime import resolve_inference_runtime
+from examples.robotwin.multigpu_rollout import resolve_sampling_steps
+from examples.robotwin.timing import aggregate_evaluation
class _RecordingModel:
@@ -109,3 +112,73 @@ def test_robotwin_runtime_rejects_ac_stream_backend_for_sync_modes(mode: str) ->
def test_robotwin_runtime_rejects_conflicting_ac_stream_backends() -> None:
with pytest.raises(ValueError, match="mutually exclusive"):
resolve_inference_runtime("ac-stream", accelerated=True, eager=True)
+
+
+@pytest.mark.parametrize(
+ ("checkpoint_format", "mode", "expected"),
+ [
+ ("starwam", "baseline", (4, 4)),
+ ("starwam", "cd", (1, 1)),
+ ("starwam", "ac-stream", (1, 1)),
+ ("fastwam", "baseline", (10, 10)),
+ ("fastwam", "cd", (1, 2)),
+ ("streamingwam", "ac-stream", (1, 2)),
+ ],
+)
+def test_robotwin_sampling_steps_follow_checkpoint_family(
+ checkpoint_format: str,
+ mode: str,
+ expected: tuple[int, int],
+) -> None:
+ assert resolve_sampling_steps(checkpoint_format, mode, None, None) == expected
+
+
+def test_robotwin_sampling_step_overrides_are_preserved() -> None:
+ assert resolve_sampling_steps("fastwam", "baseline", 3, 5) == (3, 5)
+
+
+def test_ac_stream_requests_observation_only_at_d0_and_d8_launch() -> None:
+ calls = []
+
+ def predict(observation, previous, delay):
+ calls.append((observation, previous, delay))
+ actions = torch.zeros((32, 7), dtype=torch.float32)
+ return ACStreamPrediction(
+ env_actions=actions.numpy(),
+ model_actions=actions,
+ communication_ms=0.0,
+ inference_ms=1.0,
+ )
+
+ controller = ACStreamController(predict)
+ controller.start_episode("d0")
+ assert controller.observation_required is False
+ for _ in range(8):
+ controller.next_action(None)
+ controller.mark_action_executed()
+ assert controller.observation_required is True
+ controller.next_action("d8")
+ controller.mark_action_executed()
+ assert controller.observation_required is False
+ controller.close()
+ assert [call[2] for call in calls] == [0, 8]
+
+
+def test_robotwin_summary_uses_success_only_macro_total_and_d8_chunk() -> None:
+ records = [
+ {"record_type": "inference", "regime": "d0", "model_inference_ms": 100.0},
+ {"record_type": "inference", "regime": "d8", "model_inference_ms": 40.0},
+ {"record_type": "inference", "regime": "d8", "model_inference_ms": 50.0},
+ {"record_type": "episode", "task": "task", "config": "clean", "success": True, "total_time_s": 10.0},
+ {"record_type": "episode", "task": "task", "config": "clean", "success": True, "total_time_s": 30.0},
+ {"record_type": "episode", "task": "task", "config": "clean", "success": False, "total_time_s": 999.0},
+ {"record_type": "episode", "task": "task", "config": "random", "success": True, "total_time_s": 100.0},
+ ]
+
+ summary = aggregate_evaluation(records)
+
+ assert summary["chunk_time_ms"] == pytest.approx(45.0)
+ assert summary["total_time_per_episode_s"] == pytest.approx(60.0)
+ assert summary["successes"] == 3
+ assert summary["episodes"] == 4
+ assert summary["by_setting"]["clean/task"]["total_time_success_s"] == pytest.approx(20.0)
From a8f998c5ec38566d149d7eacddb2162961768b06 Mon Sep 17 00:00:00 2001
From: TaylorSwift222 <179662524+TaylorSwift222@users.noreply.github.com>
Date: Sun, 30 Aug 2026 20:30:44 +0800
Subject: [PATCH 2/2] docs: publish RoboTwin benchmark results
---
README.md | 29 +++++++++-------
docs/assets/streaming-wam-chunk-time.png | Bin 129230 -> 107327 bytes
docs/assets/streaming-wam-episode-time.png | Bin 143269 -> 115320 bytes
docs/generate_latency_figure.py | 6 ++--
docs/index.html | 29 +++++++++-------
examples/robotwin/RoboTwin.md | 37 ++++++++++++++++++++-
6 files changed, 73 insertions(+), 28 deletions(-)
diff --git a/README.md b/README.md
index 33a1e34..4aee340 100644
--- a/README.md
+++ b/README.md
@@ -119,14 +119,16 @@ setting.
| Method | Clean ↑ | Random ↑ | Total ↑ |
|---|---:|---:|---:|
-| π₀ | 65.92 | 58.40 | 62.2 |
-| π₀.₅ | 82.74 | 76.76 | 79.8 |
-| Motus | **88.66** | 87.02 | **87.8** |
-| Motus from WAN2.2 | 77.56 | 77.00 | 77.3 |
-| FastWAM-Joint | 87.8 | 87.32 | 87.56 |
-| StarWAM-Joint | 84.8 | 86.0 | 85.4 |
-| StarWAM-CD | 79.0 | 79.2 | 79.1 |
-| Streaming-WAM (Ours) | 87.2 | **88.8** | 87.6 |
+| π₀ | 65.92 | 58.40 | 62.20 |
+| π₀.₅ | 82.74 | 76.76 | 79.80 |
+| Motus | 88.66 | 87.02 | 87.80 |
+| Motus from WAN2.2 | 77.56 | 77.00 | 77.30 |
+| FastWAM-Joint | 86.40 | 87.60 | 87.00 |
+| FastWAM-Joint-CD | 86.20 | 85.80 | 86.00 |
+| Streaming-WAM (FastWAM, Ours) | **90.40** | **90.80** | **90.60** |
+| StarWAM-Joint | 87.80 | 84.60 | 86.20 |
+| StarWAM-CD | 85.40 | 86.20 | 85.80 |
+| Streaming-WAM (StarWAM, Ours) | 86.60 | 85.80 | 86.20 |
#### RoboCasa
@@ -164,14 +166,17 @@ Task success alone does not characterize runtime efficiency. We therefore report
| LIBERO | Streaming-WAM | 41.0 ms | 5.36 s Long / 3.15 s Short |
| LIBERO | Streaming-WAM w/o Action Conditioning | 35.1 ms | 5.20 s Long / 2.92 s Short |
| LIBERO | Streaming-WAM w/o Slot Encoder | 36.3 ms | 5.31 s Long / 3.01 s Short |
-| RoboTwin 2.0 | StarWAM-Joint | 190.17 ms | 110.22 s |
-| RoboTwin 2.0 | StarWAM-CD | 81.21 ms | 102.59 s |
-| RoboTwin 2.0 | Streaming-WAM | 47.09 ms | 77.48 s |
+| RoboTwin 2.0 | FastWAM-Joint | 652.1 ms | 24.26 s |
+| RoboTwin 2.0 | FastWAM-Joint-CD | 165.2 ms | 18.63 s |
+| RoboTwin 2.0 | Streaming-WAM (FastWAM) | 54.4 ms | 20.14 s |
+| RoboTwin 2.0 | StarWAM-Joint | 196.5 ms | 25.76 s |
+| RoboTwin 2.0 | StarWAM-CD | 83.1 ms | 26.23 s |
+| RoboTwin 2.0 | Streaming-WAM (StarWAM) | 36.6 ms | 24.44 s |
| RoboCasa | X-WAM | 374.07 ms | 17.36 s |
| RoboCasa | X-WAM-CD | 134.37 ms | 13.04 s |
| RoboCasa | Streaming-WAM | 115.98 ms | 9.49 s |
-Across all three benchmarks, Streaming-WAM reduces both runtime measures while maintaining comparable task success. On LIBERO, it achieves a 12.0× Chunk Time speedup over FastWAM and Episode Time speedups of 3.0× and 2.6× on Long and Short tasks, respectively, with 98.20% average success. On RoboTwin 2.0, relative to StarWAM-Joint, Chunk Time falls from 190.17 ms to 47.09 ms and Episode Time from 110.22 s to 77.48 s, while overall success increases from 85.4 to 87.6. On RoboCasa, relative to X-WAM, Streaming-WAM achieves a 3.2× Chunk Time speedup and a 1.8× Episode Time speedup, with comparable average success (75.35% versus 75.42%).
+Across all three benchmarks, Streaming-WAM reduces Chunk Time while maintaining competitive task success. On LIBERO, it achieves a 12.0× Chunk Time speedup over FastWAM and Episode Time speedups of 3.0× and 2.6× on Long and Short tasks, respectively, with 98.20% average success. On RoboTwin 2.0, the FastWAM version reduces Chunk Time from 652.1 ms to 54.4 ms and Episode Time from 24.26 s to 20.14 s, while success rises from 87.00 to 90.60. The StarWAM version reduces Chunk Time from 196.5 ms to 36.6 ms and Episode Time from 25.76 s to 24.44 s, with the same 86.20 overall success. On RoboCasa, relative to X-WAM, Streaming-WAM achieves a 3.2× Chunk Time speedup and a 1.8× Episode Time speedup, with comparable average success (75.35% versus 75.42%).
## Runtime layout
diff --git a/docs/assets/streaming-wam-chunk-time.png b/docs/assets/streaming-wam-chunk-time.png
index d249450c60b9f2cefaac9ab1d340ae7c0d5df5f1..f283c204c57ad1a0305adebc0b512880ea7d6c8e 100644
GIT binary patch
literal 107327
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