"""Per-task native Psi0 argument lists, step math, and the probe decision. hb_args.py plan -> JSON step plan hb_args.py args (--decision DEC | --batch B --steps S --save N --warmup W) --out DIR --timestamp TS [--workers N] [--no-resume] -> one arg per line hb_args.py decide -> exit 0 decided / 3 not yet Native recipe = scripts/train/psi0/finetune-real-sonic-psi0-2.8B-sonic1.1-robust.sh (same model flags; verified against the init dir's action_header.safetensors: 12 blocks, qk rms_norm, state_null, view_feature_dim 2048, pooled 768). Changed: action/state dims and keys come from the view receipt (per-robot layout written by prepare_data.py: G1 A76/S44 body 29, H2 a18 A75/S78 body 31), H30 kept, native augmentations off (HB v2 instead), steps/warmup/checkpoint cadence from the 20-epoch rule, no wandb, no validation. """ import argparse import json import math import os import sys from pathlib import Path H = Path(__file__).resolve().parent G = Path(os.environ.get("G", H.parent)) TASKS = ("b6", "basket", "basketv2", "a3", "a7", "a18", "trolley", "a17", "b7", "a6", "a1", "a10v2", "c6t", "c6", "a14", "a7v2", "b8", "a18c2", "a17c2", "b1", "a14v2", "a10v3", "a3v3", "a7v3", "b6v6", "b5", "a3v4", "a7v4") WORLD = int(os.environ.get("HB_WORLD", "32")) # 4 nodes x 8 GPUs EPOCHS, SAVE_EPOCH, WARMUP_FRAC = 20, 10, 0.025 # warmup: native 1000/40000 = 2.5 % HORIZON = 30 POST = Path(os.environ.get("HB_POST_DIR", G / "models/psi0/psi0/postpre.sonic1.1.unifolm.2609181726.40k")) CLIP = Path(os.environ.get("HB_CLIP_DIR", G / "models/clip-vit-large-patch14")) DATA = Path(os.environ.get("HB_DATA_ROOT", G / "psi0-data")) def receipt(task): p = DATA / task / "hb-view-receipt.json" if not p.is_file(): sys.exit(f"missing {p}: run prepare_data.py {task} first") return json.loads(p.read_text()) # 2026-11-12 22:1x user: no more epoch-based training; every Psi-Zero / ACT run trains a fixed number of optimizer steps # (4000), checkpoints every 2000 steps counted back from the last step, only the last two kept (the last one with its # resume state), HF folders step-002000 / step-004000. FIXED_STEPS = int(os.environ.get("HB_FIXED_STEPS", "4000")) CKPT_EVERY = 2000 def plan(frames, batch): gb = batch * WORLD steps = FIXED_STEPS save = CKPT_EVERY if steps % CKPT_EVERY == 0 else steps - CKPT_EVERY # saves at steps - 2000 and steps return {"frames": frames, "per_gpu_batch": batch, "global_batch": gb, "fixed_steps": True, "epochs": None, "epochs_equivalent": round(steps * gb / frames, 2), "steps": steps, "save_steps": save, "warmup_steps": max(1, round(WARMUP_FRAC * steps))} def build_args(task, batch, steps, save, warmup, out, ts, workers, resume=True): r = receipt(task) cams = r["image_keys"] SK, AK, SD, AD, NB = r["state_key"], r["action_key"], int(r["state_dim"]), int(r["action_dim"]), int(r["body_dims"]) stats = os.environ.get("HB_STATS_PATH") or str(DATA / task / "meta" / "stats_psi0.json") # continuation: source run stats drop = os.environ.get("HB_STATE_DROP_PROB", "0.0") a = [ "--seed=292285", f"--exp=hb-{task}", f"--timestamp={ts}", *(["--train.resume_from_checkpoint=latest"] if resume else []), "--train.name=finetune", f"--train.output_dir={out}", "--train.data_parallel=ddp", "--train.mixed_precision=bf16", f"--train.train_batch_size={batch}", f"--train.val_batch_size={batch}", "--train.max_checkpoints_to_keep=2", "--train.preserve_checkpoint_every=None", "--train.gradient_accumulation_steps=1", "--train.learning_rate=1e-4", f"--train.max_training_steps={steps}", "--train.warmup_ratio=None", f"--train.warmup_steps={warmup}", f"--train.checkpointing_steps={save}", "--train.validation_steps=0", "--train.max_grad_norm=1.0", "--train.lr_scheduler_type=cosine", "--train.lr_scheduler_kwargs.weight_decay=1e-6", "--train.lr_scheduler_kwargs.betas", "0.95", "0.999", f"--data.root_dir={DATA}", "--data.train_repo_ids", task, "--data.val_repo_ids", task, f"--data.num_workers={workers}", "--data.prefetch_factor=4", "--data.transform.repack.image-keys", *cams, "--data.transform.repack.state-keys", SK, "--data.transform.repack.action-keys", AK, f"--data.transform.repack.dataset-name=hb_{task}", f"--data.transform.repack.pad-action-dim={AD}", f"--data.transform.repack.pad-state-dim={SD}", "--data.transform.repack.instruction-key=task", f"--data.transform.repack.action-chunk-size={HORIZON}", "--data.transform.repack.state-temporal-jitter=0", # 2026-11-12 user: align with GR00T A20 -> no proprio delay (Psi0 has no action-history input, so no history drop) # 2026-11-14 H2 training guides: the H2 Psi0 cells use the a17 epoch-020 value 0.15 (HB_DELAY_PROB) f"--data.transform.repack.hb-delay-prob={os.environ.get('HB_DELAY_PROB', '0.0')}", "--data.transform.repack.hb-delay-max-frames=2", f"--data.transform.repack.hb-body-dims={NB}", "--data.transform.repack.hb-bias-seed=292285", f"--data.transform.field.stat-path={stats}", "--data.transform.field.state-noise-std=0.0", "--data.transform.field.stat-action-keys", AK, "--data.transform.field.stat-state-keys", SK, "--data.transform.field.action_norm_type=bounds", "--data.transform.field.no-use-norm-mask", "--data.transform.field.normalize-state", f"--data.transform.field.pad-action-dim={AD}", f"--data.transform.field.pad-state-dim={SD}", "--data.transform.model.no-img-aug", "--data.transform.model.no-view-aug", "--data.transform.model.resize.size", "270", "480", "--data.transform.model.center_crop.size", "270", "480", "--data.transform.model.hb-aug", f"--model.model_name_or_path={POST}", f"--model.pretrained-action-header-path={POST}", "--model.noise-scheduler=flow", "--model.train-diffusion-steps=1000", "--model.n_conditions=0", f"--model.action-chunk-size={HORIZON}", f"--model.action-dim={AD}", f"--model.action-exec-horizon={HORIZON}", "--model.observation-horizon=1", f"--model.odim={SD}", "--model.dropout=0.0", "--model.state-feature-dropout=0.0", "--model.view_feature_dim=2048", "--model.tune-vlm", "--model.lang-backbone-lr=1e-6", "--model.vision-tower-lr=1e-5", "--model.mm-projector-lr=1e-4", "--model.gradient-checkpointing", "--model.no-use_film", "--model.qk-norm=rms_norm", "--model.combined-temb", "--model.num-blocks=12", "--model.vlm-layer-indices", *"3 5 8 10 12 14 17 19 21 23 26 28".split(), f"--model.state-drop-prob={drop}", "--model.state-as-action-token", "--model.state-null-token", "--model.pooled-text-encoder=clip", f"--model.pooled-text-encoder-path={CLIP}", "--model.pooled-projection-dim=768", "--model.pooled-cache-path=clip_pooled_cache.pt", "--model.no-rtc", "--model.max-delay=8", ] return a def decide(task, probe_dir, dec_path, cands, frac=None): frac = float(os.environ.get("HB_PROBE_MEM_FRAC", "0.92")) if frac is None else frac rows = [] for b in sorted({int(c) for c in cands}, reverse=True): d = Path(probe_dir) / f"bs{b}" rc_f = Path(probe_dir) / f"bs{b}.rc" if not rc_f.is_file(): continue ranks = [json.loads(p.read_text()) for p in sorted(d.glob("rank*.json"))] ok = rc_f.read_text().strip() == "0" and len(ranks) >= 2 and all(r.get("ok") for r in ranks) pk = max((r.get("peak_frac", 1.0) for r in ranks), default=None) sps = max((r.get("sec_per_step", 0.0) for r in ranks), default=None) rows.append({"per_gpu_batch": b, "ok": ok, "peak_frac": pk, "sec_per_step": sps, "fits": bool(ok and pk is not None and pk <= frac), "error": next((r.get("error") for r in ranks if r.get("error")), None)}) good = [r for r in rows if r["fits"]] print(json.dumps(rows, indent=1)) if not good: return 3 best = max(good, key=lambda r: r["per_gpu_batch"]) r = receipt(task) dec = plan(r["frames"], best["per_gpu_batch"]) # probed per task, i.e. per robot layout / camera set dec.update(task=task, robot=r.get("robot"), state_dim=r["state_dim"], action_dim=r["action_dim"], image_keys=r["image_keys"], mem_frac_limit=frac, probe=rows, est_hours=(dec["steps"] * best["sec_per_step"] / 3600.0) if best["sec_per_step"] else None) tmp = Path(str(dec_path) + ".tmp") tmp.write_text(json.dumps(dec, indent=2) + "\n") os.replace(tmp, dec_path) print("DECISION", json.dumps({k: dec[k] for k in ("per_gpu_batch", "global_batch", "steps", "save_steps")})) return 0 def main(): ap = argparse.ArgumentParser() sub = ap.add_subparsers(dest="cmd", required=True) p = sub.add_parser("plan"); p.add_argument("task"); p.add_argument("batch", type=int) p = sub.add_parser("args"); p.add_argument("task") p.add_argument("--decision"); p.add_argument("--batch", type=int); p.add_argument("--steps", type=int) p.add_argument("--save", type=int); p.add_argument("--warmup", type=int) p.add_argument("--out", required=True); p.add_argument("--timestamp", required=True) p.add_argument("--workers", type=int, default=int(os.environ.get("HB_NUM_WORKERS", "8"))) p.add_argument("--no-resume", action="store_true") p = sub.add_parser("decide"); p.add_argument("task"); p.add_argument("probe_dir"); p.add_argument("decision") p.add_argument("cands", nargs="+") a = ap.parse_args() if a.cmd != "decide" and a.task not in TASKS: sys.exit(f"unknown task {a.task}; known {TASKS}") if a.cmd == "plan": print(json.dumps(plan(receipt(a.task)["frames"], a.batch), indent=2)) elif a.cmd == "args": if a.decision: d = json.loads(Path(a.decision).read_text()) assert d["task"] == a.task and d["frames"] == receipt(a.task)["frames"], "stale decision file" b, s, sv, w = d["per_gpu_batch"], d["steps"], d["save_steps"], d["warmup_steps"] else: b, s, sv, w = a.batch, a.steps, a.save, a.warmup assert None not in (b, s, sv, w), "--batch/--steps/--save/--warmup or --decision" print("\n".join(build_args(a.task, b, s, sv, w, a.out, a.timestamp, a.workers, not a.no_resume))) else: sys.exit(decide(a.task, a.probe_dir, a.decision, a.cands)) if __name__ == "__main__": main()