Download pi05_v3/code/test_server_client.py from prlq/mobilemanipbench-data: direct link, hf CLI and curl.
- Browser
- Download file 5.68 kB
-
https://huggingface.co/datasets/prlq/mobilemanipbench-data/resolve/main/pi05_v3/code/test_server_client.py
- Command line
-
hf download hf://datasets/prlq/mobilemanipbench-data/pi05_v3/code/test_server_client.py
-
curl -L -o test_server_client.py https://huggingface.co/datasets/prlq/mobilemanipbench-data/resolve/main/pi05_v3/code/test_server_client.py
5.68 kB
| """Client-side test of the pi0.5 MMB policy server (shared interface): sends real dataset frames (raw 480x640 RGB head / | |
| wrist images, the stored canonical state, robot_id, task string) and checks the response format; compares the | |
| predicted chunk with the training target (expert targets + recorded commands) and decodes it with the real base pose. | |
| Usage: OPENPI_VIDEO_BACKEND=pyav HF_LEROBOT_HOME=/data/changyi/mmb/lerobot python test_server_client.py [--port 8000] [--n 20]""" | |
| import argparse | |
| import json | |
| import random | |
| import time | |
| from pathlib import Path | |
| import numpy as np | |
| import pyarrow.parquet as pq | |
| from lerobot.common.datasets.lerobot_dataset import LeRobotDataset | |
| from openpi_client import websocket_client_policy | |
| from openpi.policies import mmb_canonical_action as ca | |
| ROOT = Path("/data/changyi/mmb/merged_v2t") | |
| NAMES = {0: "go2_arm", 1: "sawyer_umi", 2: "stretch3"} | |
| def to_uint8_hwc(img): | |
| x = np.asarray(img) | |
| if x.shape[0] == 3: | |
| x = np.transpose(x, (1, 2, 0)) | |
| if x.dtype != np.uint8: | |
| x = np.clip(np.round(x * 255), 0, 255).astype(np.uint8) | |
| return x | |
| def main(): | |
| ap = argparse.ArgumentParser(); ap.add_argument("--port", type=int, default=8000); ap.add_argument("--n", type=int, default=20) | |
| a = ap.parse_args() | |
| client = websocket_client_policy.WebsocketClientPolicy("localhost", a.port) | |
| meta = client.get_server_metadata() | |
| print("server metadata:", json.dumps(meta, default=str), flush=True) | |
| H = int(meta["action_horizon"]) | |
| ds = LeRobotDataset("mmb/v2t", video_backend="pyav") | |
| eps = [json.loads(l) for l in open(ROOT / "meta/episodes.jsonl")] | |
| src = [json.loads(l) for l in open(ROOT / "meta/source_map.jsonl")] | |
| offsets = np.concatenate([[0], np.cumsum([e["length"] for e in eps])]) | |
| random.seed(7) | |
| by = {} | |
| for i, s in enumerate(src): | |
| by.setdefault(s["robot"], []).append(i) | |
| res = {r: {"pos_cm": [], "rot_deg": [], "grip_ok": [], "base_err": [], "ms": [], "dec_pos_cm": []} for r in ca.ROBOTS} | |
| fmt_ok = True | |
| for robot in ca.ROBOTS: | |
| for ep in random.sample(by[robot], a.n): | |
| L = eps[ep]["length"]; t = random.randrange(L) | |
| item = ds[int(offsets[ep] + t)] | |
| tab = pq.read_table(ROOT / f"data/chunk-{ep // 1000:03d}/episode_{ep:06d}.parquet", | |
| columns=["observation.state_canonical", "action.command", "action.eef_target", "observation.base_pose", "actions"]) | |
| S, Cm, G, B, A = (np.asarray(tab.column(c).to_pylist(), np.float64) for c in tab.column_names) | |
| rid = {"go2_arm": 0, "sawyer_umi": 1, "stretch3": 2}[robot] | |
| obs = {"observation/image": to_uint8_hwc(item["observation.images.head"]), | |
| "observation/wrist_image": to_uint8_hwc(item["observation.images.wrist"]), | |
| "observation/state": S[t].astype(np.float32), "robot_id": rid, "prompt": item["task"]} | |
| assert obs["observation/image"].shape == (480, 640, 3), obs["observation/image"].shape | |
| t0 = time.time(); out = client.infer(obs); ms = (time.time() - t0) * 1000 | |
| act = np.asarray(out["actions"]) | |
| fmt_ok &= act.shape == (H, 14) and act.dtype == np.float32 and bool(np.all(act[:, ~ca.ACTION_MASK[robot]] == 0)) | |
| idx = np.minimum(t + np.arange(H), L - 1) | |
| gt = ca.action_chunk_from_targets(robot, S[t], G[idx], Cm[idx]) | |
| r = res[robot] | |
| r["ms"].append(ms) | |
| r["pos_cm"].append(np.linalg.norm(act[:, ca.A_POS] - gt[:, ca.A_POS], axis=-1) * 100) | |
| Rp, Rg = ca.rot6d_to_rotmat(act[:, ca.A_ROT]), ca.rot6d_to_rotmat(gt[:, ca.A_ROT]) | |
| r["rot_deg"].append(ca.rot_angle_deg(np.einsum("hji,hjk->hik", Rg, Rp))) | |
| r["grip_ok"].append(((act[:, ca.A_GRIP] > 0.5) == (gt[:, ca.A_GRIP] > 0.5)).astype(float)) | |
| m = ca.ACTION_MASK[robot][:4] | |
| r["base_err"].append(np.abs(act[:, :4][:, m] - gt[:, :4][:, m]).max(1)) | |
| dec = ca.decode_action_chunk(robot, act, S[t], B[idx]) # world EEF target vs recorded expert target | |
| o = 4 if robot == "go2_arm" else 3 | |
| r["dec_pos_cm"].append(np.linalg.norm(dec[:, o:o + 3] - A[idx][:, o:o + 3], axis=-1) * 100) | |
| summary = {"format_ok": bool(fmt_ok), "horizon": H} | |
| for robot, r in res.items(): | |
| c = {k: np.concatenate([np.ravel(x) for x in v]) for k, v in r.items()} | |
| summary[robot] = {"requests": len(r["ms"]), "latency_ms_p50_max": [round(float(np.median(c["ms"])), 1), round(float(c["ms"].max()), 1)], | |
| "eef_pos_err_cm_p50_p90": [round(float(np.percentile(c["pos_cm"], q)), 2) for q in (50, 90)], | |
| "eef_rot_err_deg_p50_p90": [round(float(np.percentile(c["rot_deg"], q)), 2) for q in (50, 90)], | |
| "gripper_agreement": round(float(c["grip_ok"].mean()), 3), | |
| "base_cmd_abs_err_p50_p90": [round(float(np.percentile(c["base_err"], q)), 3) for q in (50, 90)], | |
| "decoded_world_target_vs_recorded_cm_p50": round(float(np.median(c["dec_pos_cm"])), 2), | |
| # same summary as the GR00T test: worst step of each chunk, median over requests | |
| "chunk_max_median_pos_cm_rot_deg_base": [round(float(np.median([x.max() for x in r[k]])), 3) | |
| for k in ("pos_cm", "rot_deg", "base_err")], | |
| "chunks_with_all_gripper_steps_correct": round(float(np.mean([x.min() for x in r["grip_ok"]])), 3)} | |
| print(json.dumps(summary, indent=1), flush=True) | |
| if __name__ == "__main__": | |
| main() | |