Add _render_training_curves + matplotlib dep + plot deliverables in README

physix-live/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-live/docs/plots/README.md

@@ -0,0 +1,16 @@
+# Training Curves
+
+PNGs in this directory are auto-generated by
+`physix.training.loop._render_training_curves` at end of every GRPO run, then
+mirrored from the HF model repo via `physix-train/sync-plots.sh`.
+
+Files:
+
+- `loss.png`              — GRPO surrogate loss over training steps.
+- `reward.png`            — Mean reward (with ±1σ band) over training steps.
+- `reward_components.png` — Per-component reward (`match`, `match_dense`,
+                             `correctness`, `simplicity`, `format`).
+
+To regenerate locally after a job:
+
+    ./physix-train/sync-plots.sh Pratyush-01/physix-3b-rl

physix-live/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]:
@@ -569,16 +751,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-live/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"]