Download code/hb_pi05/hb_init_weights.py from humanoid-benchmark/pi05: direct link, hf CLI and curl.
- Browser
- Download file 8.82 kB
-
https://huggingface.co/humanoid-benchmark/pi05/resolve/main/code/hb_pi05/hb_init_weights.py
- Command line
-
hf download hf://humanoid-benchmark/pi05/code/hb_pi05/hb_init_weights.py
-
curl -L -o hb_init_weights.py https://huggingface.co/humanoid-benchmark/pi05/resolve/main/code/hb_pi05/hb_init_weights.py
8.82 kB
| """pi05_base (JAX) -> PyTorch -> 76-D G1 init checkpoint. | |
| convert : runs OpenPI's own converter examples/convert_jax_model_to_pytorch.py:main (pi05 path, float32, stock | |
| 32-D config `pi05_droid_finetune` = Pi0Config(pi05=True, action_dim=32, action_horizon=16)). That converter | |
| calls PI0Pytorch.load_state_dict(..., strict=False) and ignores the result; we record it and FAIL if anything | |
| except the unused/tied `lm_head` weights was not loaded. | |
| init76 : builds PI0Pytorch for action_dim=76 in float32 (one checkpoint shared by all tasks: G1 uses 76 dims, H2 a18 | |
| uses 75 + 1 zero pad dim; max_token_len does not affect parameters), copies every converted tensor whose name and | |
| shape match, keeps the fresh nn.Linear init for whole layers that mismatch (only action_in_proj and | |
| action_out_proj are allowed to), logs every fresh/unloaded key, FAILS on any other mismatch, and writes | |
| model.safetensors that train_pytorch.py loads strictly via TrainConfig.pytorch_weight_path. | |
| --lerobot: GCS (gs://openpi-assets) is ~100 KB/s from the DLC nodes, so the base can instead be HF | |
| lerobot/pi05_base @ 22c30e5 (public, fp32 PyTorch port of the same weights); its names are remapped to | |
| PI0Pytorch and the same strict checks apply. | |
| Usage: python hb_init_weights.py convert --jax-dir $HB_PI05_BASE_JAX --out $HB_PI05_BASE_PT | |
| python hb_init_weights.py init76 --base $HB_PI05_BASE_PT --out $HB_PI05_INIT | |
| python hb_init_weights.py init76 --base $HB_G/models/lerobot-pi05_base --lerobot --out $HB_PI05_INIT | |
| """ | |
| import argparse | |
| import importlib.util | |
| import json | |
| import os | |
| import re | |
| import sys | |
| from pathlib import Path | |
| import safetensors.torch | |
| import torch | |
| ALLOWED_FRESH_LAYERS = {"action_in_proj", "action_out_proj"} | |
| ALLOWED_UNLOADED = re.compile(os.environ.get("HB_ALLOW_UNLOADED", r".*lm_head\.weight$")) | |
| def cmd_convert(a): | |
| import openpi.models_pytorch.pi0_pytorch as p0 | |
| jax_dir, out = Path(a.jax_dir).resolve(), Path(a.out).resolve() | |
| if "pi05" not in str(jax_dir): | |
| sys.exit(f"converter selects the pi05 (adaRMS) layout only if 'pi05' is in the checkpoint path: {jax_dir}") | |
| if not (jax_dir / "params").is_dir(): | |
| sys.exit(f"{jax_dir}/params missing (download gs://openpi-assets/checkpoints/pi05_base/ there)") | |
| results = [] | |
| orig = torch.nn.Module.load_state_dict | |
| def recording_load(self, state_dict, strict=True, assign=False): | |
| res = orig(self, state_dict, strict=strict, assign=assign) | |
| results.append(res) | |
| return res | |
| p0.PI0Pytorch.load_state_dict = recording_load | |
| path = Path(os.environ["HB_OPENPI"]) / "examples/convert_jax_model_to_pytorch.py" | |
| spec = importlib.util.spec_from_file_location("openpi_convert_jax_model_to_pytorch", path) | |
| mod = importlib.util.module_from_spec(spec) | |
| spec.loader.exec_module(mod) | |
| mod.main(checkpoint_dir=str(jax_dir), config_name="pi05_droid_finetune", output_path=str(out), precision="float32") | |
| p0.PI0Pytorch.load_state_dict = orig | |
| assert len(results) == 1, results | |
| missing, unexpected = list(results[0].missing_keys), list(results[0].unexpected_keys) | |
| bad = [k for k in missing if not ALLOWED_UNLOADED.fullmatch(k)] | |
| report = {"jax_dir": str(jax_dir), "missing_keys": missing, "unexpected_keys": unexpected, "bad": bad} | |
| (out / "hb_convert_report.json").write_text(json.dumps(report, indent=2)) | |
| print("converter load_state_dict: missing", missing, "unexpected", unexpected) | |
| if bad or unexpected: | |
| sys.exit(f"CONVERT_FAIL: unloaded {bad} unexpected {unexpected}") | |
| print("CONVERT_OK", out) | |
| def remap_lerobot(src, target_keys): | |
| """lerobot/pi05_base (LeRobot PI05Policy, PyTorch port of OpenPI's PI0Pytorch) -> OpenPI PI0Pytorch names. | |
| Exact name, then without the policy's leading 'model.', then a unique suffix match. Normalizer buffers are dropped; | |
| anything else unmatched fails, so every tensor is either mapped 1:1 or reported.""" | |
| tset = set(target_keys) | |
| out, dropped, unmatched, renamed = {}, [], [], {} | |
| for k, v in src.items(): | |
| cands = [k] + ([k[len("model."):]] if k.startswith("model.") else []) | |
| hit = next((c for c in cands if c in tset), None) | |
| if hit is None: | |
| b = cands[-1] | |
| suf = [t for t in tset if t.endswith("." + b) or b.endswith("." + t)] | |
| hit = suf[0] if len(suf) == 1 else None | |
| if hit is None: | |
| (dropped if re.search(r"normaliz", k) else unmatched).append(k) | |
| continue | |
| if hit in out: | |
| unmatched.append(f"duplicate target {hit} <- {k}") | |
| continue | |
| out[hit] = v | |
| if hit != k: | |
| renamed[k] = hit | |
| return out, dropped, unmatched, renamed | |
| def cmd_init76(a): | |
| import openpi.models_pytorch.pi0_pytorch as p0 | |
| import hb_g1_config as C | |
| base, out = Path(a.base), Path(a.out) | |
| src = safetensors.torch.load_file(str(base / "model.safetensors")) | |
| cfg = C.model_config(dtype="float32", pytorch_compile_mode=None) | |
| torch.manual_seed(a.seed) | |
| model = p0.PI0Pytorch(cfg) | |
| target = model.state_dict() | |
| lerobot_info = None | |
| if a.lerobot: | |
| src = {k: v.float() for k, v in src.items()} | |
| src, dropped, unmatched, renamed = remap_lerobot(src, target.keys()) | |
| print(f"lerobot remap: {len(src)} mapped, {len(renamed)} renamed, dropped {dropped}") | |
| if unmatched: | |
| sys.exit("INIT76_FAIL lerobot keys without an OpenPI match:\n" + "\n".join(unmatched[:200])) | |
| lerobot_info = {"dropped": dropped, "renamed_count": len(renamed), | |
| "renamed_examples": dict(list(renamed.items())[:20])} | |
| # tied parameters share one tensor; save_model keeps only one of their names | |
| alias = {} | |
| for name, p in model.named_parameters(remove_duplicate=False): | |
| alias.setdefault(id(p), []).append(name) | |
| tied = {n: names for names in alias.values() if len(names) > 1 for n in names} | |
| fresh_layers, problems, unloaded = set(), [], [] | |
| for k, v in target.items(): | |
| layer = k.rsplit(".", 1)[0] | |
| if k in src: | |
| if tuple(src[k].shape) != tuple(v.shape): | |
| if layer in ALLOWED_FRESH_LAYERS: | |
| fresh_layers.add(layer) | |
| else: | |
| problems.append(f"shape {k}: base {tuple(src[k].shape)} vs new {tuple(v.shape)}") | |
| elif any(t in src for t in tied.get(k, [])): | |
| continue # loaded through its tied alias | |
| elif ALLOWED_UNLOADED.fullmatch(k): | |
| unloaded.append(k) | |
| else: | |
| problems.append(f"missing in base: {k}") | |
| problems += [f"not in new model: {k}" for k in src if k not in target] | |
| if problems: | |
| sys.exit("INIT76_FAIL\n" + "\n".join(problems)) | |
| load = {k: t for k, t in src.items() if k.rsplit(".", 1)[0] not in fresh_layers} | |
| res = model.load_state_dict(load, strict=False) | |
| fresh_keys = sorted(k for k in target if k.rsplit(".", 1)[0] in fresh_layers) | |
| allowed_missing = set(fresh_keys) | set(unloaded) | {k for k in tied if k not in src} | |
| assert not res.unexpected_keys and set(res.missing_keys) <= allowed_missing, res | |
| for k in fresh_keys: | |
| print(f"FRESH {k}: new {tuple(target[k].shape)} (base {tuple(src[k].shape) if k in src else None})") | |
| for k in unloaded: | |
| print(f"UNLOADED (kept init, unused) {k}") | |
| out.mkdir(parents=True, exist_ok=True) | |
| safetensors.torch.save_model(model, str(out / "model.safetensors")) | |
| report = {"base": str(base), "base_format": "lerobot" if a.lerobot else "openpi", "lerobot_remap": lerobot_info, | |
| "seed": a.seed, "model_config": {"pi05": cfg.pi05, "action_dim": cfg.action_dim, | |
| "action_horizon": cfg.action_horizon, "max_token_len": cfg.max_token_len}, "fresh_keys": fresh_keys, | |
| "unloaded_keys": unloaded, "loaded_tensors": len(load), "total_tensors": len(target)} | |
| (out / "hb_init_report.json").write_text(json.dumps(report, indent=2)) | |
| print(f"INIT76_OK {out}: loaded {len(load)} tensors, fresh {fresh_keys}") | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| sub = ap.add_subparsers(dest="cmd", required=True) | |
| c = sub.add_parser("convert") | |
| c.add_argument("--jax-dir", required=True) | |
| c.add_argument("--out", required=True) | |
| i = sub.add_parser("init76") | |
| i.add_argument("--base", required=True) | |
| i.add_argument("--out", required=True) | |
| i.add_argument("--seed", type=int, default=0) | |
| i.add_argument("--lerobot", action="store_true", | |
| help="--base is lerobot/pi05_base (HF, PyTorch); remap its names to OpenPI PI0Pytorch") | |
| a = ap.parse_args() | |
| {"convert": cmd_convert, "init76": cmd_init76}[a.cmd](a) | |
| if __name__ == "__main__": | |
| main() | |