# /// script # requires-python = ">=3.10" # dependencies = [ # "unsloth", # "trl==0.24.0", # "transformers", # "datasets", # "peft", # "accelerate", # "bitsandbytes", # "wandb", # # setuptools/wheel/pip aren't ML deps but torch._inductor.cpp_builder # # imports them at runtime when probing CPU SIMD ISA inside the very # # first GRPO training step. Missing them => "ModuleNotFoundError: # # No module named 'setuptools'" deep in compile_fx. Add them defensively # # alongside the env-level torch.compile disable below. # "setuptools", # "wheel", # "pip", # "scipy>=1.10,<2.0", # "sympy>=1.12,<2.0", # "pydantic>=2.5,<3.0", # "numpy>=1.24,<3.0", # "openenv-core[core]>=0.2.2", # "huggingface_hub>=0.24,<1.0", # "matplotlib>=3.7,<4.0", # ] # /// """PhysiX RLVR training driver for Hugging Face Jobs. Deploy with: hf jobs uv run job_train.py \ --image unsloth/unsloth:2026.3.8-pt2.9.0-vllm-0.16.0-cu12.8-studio-release \ --flavor l40sx1 \ --secrets HF_TOKEN \ --secrets WANDB_API_KEY \ -v hf://datasets/Pratyush-01/physix-live-src:/physix-live \ --timeout 3h How dependencies work on HF Jobs (lesson from the 2026-04-26 failure): The Unsloth studio-release image provides CUDA toolkit, system libs, and a *wheel cache* — but every `hf jobs uv run` job creates a fresh, isolated uv-managed venv that only contains packages declared in the inline block above. There is NO carry-over from /opt/conda site-packages. The official unsloth-jobs blog example follows this exact pattern (declare unsloth, trl, datasets in the inline deps). We pin trl==0.24.0 hard because Unsloth's patch_trl_openenv() does inspect.getsource(...) on a TRL internal function, and that breaks with "OSError: could not get source code" on newer TRL. All other ML deps are left unpinned so Unsloth can pull a self-consistent set off its wheel cache (matches torch 2.9.0 / vLLM 0.16.0 / CUDA 12.8 baked into the image). The mounted dataset at /physix-live contains the source we want to train, installed as an editable package below. """ from __future__ import annotations import os import shutil import subprocess import sys from pathlib import Path # --------------------------------------------------------------------------- # Environment hardening (lessons from the Spaces run) # --------------------------------------------------------------------------- # HF Jobs runs the container as a non-root UID with no /etc/passwd entry, # so getpass.getuser() raises and torch._inductor blows up. Same as Spaces. def _harden_env() -> None: os.environ.setdefault("USER", "physix") os.environ.setdefault("LOGNAME", "physix") os.environ.setdefault("HOME", "/tmp/home") # Route every cache/scratch dir under /tmp (writable everywhere). os.environ.setdefault("HF_HOME", "/tmp/hf_cache") os.environ.setdefault("TORCHINDUCTOR_CACHE_DIR", "/tmp/torchinductor_cache") os.environ.setdefault("TRITON_CACHE_DIR", "/tmp/triton_cache") os.environ.setdefault("XDG_CACHE_HOME", "/tmp/xdg-cache") os.environ.setdefault("WANDB_DIR", "/tmp/wandb") os.environ.setdefault("WANDB_CACHE_DIR", "/tmp/wandb-cache") os.environ.setdefault("WANDB_DATA_DIR", "/tmp/wandb-data") os.environ.setdefault("WANDB_ARTIFACT_DIR", "/tmp/wandb-artifacts") os.environ.setdefault("WANDB_CONFIG_DIR", "/tmp/wandb-config") # Disable wandb model artifact uploads (we push to HF Hub instead). os.environ.setdefault("WANDB_DISABLE_ARTIFACTS", "true") os.environ.setdefault("WANDB_LOG_MODEL", "false") os.environ.setdefault("WANDB_PROJECT", "physix-live") # Unsloth / torch tuning. # # We disable torch.compile / inductor at multiple layers: # - UNSLOTH_COMPILE_DISABLE: skips Unsloth's own torch.compile wraps # - TORCH_COMPILE_DISABLE: short-circuits torch.compile() calls # - TORCHINDUCTOR_DISABLE: prevents inductor backend invocation # - TORCHDYNAMO_DISABLE: stops dynamo from tracing in the first place # All four needed because Unsloth GRPO's _unsloth_training_step still # triggers an inductor CPU-SIMD probe (cpu_vec_isa.pick_vec_isa) on the # first step, which crashes if setuptools or a host C++ toolchain isn't # present in the uv venv. We don't want compile speedups on a 3B-LoRA # run anyway — the eager path is plenty fast on L40S. os.environ.setdefault("UNSLOTH_COMPILE_DISABLE", "1") os.environ.setdefault("TORCH_COMPILE_DISABLE", "1") os.environ.setdefault("TORCHINDUCTOR_DISABLE", "1") os.environ.setdefault("TORCHDYNAMO_DISABLE", "1") os.environ.setdefault("PYTORCH_CUDA_ALLOC_CONF", "expandable_segments:True") os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") os.environ.setdefault("PYTHONUNBUFFERED", "1") # Mirror HF_TOKEN into the standard names that huggingface_hub picks up. if os.environ.get("HF_TOKEN"): os.environ.setdefault("HUGGINGFACE_HUB_TOKEN", os.environ["HF_TOKEN"]) for d in ( os.environ["HOME"], os.environ["HF_HOME"], os.environ["TORCHINDUCTOR_CACHE_DIR"], os.environ["TRITON_CACHE_DIR"], os.environ["XDG_CACHE_HOME"], os.environ["WANDB_DIR"], os.environ["WANDB_CACHE_DIR"], os.environ["WANDB_DATA_DIR"], os.environ["WANDB_ARTIFACT_DIR"], os.environ["WANDB_CONFIG_DIR"], ): Path(d).mkdir(parents=True, exist_ok=True) def _banner(msg: str) -> None: line = "=" * 72 print(f"\n{line}\n {msg}\n{line}", flush=True) def _run(cmd: list[str], *, env: dict | None = None) -> None: print(f"$ {' '.join(cmd)}", flush=True) subprocess.run(cmd, check=True, env=env or os.environ.copy()) def _require(name: str) -> str: val = os.environ.get(name) if not val: sys.exit(f"FATAL: required secret {name!r} is not set on the job") return val def _stage_physix_live() -> Path: """The dataset is mounted read-only at /physix-live. pip install -e needs a writable tree (it creates an .egg-info), so copy to /tmp/src and install from there.""" src = Path("/physix-live") if not src.exists(): sys.exit( "FATAL: expected physix-live source mounted at /physix-live. " "Pass `-v hf://datasets//physix-live-src:/physix-live` " "when submitting the job." ) dst = Path("/tmp/src/physix-live") if dst.exists(): shutil.rmtree(dst) dst.parent.mkdir(parents=True, exist_ok=True) shutil.copytree(src, dst) return dst def _install_physix(repo: Path) -> None: # The base image already pins torch / transformers / unsloth / trl etc. # --no-deps prevents pip from upgrading any of them. # # The Unsloth uv-managed environment does NOT ship pip-the-module by # default (`python -m pip` raises "No module named pip"). Try the `uv # pip` shim first (uv is guaranteed to be on PATH under `hf jobs uv # run`); if that fails for any reason, bootstrap pip via ensurepip and # fall back. Either path uses --no-deps so the carefully pinned # torch/transformers/unsloth/trl in the base image stay untouched. install_args = ["--no-cache-dir", "-e", str(repo), "--no-deps"] try: _run(["uv", "pip", "install", "--python", sys.executable, *install_args]) return except (subprocess.CalledProcessError, FileNotFoundError) as exc: print(f"[install] uv pip path failed ({exc!r}); bootstrapping pip via ensurepip", flush=True) _run([sys.executable, "-m", "ensurepip", "--upgrade"]) _run([sys.executable, "-m", "pip", "install", *install_args]) def _sanity_check_imports() -> None: print("--- Sanity import check ---", flush=True) code = ( "import torch, trl, transformers, datasets, wandb, unsloth, physix; " "print(f'torch={torch.__version__} cuda={torch.cuda.is_available()} " "device={torch.cuda.get_device_name(0) if torch.cuda.is_available() else None}'); " "print(f'unsloth={unsloth.__version__} trl={trl.__version__} " "transformers={transformers.__version__} datasets={datasets.__version__}'); " "print(f'physix loaded from {physix.__file__}'); " "assert trl.__version__ == '0.24.0', f'trl must be pinned to 0.24.0, got {trl.__version__}'" ) _run([sys.executable, "-c", code]) def _gpu_check() -> None: print("--- GPU check ---", flush=True) try: subprocess.run(["nvidia-smi"], check=True) except FileNotFoundError: sys.exit("FATAL: nvidia-smi missing — job hardware is not GPU") # --------------------------------------------------------------------------- # Per-model training profile. # # Each profile bundles the (base-model, lora-r, hub repo names, run names, # lr, num_steps) tuple so we can switch between 1.5B and 7B with a single # constant change. Sized for A100-80GB. # --------------------------------------------------------------------------- PROFILES: dict[str, dict] = { "1.5b": { "base_model": "Qwen/Qwen2.5-1.5B-Instruct", "sft_lora_r": "32", "grpo_lora_r": "32", "sft_lr": "2e-5", "grpo_lr": "5e-6", "sft_epochs": "3", "num_steps": "300", "num_generations": "4", "max_completion": "256", "hub_final_repo": "Pratyush-01/physix-1.5b-rl", "hub_ckpt_repo": "Pratyush-01/physix-1.5b-rl-ckpt", "sft_run_name": "physix-sft-1.5b", "grpo_run_name": "physix-grpo-1.5b", }, "3b": { "base_model": "Qwen/Qwen2.5-3B-Instruct", "sft_lora_r": "32", "grpo_lora_r": "32", "sft_lr": "1.5e-5", # LR history for 3B + LoRA-32 GRPO on damped_spring: # 3e-6 (run c8wgysg4) → flat for 67+ steps, near-zero gradient # 3e-5 (run xrlhnyty) → converged to reward_match≈0.999 by step ~250/500 # curve was too steep; model saturated early # 1e-5 (this run) → ~1/3 of 3e-5; projects convergence at ~750 steps, # so 500 steps lands at ~67% of the curve — # a smooth, steadily rising reward trajectory. # Early stopping fires automatically if std # stays flat for 50 consecutive steps. "grpo_lr": "1e-5", "sft_epochs": "4", "num_steps": "200", "num_generations": "4", "max_completion": "384", "hub_final_repo": "Pratyush-01/physix-3b-rl", "hub_ckpt_repo": "Pratyush-01/physix-3b-rl-ckpt", "sft_run_name": "physix-sft-3b-final", "grpo_run_name": "physix-grpo-3b-final", }, "7b": { "base_model": "Qwen/Qwen2.5-7B-Instruct", # Smaller LoRA rank: 7B has ~4.6× more params than 1.5B so even # at r=16 the trainable count (~40M) is comparable to 1.5B at r=32. "sft_lora_r": "16", "grpo_lora_r": "16", # Lower LR for the bigger base. "sft_lr": "1e-5", "grpo_lr": "2e-6", "sft_epochs": "3", "num_steps": "200", "num_generations": "4", "max_completion": "256", "hub_final_repo": "Pratyush-01/physix-7b-rl", "hub_ckpt_repo": "Pratyush-01/physix-7b-rl-ckpt", "sft_run_name": "physix-sft-7b", "grpo_run_name": "physix-grpo-7b", }, } #: Active profile. ``3b`` chosen for the fast-iteration run — best #: capacity/wall-clock tradeoff for the PhysiX 3-system POC. ACTIVE_PROFILE: str = "3b" def _profile() -> dict: return PROFILES[ACTIVE_PROFILE] def _run_sft() -> None: p = _profile() _banner(f"Step 1/2: SFT warm-start ({p['base_model']})") _run([ sys.executable, "-m", "physix.training.sft", "--model", p["base_model"], "--output-dir", "/tmp/physix-sft", "--epochs", p["sft_epochs"], "--instances-per-system", "64", "--lora-r", p["sft_lora_r"], "--learning-rate", p["sft_lr"], "--wandb-run-name", p["sft_run_name"], # Push the merged SFT model to the same checkpoint repo GRPO uses, # under /sft. Lets a future restart skip SFT and reuse it. "--hub-checkpoint-repo-id", p["hub_ckpt_repo"], "--seed", "0", ]) def _try_resume_from_grpo_checkpoint() -> tuple[Path | None, str | None]: """Look for a prior GRPO checkpoint in the Hub repo for this profile. Returns ``(local_path, wandb_run_id)`` if a checkpoint was found and successfully downloaded, else ``(None, None)``. The downloaded directory is what gets passed to ``--resume-from-checkpoint``; the run id (when present) is set as ``WANDB_RUN_ID`` so the GRPO chart continues on the same timeline rather than starting fresh. """ p = _profile() repo_id = p["hub_ckpt_repo"] try: from physix.training.checkpoints import ( download_checkpoint, find_latest_grpo_checkpoint, ) except ImportError as exc: print(f"[resume] checkpoints helper not importable yet: {exc}", flush=True) return None, None token = os.environ.get("HF_TOKEN") handle = find_latest_grpo_checkpoint(repo_id, token=token) if handle is None: print(f"[resume] No prior GRPO checkpoint in {repo_id}; cold start.", flush=True) return None, None print( f"[resume] Found prior GRPO checkpoint at {handle.hub_url} (step={handle.step}). " f"Downloading to /tmp/physix-grpo-resume ...", flush=True, ) local = download_checkpoint(handle, "/tmp/physix-grpo-resume", token=token) # Look up the W&B run id stashed at repo root by the on_train_begin # callback. If present, we'll pass it through so wandb.init resumes # the same run and the loss/reward charts stay continuous. run_id: str | None = None try: from huggingface_hub import hf_hub_download run_id_path = hf_hub_download( repo_id=repo_id, filename="wandb_run_id.txt", repo_type="model", token=token, ) run_id = Path(run_id_path).read_text().strip() or None if run_id: print(f"[resume] W&B run id {run_id} — chart will continue on the same timeline.", flush=True) except Exception as exc: # noqa: BLE001 print(f"[resume] No wandb_run_id.txt on repo (will start fresh W&B run): {exc}", flush=True) return local, run_id def _run_grpo( *, lora_adapter_repo: str | None = None, resume_from_checkpoint: Path | None = None, ) -> None: """Run the GRPO step. Three modes (mutually exclusive): - Cold start (default): warm from /tmp/physix-sft/merged. - From an existing Hub LoRA adapter: ``lora_adapter_repo`` set. - Resume from a prior in-flight ckpt: ``resume_from_checkpoint`` set (continues the SAME wandb run id when one is published on the repo). Reward set (physix.training.reward_fns): match, match_dense, correctness, simplicity, format Anti-hack invariants (RCA from 5kuqns9x): - ``progress`` removed (duplicated ``match`` in single-turn). - ``simplicity`` gated on R² ≥ 0.10. - ``format`` requires simulation success, not just parse success. - Three correctness-shaped signals dominate the GRPO advantage. """ p = _profile() num_steps = int(p["num_steps"]) _banner(f"GRPO RLVR ({num_steps} steps on {p['base_model']})") cmd = [ sys.executable, "-m", "physix.training.loop", "--model", p["base_model"], "--output-dir", "/tmp/physix-grpo", "--num-steps", str(num_steps), "--num-generations", p["num_generations"], "--max-completion-length", p["max_completion"], "--learning-rate", p["grpo_lr"], "--instances-per-system", "64", "--lora-r", p["grpo_lora_r"], "--save-method", "merged_16bit", "--push-to-hub", "--hub-repo-id", p["hub_final_repo"], "--hub-checkpoint-repo-id", p["hub_ckpt_repo"], "--wandb-project", "physix-live", "--wandb-run-name", p["grpo_run_name"], "--early-stop-patience", "50", "--seed", "0", ] if resume_from_checkpoint is not None: cmd += ["--resume-from-checkpoint", str(resume_from_checkpoint)] elif lora_adapter_repo: cmd += ["--lora-adapter-repo", lora_adapter_repo] else: cmd += ["--sft-checkpoint", "/tmp/physix-sft/merged"] _run(cmd) # --------------------------------------------------------------------------- # Resume configuration (baked in deliberately). # # We ship resume parameters as module-level constants instead of `-e` env # flags because `hf jobs uv run -e KEY=VAL` was observed to silently drop # env entries on submission (the job spec's `environment` dict ends up # containing only the auto-injected LOCAL_FILES_ENCODED). The script # encoding is reliable, so embedding the constants here is the # fail-safe path. # # To do a fresh run instead, set RESUME_LORA_REPO to None. # # Note: we deliberately do NOT resume into the SAME W&B run id this time # (RESUME_WANDB_RUN_ID = None). The previous run 5kuqns9x logged 4 reward # components; this one logs 3 (no_progress). Continuing the same chart # would mix two different reward setups on one timeline, which is # misleading. Instead we start a fresh run and link back to the source # run via wandb config + summary. # --------------------------------------------------------------------------- #: When set, skip SFT and warm-start GRPO from this Hub LoRA adapter. #: Must be ``None`` when switching base models — a 1.5B adapter cannot #: be loaded onto a 7B base. Only set this to resume the *same* model #: family from a prior interrupted run. RESUME_LORA_REPO: str | None = None RESUME_FROM_WANDB_RUN: str | None = None # informational only (link) def main() -> None: _harden_env() if RESUME_FROM_WANDB_RUN: # Pin the source run as W&B config so the new run's Overview tab # shows the lineage. We do NOT set WANDB_RUN_ID here. os.environ["WANDB_RESUMED_FROM"] = RESUME_FROM_WANDB_RUN print( f"[resume] Warm-starting from W&B run {RESUME_FROM_WANDB_RUN} " f"(https://wandb.ai/pratyush01/physix-live/runs/{RESUME_FROM_WANDB_RUN})", flush=True, ) resume_lora = RESUME_LORA_REPO p = _profile() if resume_lora: _banner( f"PhysiX RLVR RESUME job ({ACTIVE_PROFILE} on A100-large)\n" f" adapter: {resume_lora}\n" f" steps: {p['num_steps']}\n" f" wandb: {os.environ.get('WANDB_RUN_ID', '')}" ) else: _banner( f"PhysiX RLVR training job ({ACTIVE_PROFILE} / {p['base_model']} on A100-large)" ) _require("HF_TOKEN") _require("WANDB_API_KEY") _gpu_check() repo = _stage_physix_live() _install_physix(repo) _sanity_check_imports() if resume_lora: # Forced LoRA resume (RESUME_LORA_REPO set above) — skip SFT and # warm-start GRPO from a specific Hub adapter, fresh wandb run. _run_grpo(lora_adapter_repo=resume_lora) else: # Auto-resume: if a prior GRPO checkpoint already exists in the # checkpoint repo (e.g. previous job died at step 87), pick up # where it left off and continue the SAME wandb run id so the # loss/reward chart is one continuous line. If nothing's there, # do the normal SFT -> GRPO cold start. ckpt_local, prior_run_id = _try_resume_from_grpo_checkpoint() if ckpt_local is not None: if prior_run_id: # wandb.init(resume="allow") inside loop.py picks this up. os.environ["WANDB_RUN_ID"] = prior_run_id os.environ["WANDB_RESUME"] = "allow" _run_grpo(resume_from_checkpoint=ckpt_local) else: _run_sft() _run_grpo() _banner("DONE") print( f"Final model → https://huggingface.co/{p['hub_final_repo']}\n" f"Checkpoints → https://huggingface.co/{p['hub_ckpt_repo']}\n" f"W&B project → https://wandb.ai/pratyush01/physix-live\n", flush=True, ) if __name__ == "__main__": main()