Add checkpoint helpers + SFT hub push + GRPO resume

README.md

@@ -1,13 +1,53 @@
 # PhysiX-Live
 
-**One-line pitch:** an OpenEnv RL environment where a small (1.5B) language model iteratively
+**One-line pitch:** an OpenEnv RL environment where a small language model iteratively
 discovers equations of motion from trajectory data plus a one-sentence English hint —
 verifier is `scipy.integrate.odeint` plus per-step R², no LLM-as-judge in the reward loop.
 
 A submission for the **OpenEnv hackathon** (Apr 2026). The deliverables are: a clean
-OpenEnv-compatible env, a TRL+Unsloth+GRPO training pipeline targeting Qwen2.5-1.5B with
-LoRA-32, a React + TypeScript + Tailwind demo UI that animates trajectories side-by-side
-for the trained vs. untrained model, and a recording script for pre-baked demo episodes.
+OpenEnv-compatible env, a TRL+Unsloth+GRPO training pipeline targeting Qwen2.5 (1.5B / 3B
+profiles) with LoRA, a React + TypeScript + Tailwind demo UI that animates trajectories
+side-by-side for the trained vs. untrained model, and a recording script for pre-baked
+demo episodes.
+
+---
+
+## Deliverables
+
+| Deliverable                  | Where                                                                              |
+| ---------------------------- | ---------------------------------------------------------------------------------- |
+| **Public HF Space (live demo)** | https://huggingface.co/spaces/Pratyush-01/physix-live                          |
+| **Training driver script**   | [`physix-train/job_train.py`](../physix-train/job_train.py) — PEP 723 inline-deps UV script, runs end-to-end on `hf jobs uv run` |
+| **GRPO training loop**       | [`physix/training/loop.py`](physix/training/loop.py) — Unsloth + TRL GRPOTrainer    |
+| **SFT warm-start**           | [`physix/training/sft.py`](physix/training/sft.py)                                  |
+| **Trained adapters (Hub)**   | [`Pratyush-01/physix-3b-rl`](https://huggingface.co/Pratyush-01/physix-3b-rl)       |
+| **Mid-run checkpoints**      | [`Pratyush-01/physix-3b-rl-ckpt`](https://huggingface.co/Pratyush-01/physix-3b-rl-ckpt) |
+| **W&B project**              | https://wandb.ai/pratyush01/physix-live                                            |
+| **Writeup**                  | [`docs/writeup.md`](docs/writeup.md)                                               |
+
+## Training curves
+
+Both curves are auto-generated at end of every GRPO run by
+`physix.training.loop._render_training_curves` and committed to the repo at
+`docs/plots/`. The interpretation rules:
+
+- **`train/loss`** is the GRPO surrogate (advantage-weighted log-prob + β·KL).
+  Should trend **down** as advantages get exploited. (Per
+  [TRL docs](https://huggingface.co/docs/trl/main/logging) — this is the full
+  surrogate, not just the KL term.)
+- **`train/reward`** is mean total reward across rollouts. Should trend **up**.
+  This is the headline curve.
+- **Per-component reward** breaks `train/reward` into the 5 reward functions
+  (`match`, `match_dense`, `correctness`, `simplicity`, `format`). Used to spot
+  reward hacking — e.g. `simplicity` rising while `match` regresses.
+
+| Loss (down is good) | Reward (up is good) |
+| --- | --- |
+| ![GRPO loss curve](docs/plots/loss.png) | ![GRPO reward curve](docs/plots/reward.png) |
+
+| Per-component reward (anti-hack diagnostic) |
+| --- |
+| ![Reward components overlay](docs/plots/reward_components.png) |
 
 ---
 

physix/training/checkpoints.py

@@ -0,0 +1,214 @@
+"""Checkpoint push/pull helpers shared by SFT and GRPO.
+
+Two responsibilities:
+
+1. **Push a local checkpoint dir to a Hugging Face Hub repo as a subfolder**
+   (e.g. SFT writes to ``<repo>/sft/``, GRPO writes to ``<repo>/checkpoint-N/``).
+   Returns the resulting Hub revision SHA so the caller can pin it in W&B.
+
+2. **Discover and download the latest GRPO checkpoint** from the same repo,
+   so a re-launched job can resume the same GRPO run rather than redoing SFT.
+
+We deliberately do NOT push raw model weights into W&B Artifacts — they live
+on the Hub. W&B gets a tiny **link-artifact** (one JSON metadata file with
+the Hub repo + revision SHA + step), which is enough for `wandb artifact
+get` to round-trip back to the Hub and download via `huggingface_hub`.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import tempfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+_log = logging.getLogger(__name__)
+
+
+# Subfolder names on the Hub checkpoint repo. The SFT subfolder is fixed.
+# GRPO checkpoint subfolders follow Trainer's "checkpoint-{step}" convention.
+SFT_SUBFOLDER = "sft"
+GRPO_CHECKPOINT_RE = re.compile(r"^checkpoint-(\d+)$")
+
+
+@dataclass
+class CheckpointHandle:
+    """A pointer to a checkpoint on the Hub.
+
+    ``revision`` is a commit SHA (not a branch) so the artifact is
+    immutable — re-pushes to the same subfolder won't change what we
+    resume from.
+    """
+    repo_id: str
+    subfolder: str
+    revision: str
+    step: Optional[int] = None  # populated for GRPO checkpoint-N
+
+    @property
+    def hub_url(self) -> str:
+        return f"https://huggingface.co/{self.repo_id}/tree/{self.revision}/{self.subfolder}"
+
+
+def push_checkpoint_to_hub(
+    local_dir: str | os.PathLike,
+    repo_id: str,
+    subfolder: str,
+    *,
+    commit_message: str,
+    token: Optional[str] = None,
+) -> CheckpointHandle:
+    """Upload ``local_dir`` to ``repo_id/<subfolder>/`` and return a pinned handle.
+
+    Raises if the repo can't be created or upload fails — the caller decides
+    whether to swallow the exception.
+    """
+    from huggingface_hub import HfApi, create_repo
+
+    local = Path(local_dir)
+    if not local.is_dir():
+        raise FileNotFoundError(f"checkpoint dir does not exist: {local}")
+
+    api = HfApi(token=token)
+    create_repo(repo_id, exist_ok=True, repo_type="model", token=token)
+
+    _log.info("Uploading %s -> %s/%s", local, repo_id, subfolder)
+    commit = api.upload_folder(
+        folder_path=str(local),
+        repo_id=repo_id,
+        path_in_repo=subfolder,
+        commit_message=commit_message,
+        token=token,
+    )
+    revision = commit.oid if hasattr(commit, "oid") else str(commit)
+    _log.info("Push complete; revision=%s", revision)
+    return CheckpointHandle(
+        repo_id=repo_id,
+        subfolder=subfolder,
+        revision=revision,
+    )
+
+
+def find_latest_grpo_checkpoint(
+    repo_id: str,
+    *,
+    token: Optional[str] = None,
+) -> Optional[CheckpointHandle]:
+    """Return the highest-step ``checkpoint-N/`` folder on the repo, or None.
+
+    Reads the *current* main revision (so concurrent pushes are race-free
+    for our purposes — we never need to resume from a half-finished push).
+    """
+    from huggingface_hub import HfApi
+    from huggingface_hub.utils import RepositoryNotFoundError, RevisionNotFoundError
+
+    api = HfApi(token=token)
+    try:
+        files = api.list_repo_files(repo_id, repo_type="model", token=token)
+    except (RepositoryNotFoundError, RevisionNotFoundError):
+        return None
+    except Exception as exc:  # noqa: BLE001
+        _log.warning("Could not list %s: %s", repo_id, exc)
+        return None
+
+    best_step = -1
+    best_subfolder: Optional[str] = None
+    for f in files:
+        # Top-level folder name is the first path component.
+        head = f.split("/", 1)[0]
+        m = GRPO_CHECKPOINT_RE.match(head)
+        if not m:
+            continue
+        step = int(m.group(1))
+        if step > best_step:
+            best_step = step
+            best_subfolder = head
+
+    if best_subfolder is None:
+        return None
+
+    # Pin the revision to the current main HEAD so concurrent commits don't
+    # surprise us partway through download.
+    info = api.repo_info(repo_id, repo_type="model", token=token)
+    revision = info.sha or "main"
+    return CheckpointHandle(
+        repo_id=repo_id,
+        subfolder=best_subfolder,
+        revision=revision,
+        step=best_step,
+    )
+
+
+def download_checkpoint(
+    handle: CheckpointHandle,
+    local_dir: str | os.PathLike,
+    *,
+    token: Optional[str] = None,
+) -> Path:
+    """Download a Hub checkpoint subfolder to ``local_dir`` and return the path."""
+    from huggingface_hub import snapshot_download
+
+    target = Path(local_dir)
+    target.mkdir(parents=True, exist_ok=True)
+
+    snapshot_download(
+        repo_id=handle.repo_id,
+        revision=handle.revision,
+        allow_patterns=[f"{handle.subfolder}/*"],
+        local_dir=str(target),
+        token=token,
+    )
+    out = target / handle.subfolder
+    if not out.is_dir():
+        raise FileNotFoundError(
+            f"download succeeded but {out} is missing — check repo layout"
+        )
+    return out
+
+
+def log_link_artifact_to_wandb(
+    handle: CheckpointHandle,
+    *,
+    artifact_name: str,
+    extra: Optional[dict] = None,
+) -> None:
+    """Log a tiny pointer-only artifact to the active W&B run.
+
+    The artifact contains a single ``checkpoint.json`` describing the Hub
+    location and revision. No model bytes are uploaded — this is purely an
+    addressable, versioned reference (~200 bytes) that makes the artifact
+    panel of the W&B run usable as a checkpoint registry.
+    """
+    try:
+        import wandb
+    except ImportError:
+        return
+    if wandb.run is None:
+        return
+
+    payload = {
+        "repo_id": handle.repo_id,
+        "subfolder": handle.subfolder,
+        "revision": handle.revision,
+        "step": handle.step,
+        "hub_url": handle.hub_url,
+    }
+    if extra:
+        payload.update(extra)
+
+    with tempfile.TemporaryDirectory() as tmp:
+        meta_path = Path(tmp) / "checkpoint.json"
+        meta_path.write_text(json.dumps(payload, indent=2))
+        artifact = wandb.Artifact(
+            name=artifact_name,
+            type="model-pointer",
+            description=f"Pointer to {handle.hub_url}",
+            metadata=payload,
+        )
+        artifact.add_file(str(meta_path))
+        try:
+            wandb.run.log_artifact(artifact)
+        except Exception as exc:  # noqa: BLE001
+            _log.warning("W&B artifact logging failed (non-fatal): %s", exc)

physix/training/loop.py

@@ -197,6 +197,7 @@ def train(config: TrainingConfig) -> None:
     trainer.train(resume_from_checkpoint=config.resume_from_checkpoint)
 
     _log_reward_summary(trainer)
+    _render_training_curves(trainer, config)
 
     _log.info("Saving adapter (%s) to %s", config.save_method, config.output_dir)
     _save_artifacts(model, tokenizer, config)
@@ -204,15 +205,20 @@ def train(config: TrainingConfig) -> None:
 
 
 def _log_reward_summary(trainer: "GRPOTrainer") -> None:
-    """Emit a final reward-signal summary so log readers don't misinterpret
-    GRPO's near-zero ``train/loss`` as a broken run. ``train/loss`` is just
-    the KL term; what matters is whether reward components moved.
+    """Emit a final reward-signal summary at end of training.
 
     Pulls the last ``log_history`` entry that contains reward keys and prints
-    the mean of every ``rewards/*/mean`` it finds, plus an explicit
-    interpretation hint. If *no* reward keys are present we hard-fail — that
-    means the reward functions never produced a non-NaN value, which is a
-    real bug worth surfacing.
+    the mean of every ``rewards/*/mean`` it finds. If *no* reward keys are
+    present we hard-fail — that means the reward functions never produced a
+    non-NaN value, which is a real bug worth surfacing.
+
+    Note on ``train/loss``: this scalar IS the GRPO surrogate objective
+    (advantage-weighted token log-probabilities, plus the KL-to-ref penalty
+    when ``beta > 0``). Per the TRL docs (``trl/docs/source/grpo_trainer.md``)
+    the ``Trainer`` superclass logs the full surrogate as ``loss``, not just
+    the KL term. So ``train/loss`` collapsing without ``train/reward`` rising
+    is a real failure mode — typically a sign of reward hacking or saturated
+    advantages — and should be debugged, not dismissed.
     """
     history = getattr(trainer.state, "log_history", []) or []
     reward_entries = [
@@ -240,14 +246,190 @@ def _log_reward_summary(trainer: "GRPOTrainer") -> None:
             if isinstance(v0, (int, float)) and isinstance(v1, (int, float)):
                 _log.info("  %-40s %.4f → %.4f  (Δ=%+.4f)", key, v0, v1, v1 - v0)
     _log.info("-" * 60)
-    _log.info("NOTE: train/loss near zero is EXPECTED for GRPO — it is only")
-    _log.info("the KL-term contribution (beta=%.3f). The model learns via the",
-              trainer.args.beta)
-    _log.info("advantage-weighted policy gradient, which doesn't appear in")
-    _log.info("the displayed loss scalar. Trust `train/reward` and `rewards/*`.")
+    _log.info("Interpretation guide:")
+    _log.info("  train/loss     — full GRPO surrogate (policy + KL*beta).")
+    _log.info("                   Should DECREASE as advantages get exploited.")
+    _log.info("  train/reward   — mean episode reward across rollouts.")
+    _log.info("                   Should INCREASE; this is the headline curve.")
+    _log.info("  train/kl       — KL(policy || ref). Should grow slowly.")
+    _log.info("  rewards/*/mean — per-component reward (match, simplicity, …).")
+    _log.info("Loss-down WITHOUT reward-up is a red flag (reward hacking or")
+    _log.info("advantage saturation).")
     _log.info("=" * 60)
 
 
+def _render_training_curves(
+    trainer: "GRPOTrainer",
+    config: TrainingConfig,
+) -> None:
+    """Render the headline training curves to PNG and ship them.
+
+    Why we do this in-process at end of training (instead of pulling from
+    W&B post-hoc):
+
+    1. The competition's automated validation requires PNG plots committed
+       to the public repo at submission time. Wandb-only links don't count.
+    2. ``trainer.state.log_history`` already contains every metric the
+       Trainer logged step-by-step — no API roundtrip needed.
+    3. We can also push the PNGs to the model Hub repo so they're discoverable
+       from the model card without a separate deploy step.
+
+    Renders three curves:
+
+    - ``loss.png``                — ``train/loss`` over global step.
+                                    GRPO surrogate; SHOULD trend down.
+    - ``reward.png``              — ``reward`` (or ``train/reward``) over step
+                                    with ±1σ band. SHOULD trend up.
+    - ``reward_components.png``   — overlay of every ``rewards/<name>/mean``
+                                    so reward hacking shows up visually
+                                    (e.g. ``simplicity`` rising while
+                                    ``match`` regresses).
+
+    Failures are logged and swallowed — a missing plot must not crash a
+    successful training run, since the model artefact is still useful.
+    """
+    try:
+        import matplotlib
+        matplotlib.use("Agg")  # headless / no display server in HF Jobs
+        import matplotlib.pyplot as plt
+    except Exception as exc:  # noqa: BLE001
+        _log.warning("matplotlib unavailable, skipping curve PNGs: %s", exc)
+        return
+
+    history = list(getattr(trainer.state, "log_history", []) or [])
+    if not history:
+        _log.warning("No log_history found — cannot render curves.")
+        return
+
+    plots_dir = Path(config.output_dir) / "plots"
+    plots_dir.mkdir(parents=True, exist_ok=True)
+
+    def _series(metric: str) -> tuple[list[int], list[float]]:
+        xs: list[int] = []
+        ys: list[float] = []
+        for entry in history:
+            if metric in entry and "step" in entry:
+                value = entry[metric]
+                if isinstance(value, (int, float)):
+                    xs.append(int(entry["step"]))
+                    ys.append(float(value))
+        return xs, ys
+
+    rendered: list[Path] = []
+
+    # 1) Loss — the GRPO surrogate.
+    steps_l, losses = _series("loss")
+    if steps_l:
+        fig, ax = plt.subplots(figsize=(8, 4.5))
+        ax.plot(steps_l, losses, color="#d62728", linewidth=1.8)
+        ax.set_xlabel("training step")
+        ax.set_ylabel("GRPO surrogate loss")
+        ax.set_title("PhysiX GRPO — train/loss (lower is better)")
+        ax.grid(alpha=0.3)
+        path = plots_dir / "loss.png"
+        fig.tight_layout()
+        fig.savefig(path, dpi=140)
+        plt.close(fig)
+        rendered.append(path)
+    else:
+        _log.warning("No 'loss' entries in log_history.")
+
+    # 2) Reward — headline curve (with ±std band when available).
+    steps_r, rewards = _series("reward")
+    _, reward_std = _series("reward_std")
+    if steps_r:
+        fig, ax = plt.subplots(figsize=(8, 4.5))
+        ax.plot(steps_r, rewards, color="#2ca02c", linewidth=2.0, label="mean reward")
+        if reward_std and len(reward_std) == len(rewards):
+            import numpy as np
+            r = np.asarray(rewards)
+            s = np.asarray(reward_std)
+            ax.fill_between(steps_r, r - s, r + s, color="#2ca02c", alpha=0.18,
+                            label="±1σ across rollouts")
+        ax.set_xlabel("training step")
+        ax.set_ylabel("mean reward (sum of components)")
+        ax.set_title("PhysiX GRPO — train/reward (higher is better)")
+        ax.legend(loc="best")
+        ax.grid(alpha=0.3)
+        path = plots_dir / "reward.png"
+        fig.tight_layout()
+        fig.savefig(path, dpi=140)
+        plt.close(fig)
+        rendered.append(path)
+    else:
+        _log.warning("No 'reward' entries in log_history.")
+
+    # 3) Per-component reward overlay — exposes reward hacking patterns.
+    component_keys = sorted({
+        k for entry in history for k in entry
+        if k.startswith("rewards/") and k.endswith("/mean")
+    })
+    if component_keys:
+        fig, ax = plt.subplots(figsize=(8, 4.5))
+        for k in component_keys:
+            xs, ys = _series(k)
+            if xs:
+                label = k.removeprefix("rewards/").removesuffix("/mean")
+                ax.plot(xs, ys, linewidth=1.6, label=label)
+        ax.set_xlabel("training step")
+        ax.set_ylabel("component mean reward")
+        ax.set_title("PhysiX GRPO — per-component reward (rewards/*/mean)")
+        ax.legend(loc="best", fontsize=8)
+        ax.grid(alpha=0.3)
+        path = plots_dir / "reward_components.png"
+        fig.tight_layout()
+        fig.savefig(path, dpi=140)
+        plt.close(fig)
+        rendered.append(path)
+
+    if not rendered:
+        _log.warning("No PNGs rendered — log_history had no recognised metrics.")
+        return
+
+    _log.info("Rendered %d curve PNG(s) to %s", len(rendered), plots_dir)
+
+    # Log the PNGs as wandb.Images so they appear in the run's Media tab,
+    # and persist to the run summary as a reference table.
+    try:
+        import wandb
+        if wandb.run is not None:
+            wandb.log({
+                f"plots/{p.stem}": wandb.Image(str(p)) for p in rendered
+            })
+            _log.info("Logged %d plot(s) to wandb.Media", len(rendered))
+    except Exception as exc:  # noqa: BLE001
+        _log.warning("Could not log plots to wandb: %s", exc)
+
+    # Push PNGs to the final Hub model repo under ``plots/`` so the model
+    # card can render them and ``sync-plots.sh`` can pull them locally.
+    if config.push_to_hub and config.hub_repo_id:
+        try:
+            from huggingface_hub import HfApi, create_repo
+
+            api = HfApi(token=os.environ.get("HUGGINGFACE_HUB_TOKEN"))
+            create_repo(
+                repo_id=config.hub_repo_id,
+                repo_type="model",
+                exist_ok=True,
+                token=os.environ.get("HUGGINGFACE_HUB_TOKEN"),
+            )
+            for p in rendered:
+                api.upload_file(
+                    path_or_fileobj=str(p),
+                    path_in_repo=f"plots/{p.name}",
+                    repo_id=config.hub_repo_id,
+                    repo_type="model",
+                    commit_message=f"plots: {p.name}",
+                )
+            _log.info(
+                "Pushed %d plot(s) to https://huggingface.co/%s/tree/main/plots",
+                len(rendered),
+                config.hub_repo_id,
+            )
+        except Exception as exc:  # noqa: BLE001
+            _log.warning("Could not push plots to Hub: %s", exc)
+
+
 def _load_model_and_tokenizer(
     config: TrainingConfig,
 ) -> tuple[FastLanguageModel, AutoTokenizer]:
@@ -482,9 +664,38 @@ class _WandbCheckpointCallback(TrainerCallback):
                 f"\n[wandb] Checkpoint repo pinned in run summary: {self._repo_url}\n",
                 flush=True,
             )
+
+            # Stash the W&B run id at the *root* of the checkpoint repo so a
+            # future re-launch can find it without W&B API calls. Atomic with
+            # checkpoint storage, ~36 bytes. We do this once at train begin
+            # instead of every save to avoid 200 redundant commits.
+            self._publish_wandb_run_id(wandb.run.id)
         except Exception as exc:  # noqa: BLE001
             _log.warning("Could not pin checkpoint repo to W&B summary: %s", exc)
 
+    def _publish_wandb_run_id(self, run_id: str) -> None:
+        try:
+            import tempfile
+            from huggingface_hub import HfApi, create_repo
+
+            token = os.environ.get("HUGGINGFACE_HUB_TOKEN") or os.environ.get("HF_TOKEN")
+            api = HfApi(token=token)
+            create_repo(self._repo, exist_ok=True, repo_type="model", token=token)
+            with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as tmp:
+                tmp.write(run_id)
+                tmp_path = tmp.name
+            api.upload_file(
+                path_or_fileobj=tmp_path,
+                path_in_repo="wandb_run_id.txt",
+                repo_id=self._repo,
+                repo_type="model",
+                commit_message=f"Pin W&B run id {run_id}",
+                token=token,
+            )
+            print(f"[wandb] Published run_id={run_id} to {self._repo_url}/wandb_run_id.txt", flush=True)
+        except Exception as exc:  # noqa: BLE001
+            _log.warning("Could not publish wandb run id (non-fatal): %s", exc)
+
     def on_save(
         self,
         args: HFTrainingArguments,
@@ -523,7 +734,28 @@ class _WandbCheckpointCallback(TrainerCallback):
             # Re-log the entire table each time so the latest version shows.
             wandb.log({"checkpoint_history": self._table}, step=step)
 
-            # 4. Stdout banner — also visible in `hf jobs logs`.
+            # 4. Pointer-only W&B Artifact (~200 bytes JSON). Doesn't upload
+            #    weights — those are on the Hub already — but makes every
+            #    checkpoint a first-class, addressable W&B artifact that can
+            #    be looked up later by `wandb artifact get`. Side effect:
+            #    populates the run's "Artifacts" panel with one entry per save.
+            if commit_sha:
+                from physix.training.checkpoints import (
+                    CheckpointHandle,
+                    log_link_artifact_to_wandb,
+                )
+                handle = CheckpointHandle(
+                    repo_id=self._repo,
+                    subfolder=f"checkpoint-{step}",
+                    revision=commit_sha,
+                    step=step,
+                )
+                log_link_artifact_to_wandb(
+                    handle,
+                    artifact_name="physix-grpo-checkpoint",
+                )
+
+            # 5. Stdout banner — also visible in `hf jobs logs`.
             print(
                 "\n"
                 "================ CHECKPOINT SAVED ================\n"
@@ -569,16 +801,19 @@ class _WandbCheckpointCallback(TrainerCallback):
 
 
 def _build_grpo_config(config: TrainingConfig) -> GRPOConfig:
-    # NOTE on "train/loss → 0" — this is expected GRPO behaviour, not a bug.
-    # The scalar TRL logs as `train/loss` is *only* the KL-divergence term
-    # weighted by beta; the advantage-weighted policy-gradient term that
-    # actually drives learning contributes gradients but is not in the
-    # displayed loss. At step 0, policy == reference → KL = 0 → loss = 0.
-    # As the policy drifts, loss rises slightly (with beta=0.04 typically
-    # to ~0.001–0.05). The signal you care about is `train/rewards/*` and
-    # `train/reward`, not `train/loss`. See:
-    #   https://github.com/huggingface/trl/issues/2703
-    #   https://github.com/huggingface/open-r1/issues/239
+    # Note on the metrics this run will produce in W&B (per TRL docs):
+    #   train/loss     — the GRPO surrogate objective being minimized.
+    #                    = -E[advantage * logπ(action|state)] + β * KL.
+    #                    Should DECREASE as the policy exploits advantages.
+    #   train/reward   — mean total reward per rollout. Should INCREASE.
+    #   train/kl       — KL(policy || reference). Bounded by β; grows slowly.
+    #   rewards/<f>/mean — per-component reward (one per reward function).
+    #
+    # ``train/loss`` going to ~0 *only* if ``train/reward`` rises in lockstep
+    # is fine — it just means advantages got fully exploited. Loss collapsing
+    # without reward growth is reward hacking, broken parsing, or a saturated
+    # KL anchor. We surface both via _log_reward_summary at end of training
+    # AND via _GenerateCurvesCallback which renders both curves to PNG.
     effective_batch = (
         config.per_device_train_batch_size * config.gradient_accumulation_steps
     )

physix/training/sft.py

@@ -145,6 +145,8 @@ def train_sft(
     instances_per_system: int = 32,
     seed: int = 0,
     wandb_run_name: str | None = None,
+    hub_checkpoint_repo_id: str | None = None,
+    hub_token: str | None = None,
 ) -> None:
     _configure_logging()
 
@@ -251,6 +253,43 @@ def train_sft(
         save_method="merged_16bit",
     )
     _log.info("SFT model (merged 16-bit) saved → %s", out_path)
+
+    if hub_checkpoint_repo_id:
+        # Push the merged SFT model to the same checkpoint repo GRPO uses,
+        # under a fixed `sft/` subfolder. Re-runs overwrite the subfolder
+        # but produce a new commit, so the revision SHA still uniquely
+        # identifies *this* SFT result.
+        from physix.training.checkpoints import (
+            SFT_SUBFOLDER,
+            log_link_artifact_to_wandb,
+            push_checkpoint_to_hub,
+        )
+
+        try:
+            handle = push_checkpoint_to_hub(
+                local_dir=out_path,
+                repo_id=hub_checkpoint_repo_id,
+                subfolder=SFT_SUBFOLDER,
+                commit_message=(
+                    f"SFT merged_16bit: {model_name} | "
+                    f"epochs={epochs} lora_r={lora_r}"
+                ),
+                token=hub_token,
+            )
+            _log.info("SFT checkpoint pushed to Hub: %s", handle.hub_url)
+            wandb.run.summary["sft/hub_repo"] = handle.repo_id
+            wandb.run.summary["sft/hub_url"] = handle.hub_url
+            wandb.run.summary["sft/hub_revision"] = handle.revision
+            log_link_artifact_to_wandb(
+                handle,
+                artifact_name="physix-sft-checkpoint",
+                extra={"model_name": model_name, "epochs": epochs, "lora_r": lora_r},
+            )
+        except Exception as exc:  # noqa: BLE001
+            # Don't kill SFT just because the hub push failed; the GRPO step
+            # downstream can fall back to the local /tmp checkpoint.
+            _log.error("SFT hub push failed (non-fatal): %s", exc)
+
     wandb.finish()
 
 
@@ -274,6 +313,14 @@ def main() -> None:
     parser.add_argument("--seed", type=int, default=0)
     parser.add_argument("--wandb-run-name", default=None,
                         help="Override W&B run name. Defaults to physix-sft-{epochs}ep.")
+    parser.add_argument(
+        "--hub-checkpoint-repo-id",
+        default=None,
+        help=(
+            "If set, push the merged SFT model to <repo>/sft on the Hub "
+            "and log a pointer-only artifact to W&B."
+        ),
+    )
     args = parser.parse_args()
 
     os.environ.setdefault("WANDB_PROJECT", "physix-live")
@@ -286,6 +333,8 @@ def main() -> None:
         instances_per_system=args.instances_per_system,
         seed=args.seed,
         wandb_run_name=args.wandb_run_name,
+        hub_checkpoint_repo_id=args.hub_checkpoint_repo_id,
+        hub_token=os.environ.get("HF_TOKEN"),
     )
 
 

pyproject.toml

@@ -33,6 +33,11 @@ train = [
     "wandb>=0.16",
     "datasets>=3.0",
     "huggingface_hub>=0.24,<1.0",
+    # Used by physix.training.loop._render_training_curves to write
+    # loss / reward / per-component PNGs after GRPO training. Required so
+    # the run produces the repo-committable plots that the competition
+    # validator checks for.
+    "matplotlib>=3.7",
 ]
 demo = ["ollama>=0.4"]