"""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 pathlib import Path 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 v2_factor(arm): base = arm.replace("_nogate", "").replace("_v2", "") return ARM_FACTOR.get(base, ARM_FACTOR["s_gae"]) # vp_* (value probe) costs like the spectral arms def v2_inputs(b, d, arm): """Existing files a v2 training job needs (no prep jobs: v2 reuses data, rollouts and states).""" spec, cell = ARMS[arm], f"$TDPRM_HOME/states/{b}_{d}" deps = [f"file:$TDPRM_HOME/data/train/{d}_{b}.parquet"] if spec.get("extractor") == "spectral": deps += [f"file:{cell}/spectral_k7.npz", f"file:{cell}/spectral_warm.npz"] if spec.get("extractor") == "jev": deps += [f"file:$TDPRM_HOME/states/{d}_openjev_states.json", f"file:{cell}/jevk5_calibration.json", f"file:{cell}/jev_warm.npz"] return deps def build_v2(args): """v2 jobs (scripts run this checkout via TDPRM_REPO), merged into an existing plan file so that one queue drives every GPU. Waves are priorities 21, 22, ... : after every Qwen v1 cell, before the Llama v1 cells (30+). A GPU pilot (10 rounds) runs first; every wave job waits for the pilot check's PASS marker. Held Llama v1 jobs are released when the pilot check has run, so the waves (higher priority) still start first.""" jobs = [] def add(jid, body, gpus, priority, deps=(), est=1.0): jobs.append({"id": jid, "script": write_script(jid, body), "gpus": gpus, "priority": priority, "deps": list(deps), "est_hours": round(est, 2), "v2": True}) waves = [w for w in args.v2_waves.split(";") if w.strip()] cells = sorted({tuple(w.split("=")[0].split(":")) for w in waves} | {("qwen1.5b", "math")}) for b, d in cells: add(f"retest_{b}_{d}", py_job(f"tdprm.sampling.base_rollouts --backbone {b} --domain {d} --retest-only"), 0, 0.5, [f"file:$TDPRM_HOME/rollouts/{b}_{d}.jsonl.gz"], 0.05) pilot_runs = [] for b, arm in [("qwen1.5b", a) for a in args.v2_pilot.split(",")] + [("llama3b", args.v2_pilot_llama)]: exp = experiment(b, "math", arm, 0) pilot_runs.append(exp) body = train_script(b, "math", arm, 0, 10, "--eval-prompts 32 --no-test").rstrip("\n") # a pilot always "finishes": pilot_v2_check judges it from its logs, so a failure cannot block the queue add(f"pilot_{exp}", body + " || echo '[pilot] training exited with an error'\n", gpus_for(b), 9.5, [f"retest_{b}_math"] + v2_inputs(b, "math", arm), 0.6 if b == "qwen1.5b" else 1.0) marker = "$TDPRM_HOME/report/pilot_v2.PASS" qwen_marker = "$TDPRM_HOME/report/pilot_v2_qwen.PASS" add("pilot_v2_check", py_job(f"tdprm.report.pilot_v2 --runs {' '.join(pilot_runs)}"), 0, 9.6, [f"pilot_{e}" for e in pilot_runs], 0.05) qwen_pilots = [e for e in pilot_runs if e.startswith("qwen")] add("pilot_v2_qwen_check", py_job(f"tdprm.report.pilot_v2 --name pilot_v2_qwen --runs {' '.join(qwen_pilots)}"), 0, 9.6, [f"pilot_{e}" for e in qwen_pilots], 0.05) held = " ".join(args.v2_release) if held: add("release_llama_v1", PREAMBLE.format(repo=paths.REPO, home=paths.HOME) + f"for j in {held}; do python -m tdprm.queue.gpuq retry --plan {args.v2_merge_into} $j; done\n", 0, 9.7, ["pilot_v2_check"], 0.01) # every Qwen wave before any Llama wave; Qwen waves only need the Qwen pilots, Llama waves need the full check order = sorted(range(len(waves)), key=lambda i: (waves[i].startswith("llama"), i)) for rank, wi in enumerate(order): cell, arms = waves[wi].split("=") b, d = cell.split(":") for ai, arm in enumerate(arms.split(",")): exp = experiment(b, d, arm, 1) add(f"train_{exp}", train_script(b, d, arm, 1, args.rounds), gpus_for(b), 21 + rank + ai * 0.01, [f"file:{qwen_marker if b == 'qwen1.5b' else marker}", f"retest_{b}_{d}"] + v2_inputs(b, d, arm), BASE_HOURS[(b, d)] * v2_factor(arm) * args.rounds / 200 + TEST_HOURS[b]) target = paths.QUEUE / args.v2_merge_into if "/" not in args.v2_merge_into else Path(args.v2_merge_into) data = json.loads(target.read_text()) # Llama jobs (v2 and v1) start only after these Qwen v2 runs have finished (any final outcome) after = [f"after:{j['id']}" for j in jobs if j["id"].startswith("train_qwen1.5b-") and j["id"].split("-")[1] in args.llama_after_domains] # train_--- if not after and args.llama_after_domains: raise SystemExit(f"no Qwen v2 runs found for {args.llama_after_domains}: Llama would not wait") for j in jobs + data["jobs"]: if j["id"].startswith("train_llama3b"): j["deps"] = [d for d in j["deps"] if not d.startswith("after:")] + after ids = {j["id"] for j in jobs} data["jobs"] = [j for j in data["jobs"] if not j.get("v2") and j["id"] not in ids] + jobs tmp = target.with_suffix(".tmp") tmp.write_text(json.dumps(data, indent=1)) tmp.replace(target) print(f"merged {len(jobs)} v2 jobs into {target} " f"({sum(j['id'].startswith('train_') for j in jobs)} training runs, {len(pilot_runs)} pilots)") 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") parser.add_argument("--v2-waves", default="", help='v2 only: "b:d=arm,arm;b:d=arm,..." (priority waves)') parser.add_argument("--v2-merge-into", default=str(paths.QUEUE / "plan.json")) parser.add_argument("--v2-pilot", default="grpo_v2,s_gae_v2,vp_gae_v2,j_gae_v2,prm800k_v2") parser.add_argument("--v2-pilot-llama", default="s_gae_v2") parser.add_argument("--v2-release", nargs="*", default=[], help="held job ids to release after the pilot") parser.add_argument("--llama-after-domains", nargs="*", default=["proverqa"], help="Llama training jobs wait until every Qwen v2 run of these domains has finished") args = parser.parse_args() if args.v2_waves: build_v2(args) return if args.smoke: args.rounds = min(args.rounds, 10) build(args) if __name__ == "__main__": main()