| """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"] |
| |
| 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} |
| 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) |
| 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): |
| |
| |
| |
| 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)) |
| 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"]) |
|
|
|
|
| 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") |
| |
| 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) |
| |
| 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()) |
| |
| 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] |
| 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() |
|
|
