training: add early-stop callback + lr=1e-5 for next run

physix/training/loop.py

@@ -97,6 +97,9 @@ class TrainingConfig(BaseModel):
     per_device_train_batch_size: int = 1
     gradient_accumulation_steps: int = 8
     num_steps: int = 300
+    #: Stop early if ``reward_std`` stays below 0.05 for this many consecutive
+    #: logged steps. Set to 0 to disable early stopping.
+    early_stop_patience: int = 50
     seed: int = 0
     instances_per_system: int = 32
     #: Subset of system IDs to train on. Defaults to all SUPPORTED_SYSTEMS.
@@ -176,6 +179,12 @@ def train(config: TrainingConfig) -> None:
     grpo_config = _build_grpo_config(config)
 
     callbacks = []
+    if config.early_stop_patience > 0:
+        callbacks.append(_RewardConvergenceCallback(patience=config.early_stop_patience))
+        _log.info(
+            "Early stopping enabled: will stop if reward_std < 0.05 for %d consecutive steps",
+            config.early_stop_patience,
+        )
     if config.hub_checkpoint_repo_id:
         callbacks.append(_WandbCheckpointCallback(config.hub_checkpoint_repo_id))
         _log.info(
@@ -610,6 +619,65 @@ def _select_reward_funcs(ablation: Optional[Ablation]) -> list[object]:
     )
 
 
+class _RewardConvergenceCallback(TrainerCallback):
+    """Stop training early when the GRPO reward has converged.
+
+    Convergence criterion: ``reward_std`` (std of total reward across the
+    rollout batch) stays below ``min_std`` for ``patience`` consecutive
+    logged steps.  When ``reward_std ≈ 0`` every generation scores the
+    same, so the GRPO advantage estimates are all zero and the policy
+    gradient vanishes — continuing burns compute without learning.
+
+    The callback also logs the early-stop event to W&B so the decision
+    is visible on the run page.
+    """
+
+    def __init__(self, patience: int = 50, min_std: float = 0.05) -> None:
+        self._patience = patience
+        self._min_std = min_std
+        self._flat_steps: int = 0
+
+    def on_log(
+        self,
+        args: HFTrainingArguments,
+        state: TrainerState,
+        control: TrainerControl,
+        logs: dict | None = None,
+        **kwargs,
+    ) -> None:
+        if not logs:
+            return
+        reward_std = logs.get("reward_std")
+        if reward_std is None:
+            return
+
+        if reward_std < self._min_std:
+            self._flat_steps += 1
+        else:
+            self._flat_steps = 0
+
+        if self._flat_steps >= self._patience:
+            step = state.global_step
+            msg = (
+                f"[early-stop] reward_std < {self._min_std} for "
+                f"{self._flat_steps} consecutive steps at step {step}. "
+                "Stopping training — policy has converged."
+            )
+            print(f"\n{msg}\n", flush=True)
+            _log.info(msg)
+            try:
+                import wandb
+                if wandb.run is not None:
+                    wandb.run.summary["early_stop/step"] = step
+                    wandb.run.summary["early_stop/reason"] = (
+                        f"reward_std < {self._min_std} for {self._flat_steps} steps"
+                    )
+                    wandb.log({"early_stop/triggered": 1}, step=step)
+            except Exception as exc:  # noqa: BLE001
+                _log.debug("Could not log early-stop event to W&B: %s", exc)
+            control.should_training_stop = True
+
+
 class _WandbCheckpointCallback(TrainerCallback):
     """Make checkpoints first-class in W&B.
 
@@ -962,6 +1030,16 @@ def _parse_args() -> TrainingConfig:
         default=None,
         help="Path to a Trainer checkpoint directory to resume GRPO from.",
     )
+    parser.add_argument(
+        "--early-stop-patience",
+        type=int,
+        default=50,
+        help=(
+            "Stop training early if reward_std stays below 0.05 for this many "
+            "consecutive steps (policy converged, GRPO advantage ≈ 0). "
+            "Set to 0 to disable."
+        ),
+    )
     parser.add_argument("--seed", type=int, default=0)
 
     args = parser.parse_args()
@@ -999,6 +1077,7 @@ def _parse_args() -> TrainingConfig:
         hub_repo_id=args.hub_repo_id,
         hub_checkpoint_repo_id=args.hub_checkpoint_repo_id,
         resume_from_checkpoint=args.resume_from_checkpoint,
+        early_stop_patience=args.early_stop_patience,
         seed=args.seed,
     )