pi05 / code /hb_pi05 /hb_init_weights.py
BIue-Jay's picture
Add files using upload-large-folder tool
b04edfb verified
Raw History Blame Contribute Delete
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()