Download code/hb_pi05/verify_cpu.py from humanoid-benchmark/pi05: direct link, hf CLI and curl.
- Browser
- Download file 12.2 kB
-
https://huggingface.co/humanoid-benchmark/pi05/resolve/main/code/hb_pi05/verify_cpu.py
- Command line
-
hf download hf://humanoid-benchmark/pi05/code/hb_pi05/verify_cpu.py
-
curl -L -o verify_cpu.py https://huggingface.co/humanoid-benchmark/pi05/resolve/main/code/hb_pi05/verify_cpu.py
12.2 kB
| """CPU-only checks of the HB pi0.5 pipeline for one task (no GPU needed). Tasks: b6 basket a3 a7 (g1), a18 (h2). | |
| python verify_cpu.py --task a18 # uses the prepared view $HB_PI05_DATA/a18 (hb_prepare.py a18) | |
| python verify_cpu.py --task a18 --mini # first builds a 2-episode view in a temp dir (no full prep needed) | |
| python verify_cpu.py --task b6 --forward # + full-size PI0Pytorch fp32 forward on CPU with $HB_PI05_INIT (~35 GB RAM) | |
| Checks: raw sample vs parquet, action chunk/clamp, visual augmentation (images changed, letterbox black, labels | |
| untouched), proprio augmentation (delay <= 2 control periods within the episode, per-trajectory bias, per-sample noise, | |
| only the n_body joints touched, delay rate ~15%), norm stats dims, OpenPI transform chain (image slots/masks, state | |
| tokens not truncated for this layout's max_token_len, actions padded to 76 with zeros for h2), Unnormalize + HBOutputs | |
| back to the raw action dim, torch loader batch -> Observation, OpenPI image aug disabled, PI0Pytorch structure on the | |
| meta device, init checkpoint header shapes. | |
| """ | |
| import argparse | |
| import json | |
| import math | |
| import os | |
| import sys | |
| import tempfile | |
| from pathlib import Path | |
| import numpy as np | |
| sys.path.insert(0, str(Path(__file__).resolve().parent)) | |
| FAILS = [] | |
| def check(cond, msg): | |
| print(("PASS " if cond else "FAIL ") + msg, flush=True) | |
| if not cond: | |
| FAILS.append(msg) | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--task", default="b6") | |
| ap.add_argument("--mini", action="store_true") | |
| ap.add_argument("--forward", action="store_true") | |
| ap.add_argument("--samples", type=int, default=200) | |
| a = ap.parse_args() | |
| if a.mini: | |
| os.environ["HB_PI05_DATA"] = tempfile.mkdtemp(prefix="hb_pi05_mini_") | |
| import torch | |
| import hb_g1_data as D | |
| import hb_prepare | |
| if a.mini: | |
| hb_prepare.prepare(a.task, max_episodes=2, check_expected=False, workers=4) | |
| import hb_g1_config as C # noqa: E402 | |
| import openpi.models.model as _model | |
| import openpi.training.config as _config | |
| import openpi.training.data_loader as _data | |
| import openpi.transforms as _transforms | |
| tok = Path(os.environ.get("OPENPI_DATA_HOME", "~/.cache/openpi")).expanduser() / "big_vision/paligemma_tokenizer.model" | |
| check(tok.exists(), f"tokenizer present at {tok}") | |
| rng = np.random.default_rng(0) | |
| L = D.layout_of(a.task) | |
| cam0, cam1 = (f"observation/{c}" for c in L.cameras) | |
| print(f"task {a.task}: layout {L.name} state {L.state_dim} actions {L.action_dim} cams {L.cameras} " | |
| f"n_body {L.n_body} max_token_len {L.max_token_len}") | |
| # 1. raw sample vs parquet | |
| ds = D.HBCachedDataset(a.task, augment=False) | |
| n = len(ds) | |
| s = ds[5] | |
| check(s[cam0].shape == (224, 224, 3) and s[cam0].dtype == np.uint8 and s[cam1].shape == (224, 224, 3), | |
| f"{L.cameras} uint8 224x224x3") | |
| check(s["observation/state"].shape == (L.state_dim,) and s["actions"].shape == (16, L.action_dim), | |
| f"state {s['observation/state'].shape} actions {s['actions'].shape}") | |
| check(isinstance(s["prompt"], str) and len(s["prompt"]) > 0, f"prompt {s['prompt']!r}") | |
| src = D.TASKS[a.task].root | |
| info = json.loads((src / "meta/info.json").read_text()) | |
| ep0 = hb_prepare.read_episode(src, info, 0, L.name) | |
| check(np.allclose(s["observation/state"], ep0["state"][5], atol=1e-6), f"state[5] == parquet ({L.state_desc})") | |
| check(np.allclose(s["actions"][0], ep0["action"][5], atol=1e-6) and np.allclose(s["actions"][15], ep0["action"][20], atol=1e-6), | |
| f"actions rows t..t+15 == parquet ({L.action_desc})") | |
| ln = len(ep0["state"]) | |
| tail = ds[ln - 3] | |
| check(np.allclose(tail["actions"][2:], ep0["action"][ln - 1], atol=1e-6), "chunk clamped to the episode's last row") | |
| q = ds.state[:, :L.n_body] | |
| check(np.abs(q).max() < 2 * math.pi, f"perturbed joints look like radians (max |q| {np.abs(q).max():.2f})") | |
| print(f" fps {ds.fps} control_hz {ds.control_hz} -> delay rows for 1/2 periods: " | |
| f"{max(1, round(ds.fps / ds.control_hz))}/{max(1, round(2 * ds.fps / ds.control_hz))}") | |
| # 2. visual augmentation (+ labels untouched) | |
| dsa = D.HBCachedDataset(a.task, augment=True) | |
| top, bottom, _, _ = ds.box | |
| changed, pad_black, act_ok = 0, True, True | |
| for i in rng.integers(0, n, 16): | |
| r, g = ds[int(i)], dsa[int(i)] | |
| changed += int(not np.array_equal(r[cam0], g[cam0])) | |
| for k in (cam0, cam1): | |
| pad_black &= bool(g[k][:top].max(initial=0) == 0 and g[k][bottom:].max(initial=0) == 0) | |
| act_ok &= bool(np.array_equal(g["actions"], r["actions"])) | |
| check(changed >= 12, f"augmentation changes images ({changed}/16)") | |
| check(pad_black, f"letterbox rows stay black (content rows {top}:{bottom})") | |
| check(act_ok, "action labels untouched by augmentation") | |
| # 3. proprio augmentation (CLAUDE.md sec. 3): delay, per-trajectory bias, per-sample noise | |
| dsa._lazy_init() # noqa: SLF001 | |
| nb, max_d = L.n_body, max(1, round(2 * ds.fps / ds.control_hz)) | |
| bound = math.radians(D.BIAS_DEG + 3 * D.NOISE_DEG) + 1e-5 | |
| delays, ok = [], True | |
| for i in rng.integers(0, n, 400): | |
| i = int(i) | |
| st, d = dsa.proprio(i, epoch=0) | |
| j = i - d | |
| ok &= bool(0 <= d <= max_d and j >= dsa.ep_start[i] and np.array_equal(st[nb:], ds.state[j][nb:]) | |
| and np.abs(st[:nb] - ds.state[j][:nb]).max() <= bound) | |
| delays.append(d) | |
| rate = np.mean(np.asarray(delays) > 0) | |
| check(ok, f"delay <= {max_d} rows within the episode; only state[:{nb}] perturbed within 2 deg + 3 sigma") | |
| check(0.08 <= rate <= 0.23, f"delayed fraction {rate:.3f} ~ 0.15 (clamped delays at episode start count as 0)") | |
| ep = int(ds.episode[0]) | |
| b1, b2 = D.trajectory_bias(42, 0, ep, nb), D.trajectory_bias(42, 0, ep, nb) | |
| check(np.array_equal(b1, b2) and np.abs(b1).max() <= math.radians(D.BIAS_DEG), "bias deterministic per (seed, pass, episode), |b| <= 2 deg") | |
| check(not np.array_equal(b1, D.trajectory_bias(42, 1, ep, nb)) and not np.array_equal(b1, D.trajectory_bias(42, 0, ep + 1, nb)), | |
| "bias redrawn per pass and per episode") | |
| # same episode, same pass, no delay: difference between two samples' offsets is noise only (<= 2 * 3 sigma) | |
| same = [k for k in range(n) if ds.episode[k] == ep][:50] | |
| offs = [] | |
| for k in same: | |
| st, d = dsa.proprio(k, epoch=0) | |
| if d == 0: | |
| offs.append(st[:nb] - ds.state[k][:nb]) | |
| spread = np.ptp(np.stack(offs), axis=0).max() if len(offs) > 1 else 0.0 | |
| check(spread <= 2 * math.radians(3 * D.NOISE_DEG) + 1e-5, f"bias fixed within the episode (offset spread {math.degrees(spread):.2f} deg)") | |
| check(dsa[n + 5]["actions"].shape == (16, L.action_dim), "index + pass*N decodes to row 5 of pass 1") | |
| # 4. config + norm stats | |
| cfg = C.make_train_config(a.task, batch_size=2, num_workers=0, num_train_steps=10) | |
| check(_config.get_config(D.config_name(a.task)).name == cfg.name, f"config {cfg.name} registered") | |
| m = cfg.model | |
| check(m.pi05 and m.action_dim == 76 and m.action_horizon == 16 and m.discrete_state_input | |
| and m.max_token_len == L.max_token_len, f"model {m}") | |
| dc = cfg.data.create(cfg.assets_dirs, cfg.model) | |
| check(dc.use_quantile_norm, "pi05 uses quantile norm") | |
| ns = dc.norm_stats or {} | |
| check(set(ns) == {"state", "actions"} and np.asarray(ns["state"].q01).shape == (L.state_dim,) | |
| and np.asarray(ns["actions"].q99).shape == (L.action_dim,), | |
| f"norm stats state[{L.state_dim}] actions[{L.action_dim}] (raw dims, no pad dim) with q01/q99") | |
| # 5. OpenPI transform chain | |
| tds = _data.transform_dataset(dsa, dc) | |
| t = tds[7] | |
| check(set(t["image"]) == set(_model.IMAGE_KEYS), f"image slots {sorted(t['image'])}") | |
| check(t["image"]["base_0_rgb"].shape == (224, 224, 3) and t["image"]["base_0_rgb"].dtype == np.uint8, "base_0_rgb uint8 224") | |
| check(bool(t["image_mask"]["base_0_rgb"]) and bool(t["image_mask"]["left_wrist_0_rgb"]) | |
| and not bool(t["image_mask"]["right_wrist_0_rgb"]), "masks base/left True, right False") | |
| sw = max(L.state_dim, 76) | |
| check(t["state"].shape == (sw,) and np.all(t["state"][L.state_dim:] == 0), f"state after pad ({sw},)") | |
| check(t["actions"].shape == (16, 76) and np.all(t["actions"][:, L.action_dim:] == 0), | |
| f"actions (16,76); dims {L.action_dim}: are zero padding") | |
| lens = [int(tds[int(i)]["tokenized_prompt_mask"].sum()) for i in rng.integers(0, n, a.samples)] | |
| check(max(lens) < m.max_token_len, f"prompt+state tokens max {max(lens)} < max_token_len {m.max_token_len} (mean {np.mean(lens):.0f})") | |
| from openpi.models.tokenizer import PaligemmaTokenizer | |
| sp = PaligemmaTokenizer(m.max_token_len)._tokenizer # noqa: SLF001 | |
| print(" decoded prompt:", sp.decode([int(x) for x, k in zip(t["tokenized_prompt"], t["tokenized_prompt_mask"]) if k])) | |
| out = _transforms.compose([_transforms.Unnormalize(dc.norm_stats, use_quantiles=True), *dc.data_transforms.outputs])( | |
| {"actions": np.asarray(t["actions"], np.float64), "state": np.asarray(t["state"])}) | |
| check(out["actions"].shape == (16, L.action_dim), f"Unnormalize + HBOutputs -> (16,{L.action_dim})") | |
| raw_rows = ds.action[np.minimum(np.arange(7, 23), ds.ep_end[7] - 1)] | |
| check(np.allclose(out["actions"], raw_rows, atol=1e-3 * (1 + np.abs(raw_rows).max())), "normalize -> unnormalize round trip") | |
| # 6. loader + OpenPI aug disabled | |
| D.install_hooks(augment=True) | |
| loader = _data.create_data_loader(cfg, framework="pytorch", shuffle=True, num_batches=1) | |
| obs, act = next(iter(loader)) | |
| check(tuple(obs.images["base_0_rgb"].shape) == (2, 3, 224, 224) and obs.images["base_0_rgb"].dtype == torch.float32, | |
| f"batch image {tuple(obs.images['base_0_rgb'].shape)} float [-1,1]") | |
| check(tuple(obs.state.shape) == (2, sw) and tuple(act.shape) == (2, 16, 76), f"batch state (2,{sw}) actions (2,16,76)") | |
| import openpi.models_pytorch.preprocessing_pytorch as pp | |
| torch.manual_seed(0) | |
| o1 = pp.preprocess_observation_pytorch(obs, train=True) | |
| o2 = pp.preprocess_observation_pytorch(obs, train=False) | |
| check(all(torch.equal(o1.images[k], o2.images[k]) for k in o1.images), "OpenPI train-time image aug disabled") | |
| # 7. model structure (meta device) + init checkpoint header | |
| import openpi.models_pytorch.pi0_pytorch as p0 | |
| mcfg = C.model_config(L.name, dtype="float32", pytorch_compile_mode=None) | |
| with torch.device("meta"): | |
| net = p0.PI0Pytorch(mcfg) | |
| check(tuple(net.action_in_proj.weight.shape) == (1024, 76) and tuple(net.action_out_proj.weight.shape) == (76, 1024), | |
| "PI0Pytorch action_in/out_proj sized for 76") | |
| print(f" params: {sum(p.numel() for p in net.parameters()) / 1e9:.3f} B") | |
| init = Path(os.environ.get("HB_PI05_INIT", "")) / "model.safetensors" | |
| if init.exists(): | |
| from safetensors import safe_open | |
| sd = net.state_dict() | |
| groups = {} | |
| for name, p in net.named_parameters(remove_duplicate=False): | |
| groups.setdefault(id(p), []).append(name) | |
| alias = {k: g for g in groups.values() for k in g} | |
| with safe_open(str(init), "pt") as f: | |
| keys = set(f.keys()) | |
| bad = [k for k in keys if k not in sd or tuple(f.get_slice(k).get_shape()) != tuple(sd[k].shape)] | |
| missing = [k for k in sd if k not in keys and not any(x in keys for x in alias.get(k, []))] | |
| check(not bad and not missing, f"init checkpoint matches model ({len(keys)} tensors; bad {bad[:5]} missing {missing[:5]})") | |
| else: | |
| print(f" (skip) {init} not found") | |
| if a.forward: | |
| import safetensors.torch | |
| net = p0.PI0Pytorch(mcfg) | |
| safetensors.torch.load_model(net, str(init)) | |
| net.eval() | |
| with torch.no_grad(): | |
| loss = net(obs, act.to(torch.float32)) | |
| check(tuple(loss.shape) == (2, 16, 76) and torch.isfinite(loss).all().item(), f"fp32 CPU forward loss {loss.mean().item():.4f}") | |
| print("VERIFY_" + ("OK" if not FAILS else f"FAILED ({len(FAILS)})")) | |
| sys.exit(1 if FAILS else 0) | |
| if __name__ == "__main__": | |
| main() | |