File size: 9,767 Bytes
813ba5d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 | """Per-task native Psi0 argument lists, step math, and the probe decision.
hb_args.py plan <task> <per_gpu_batch> -> JSON step plan
hb_args.py args <task> (--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 <task> <probe_dir> <decision_json> <cands...> -> 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", "a3", "a7", "a18", "trolley", "a17", "b7")
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())
def plan(frames, batch):
gb = batch * WORLD
steps = math.ceil(EPOCHS * frames / gb)
save = math.ceil(SAVE_EPOCH * frames / gb) # saves at `save` and at `steps` only (2*save >= steps)
return {"frames": frames, "per_gpu_batch": batch, "global_batch": gb, "epochs": EPOCHS, "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 = str(DATA / task / "meta" / "stats_psi0.json")
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",
"--data.transform.repack.hb-delay-prob=0.15", "--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()
|