| |
| """Time 4-step guided RTC on the stack checkpoint and check the prefix. |
| |
| Does not rewrite config.json. Prints whether the measured guided latency |
| still fits inside chunk_size at 20 Hz. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import time |
|
|
| import torch |
|
|
| CKPT = "/home/sdznkj/zkx_ws/sendlerobot/smolvla_rm65_stack_30ep_s1000" |
|
|
|
|
| def _batch(policy, device: torch.device) -> dict: |
| g = torch.Generator(device="cpu").manual_seed(0) |
| state_dim = int(policy.config.robot_state_feature.shape[0]) |
| img = torch.rand(1, 3, 240, 320, generator=g) |
| state = torch.randn(1, state_dim, generator=g) |
| batch = {"observation.state": state.to(device), "task": "Stack three cylinder blocks."} |
| for key in policy.config.image_features: |
| batch[key] = img.clone().to(device) |
| return batch |
|
|
|
|
| def _ms(fn) -> tuple[float, torch.Tensor]: |
| if torch.cuda.is_available(): |
| torch.cuda.synchronize() |
| t0 = time.perf_counter() |
| out = fn() |
| if torch.cuda.is_available(): |
| torch.cuda.synchronize() |
| return (time.perf_counter() - t0) * 1000.0, out |
|
|
|
|
| def main() -> int: |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--device", default="cuda") |
| parser.add_argument("--fps", type=float, default=20.0) |
| args = parser.parse_args() |
|
|
| from lerobot.scripts.server.rm65_ckpt import load_smolvla_for_server |
| from lerobot.scripts.server.rm65_rtc import enable_smolvla_rtc |
|
|
| device = torch.device(args.device if torch.cuda.is_available() or args.device == "cpu" else "cpu") |
| policy = load_smolvla_for_server(CKPT, str(device), sanitize=False) |
| enable_smolvla_rtc(policy, num_steps=4, execution_horizon=13, ckpt_dir=CKPT) |
| policy.eval() |
|
|
| batch = _batch(policy, device) |
| noise = torch.randn(1, policy.config.chunk_size, policy.config.max_action_dim, device=device) |
|
|
| _ms(lambda: policy.predict_action_chunk(batch, noise=noise.clone())) |
| plain_ms, plain = _ms(lambda: policy.predict_action_chunk(batch, noise=noise.clone())) |
|
|
| leftover = plain.detach() |
| if leftover.ndim == 3: |
| leftover = leftover[0] |
| |
| delay = 8 |
| leftover = leftover[delay:].cpu() |
| guided_ms, guided = _ms( |
| lambda: policy.predict_action_chunk( |
| batch, |
| noise=noise.clone(), |
| prev_chunk_left_over=leftover, |
| inference_delay=delay, |
| execution_horizon=13, |
| ) |
| ) |
| guided = guided[0] if guided.ndim == 3 else guided |
| again_ms, again = _ms(lambda: policy.predict_action_chunk(batch, noise=noise.clone())) |
| again = again[0] if again.ndim == 3 else again |
| ref = leftover[:5].to(guided.device) |
| width = ref.shape[-1] |
| rtc_mae = (guided[:5, :width] - ref).abs().mean().item() |
| base_mae = (again[:5, :width] - ref).abs().mean().item() |
|
|
| dt_ms = 1000.0 / args.fps |
| plain_steps = plain_ms / dt_ms |
| guided_steps = guided_ms / dt_ms |
| chunk = int(policy.config.chunk_size) |
| print(f"relative={policy.config.use_relative_actions} num_steps={policy.config.num_steps} chunk={chunk}") |
| print(f"plain_ms={plain_ms:.0f} (~{plain_steps:.1f} steps @ {args.fps:.0f}Hz)") |
| print(f"guided_ms={guided_ms:.0f} (~{guided_steps:.1f} steps @ {args.fps:.0f}Hz) repeat_plain_ms={again_ms:.0f}") |
| print(f"prefix_mae_first5 rtc={rtc_mae:.4f} unguided={base_mae:.4f} leftover_T={tuple(leftover.shape)}") |
| fits = guided_steps < chunk - 2 |
| print(f"fits_in_chunk={fits} prefix_improved={rtc_mae < base_mae}") |
| return 0 if fits and rtc_mae < base_mae else 1 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
