"""Generate the experiment plan (job scripts + plan.json) for the single 8xA100 node. python -m tdprm.queue.plan [--rounds 200] [--extra-seeds 0] [--llama-arms all] python -m tdprm.queue.gpuq simulate --plan $TDPRM_HOME/queue/plan.json nohup python -m tdprm.queue.gpuq run --plan $TDPRM_HOME/queue/plan.json > $TDPRM_HOME/queue/queue.log 2>&1 & Priority (lower first): data/sampling/state fitting -> OpenJev construction (critical path of the six 1.b arms) -> Qwen-math (first comparison) -> Qwen-HotpotQA -> Llama-math -> Llama-HotpotQA. Each training job also runs its in-loop evaluations and final test (tdprm.rl.train); only the base model is evaluated by a separate job. """ import argparse import json import stat from collections import defaultdict from .. import paths from ..rl.launch import ARMS, PREAMBLE, eval_script, experiment, gpus_for, local_model, train_script CELLS = [("qwen1.5b", "math"), ("qwen1.5b", "proverqa"), ("llama3b", "math"), ("llama3b", "proverqa")] ARM_ORDER = ["grpo", "s_hc", "s_gae", "s_gaed", "prm800k", "qwenprm", "versaprm", "j_hc", "j_gae", "j_gaed"] # Estimated wall-clock hours for 200 rounds (64 prompts x 8 rollouts) on one Qwen-1.5B GPU / two Llama-3B GPUs. BASE_HOURS = {("qwen1.5b", "math"): 6.0, ("qwen1.5b", "proverqa"): 6.0, ("llama3b", "math"): 7.8, ("llama3b", "proverqa"): 7.8} TEST_HOURS = {"qwen1.5b": 0.3, "llama3b": 0.4} # in-run final test on the colocated vLLM engine ARM_FACTOR = {"grpo": 1.0, "s_hc": 1.08, "s_gae": 1.08, "s_gaed": 1.08, "prm800k": 1.25, "qwenprm": 1.25, "versaprm": 1.3, "j_hc": 1.25, "j_gae": 1.25, "j_gaed": 1.25} def write_script(name, body): path = paths.QUEUE / "scripts" / f"{name}.sh" path.parent.mkdir(parents=True, exist_ok=True) tmp = path.with_suffix(".tmp") tmp.write_text(body) tmp.chmod(tmp.stat().st_mode | stat.S_IXUSR) tmp.replace(path) # a running job's bash keeps reading its old (unlinked) script return str(path) def py_job(module_args): return PREAMBLE.format(repo=paths.REPO, home=paths.HOME) + f"python -m {module_args}\n" SMOKE_ARMS = ["grpo", "s_gae", "j_gae", "prm800k", "versaprm"] def build(args): jobs = [] smoke = args.smoke cells = [("qwen1.5b", "math")] if smoke else CELLS backbones = sorted({b for b, _ in cells}, key=lambda b: ("qwen" not in b, b)) domains = [d for d in ("math", "proverqa") if any(c[1] == d for c in cells)] tiny = {"sample": " --max-prompts 256", "fit": " --max-rollouts 1000", "build": " --rounds 2 --proposals 1 --round-size 200 --per-backbone 300", "label": " --n-ref 40", "calib": " --n-ref 40 --n-warm 200"} if smoke else defaultdict(str) def add(jid, body, gpus, priority, deps=(), est=1.0, **extra): jobs.append({"id": jid, "script": write_script(jid, body), "gpus": gpus, "priority": priority, "deps": list(deps), "est_hours": round(est, 2), **extra}) add("prep_data", py_job("tdprm.data.prepare"), 0, 0, est=0.3) add("download_models", PREAMBLE.format(repo=paths.REPO, home=paths.HOME) + "bash $TDPRM_REPO/tdprm/scripts/download_models.sh\n", 0, 0, est=0.6) prep = ["prep_data", "download_models"] for ci, (b, d) in enumerate(cells): add(f"sample_{b}_{d}", py_job(f"tdprm.sampling.base_rollouts --backbone {b} --domain {d}" + tiny["sample"]), 1, 1 + ci * 0.1, prep, est={"qwen1.5b": 0.35, "llama3b": 0.6}[b]) add(f"fit_spectral_{b}_{d}", py_job(f"tdprm.states.fit spectral --backbone {b} --domain {d}" + tiny["fit"]), 1, 2 + ci * 0.1, [f"sample_{b}_{d}"], est={"qwen1.5b": 0.3, "llama3b": 0.45}[b]) for b in backbones: add(f"eval_base_{b}", eval_script(local_model(paths.BACKBONES[b]), f"{b}-base/step_0"), 1, 6, prep, est={"qwen1.5b": 0.25, "llama3b": 0.4}[b]) jev_group = [] for di, d in enumerate(domains): # OpenJev-27B (bf16 fits one A100-80GB): build + balance the domain's state set from both backbones' steps; # then label a few thousand steps per cell as the reference for JevK5 (online labeler) calibration, # after which JevK5 labels the warm-start rollouts. jid = f"openjev_states_{d}" add(jid, py_job(f"tdprm.states.openjev build --domain {d}" + tiny["build"]), 1, 3 + di, [f"sample_{b}_{d}" for b in backbones], est=1.5) jev_group.append(jid) for b in backbones: lid, cid = f"openjev_label_{b}_{d}", f"jevk5_calib_{b}_{d}" add(lid, py_job(f"tdprm.states.openjev label --backbone {b} --domain {d}" + tiny["label"]), 1, 3.1 + di, [jid], est=0.4) add(cid, py_job(f"tdprm.states.openjev calibrate --backbone {b} --domain {d}" + tiny["calib"]), 1, 3.2 + di, [lid], est=0.35) jev_group += [lid, cid] llama_arms = ARM_ORDER if args.llama_arms == "all" else args.llama_arms.split(",") seeds = [0] if smoke else [1] + list(range(2, 2 + args.extra_seeds)) # smoke runs never collide with real ones for ci, (b, d) in enumerate(cells): arms = SMOKE_ARMS if smoke else (ARM_ORDER if b == "qwen1.5b" else llama_arms) for seed in seeds: if seed > 1 and (b, d) != ("qwen1.5b", "math"): continue for ai, arm in enumerate(arms): exp = experiment(b, d, arm, seed) deps = [f"sample_{b}_{d}"] if ARMS[arm].get("extractor") == "spectral": deps.append(f"fit_spectral_{b}_{d}") if ARMS[arm].get("extractor") == "jev": deps.append(f"jevk5_calib_{b}_{d}") est = BASE_HOURS[(b, d)] * ARM_FACTOR[arm] * args.rounds / 200 + TEST_HOURS[b] prio = 10 + 10 * ci + ai * 0.1 + (50 if seed > 1 else 0) tid = f"train_{exp}" add(tid, train_script(b, d, arm, seed, args.rounds), gpus_for(b, arm), prio, deps, est, first_look_frac=(100 / args.rounds if ci == 0 and seed == 1 and not smoke else None)) out = paths.QUEUE / ("plan_smoke.json" if smoke else "plan.json") reservations = [{"gpus": args.jev_gpus, "jobs": jev_group}] if args.jev_gpus else [] out.write_text(json.dumps({"jobs": jobs, "reservations": reservations}, indent=1)) print(f"wrote {out}: {len(jobs)} jobs " f"({sum(j['id'].startswith('train_') for j in jobs)} training runs, " f"{sum(j['id'].startswith('eval_') for j in jobs)} evaluations)") return out def main(): parser = argparse.ArgumentParser() parser.add_argument("--rounds", type=int, default=200, help="GRPO rounds (64 prompts x 8 rollouts each)") parser.add_argument("--extra-seeds", type=int, default=0, help="extra seeds for the Qwen-math cell") parser.add_argument("--llama-arms", default="all") parser.add_argument("--smoke", action="store_true", help="tiny end-to-end check (Qwen-math, 10 rounds, small samples); use a separate TDPRM_HOME") parser.add_argument("--jev-gpus", type=lambda s: [int(x) for x in s.split(",")] if s else [], default="7", help="GPUs held for the OpenJev/JevK5 state pipeline until it finishes") args = parser.parse_args() if args.smoke: args.rounds = min(args.rounds, 10) build(args) if __name__ == "__main__": main()