loop.py: prominent W&B checkpoint logging (summary keys + table)

physix/training/loop.py

@@ -134,6 +134,28 @@ def train(config: TrainingConfig) -> None:
         resume="allow",
     )
 
+    # Pin a few high-signal pointers into the run summary right away so the
+    # W&B "Overview" tab shows them prominently (no scrolling, no hunting).
+    if config.hub_checkpoint_repo_id:
+        ckpt_url = f"https://huggingface.co/{config.hub_checkpoint_repo_id}"
+        wandb.run.summary["checkpoint/repo"] = config.hub_checkpoint_repo_id
+        wandb.run.summary["checkpoint/repo_url"] = ckpt_url
+    if config.hub_repo_id:
+        wandb.run.summary["model/final_repo"] = config.hub_repo_id
+        wandb.run.summary["model/final_url"] = (
+            f"https://huggingface.co/{config.hub_repo_id}"
+        )
+    if config.lora_adapter_repo:
+        wandb.run.summary["resume/from_adapter"] = config.lora_adapter_repo
+        wandb.run.summary["resume/from_url"] = (
+            f"https://huggingface.co/{config.lora_adapter_repo}"
+        )
+        print(
+            f"\n[wandb] RESUMED run — warm-started from "
+            f"https://huggingface.co/{config.lora_adapter_repo}\n",
+            flush=True,
+        )
+
     _log.info("Loading model %s with Unsloth (4-bit, LoRA-%d)", config.model_name, config.lora_r)
     model, tokenizer = _load_model_and_tokenizer(config)
     train_dataset = _build_and_format_dataset(config, tokenizer)
@@ -365,14 +387,64 @@ def _select_reward_funcs(ablation: Optional[Ablation]) -> list[object]:
 
 
 class _WandbCheckpointCallback(TrainerCallback):
-    """Logs a lightweight W&B artifact reference after each Trainer checkpoint.
-
-    The artifact does not re-upload model weights — it simply records the
-    HuggingFace Hub URL of the checkpoint so the W&B run links back to it.
+    """Make checkpoints first-class in W&B.
+
+    After every Trainer save, this callback:
+
+    1. Resolves the latest commit hash on the Hub repo (best-effort — the
+       trainer's own ``PushToHubCallback`` runs ``git push`` asynchronously
+       so we may briefly see an older commit; that is fine, it self-corrects
+       on the next save).
+    2. Updates the W&B run summary with persistent, prominent keys
+       (visible in the "Overview" tab of the run):
+         - ``checkpoint/last_step``
+         - ``checkpoint/last_commit``
+         - ``checkpoint/repo_url``
+         - ``checkpoint/last_url``
+    3. Logs a step-indexed scalar ``checkpoint/step`` so a chart appears
+       on the W&B run page (one tick per save).
+    4. Maintains a running ``checkpoint_history`` ``wandb.Table`` so every
+       saved checkpoint is browsable as a sortable table directly on the
+       run page (Tables tab).
+    5. Prints a banner to stdout (visible in ``hf jobs logs``) with the
+       direct URL — so the checkpoint is also impossible to miss in the
+       job logs.
+
+    No model bytes are uploaded to W&B; the actual weights live on the HF
+    Hub checkpoint repo. We never crash training if any of this fails.
     """
 
     def __init__(self, hub_checkpoint_repo_id: str) -> None:
         self._repo = hub_checkpoint_repo_id
+        self._repo_url = f"https://huggingface.co/{hub_checkpoint_repo_id}"
+        self._table = None  # lazy: wandb may not be initialised at __init__
+
+    def on_train_begin(
+        self,
+        args: HFTrainingArguments,
+        state: TrainerState,
+        control: TrainerControl,
+        **kwargs,
+    ) -> None:
+        # Pin the repo URL into the run config + summary at the very start
+        # so the link is visible on the W&B "Overview" panel from step 0.
+        try:
+            import wandb
+
+            if wandb.run is None:
+                return
+            wandb.run.summary["checkpoint/repo_url"] = self._repo_url
+            wandb.run.summary["checkpoint/repo"] = self._repo
+            wandb.config.update(
+                {"checkpoint_repo_url": self._repo_url, "checkpoint_repo": self._repo},
+                allow_val_change=True,
+            )
+            print(
+                f"\n[wandb] Checkpoint repo pinned in run summary: {self._repo_url}\n",
+                flush=True,
+            )
+        except Exception as exc:  # noqa: BLE001
+            _log.warning("Could not pin checkpoint repo to W&B summary: %s", exc)
 
     def on_save(
         self,
@@ -381,43 +453,81 @@ class _WandbCheckpointCallback(TrainerCallback):
         control: TrainerControl,
         **kwargs,
     ) -> None:
-        # The W&B artifact stores ONLY a URL reference back to the HF Hub
-        # checkpoint — no model bytes are uploaded to wandb. This is purely
-        # a convenience link in the W&B run page.
-        #
-        # Failure of this callback must NEVER crash training. The trainer's
-        # own PushToHubCallback runs the actual git push asynchronously, so
-        # at the instant `on_save` fires the Hub URL almost always 404s
-        # (push hasn't finished yet). We try once, swallow any error, and
-        # carry on. Loss of a wandb-side hyperlink is not a training bug.
         try:
             import wandb
 
             if wandb.run is None:
                 return
             step = state.global_step
-            artifact = wandb.Artifact(
-                name="grpo-checkpoint",
-                type="model",
-                metadata={"step": step, "hub_repo": self._repo},
+            commit_sha = self._latest_commit_sha()
+            short = (commit_sha or "pending")[:8]
+            tree_url = (
+                f"{self._repo_url}/tree/{commit_sha}"
+                if commit_sha
+                else f"{self._repo_url}/tree/main"
             )
-            artifact.add_reference(
-                f"https://huggingface.co/{self._repo}/tree/main/checkpoint-{step}"
+
+            # 1. Persistent summary keys (top-of-run, always visible).
+            wandb.run.summary["checkpoint/last_step"] = step
+            wandb.run.summary["checkpoint/last_commit"] = commit_sha or "pending"
+            wandb.run.summary["checkpoint/last_url"] = tree_url
+
+            # 2. Step-indexed scalar so a small chart appears on the run page.
+            wandb.log({"checkpoint/step": step}, step=step)
+
+            # 3. Running history table.
+            if self._table is None:
+                self._table = wandb.Table(
+                    columns=["step", "commit", "url", "repo"]
+                )
+            self._table.add_data(step, commit_sha or "pending", tree_url, self._repo)
+            # 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`.
+            print(
+                "\n"
+                "================ CHECKPOINT SAVED ================\n"
+                f"  step  : {step}\n"
+                f"  commit: {short}\n"
+                f"  url   : {tree_url}\n"
+                f"  repo  : {self._repo_url}\n"
+                "==================================================\n",
+                flush=True,
             )
-            wandb.log_artifact(artifact, aliases=[f"step-{step}", "latest"])
             _log.info(
-                "W&B artifact link logged for checkpoint-%d → %s", step, self._repo
+                "W&B checkpoint metadata logged: step=%d commit=%s",
+                step,
+                short,
             )
-        except Exception as exc:  # noqa: BLE001 — see comment above
+        except Exception as exc:  # noqa: BLE001
             _log.warning(
-                "W&B checkpoint-link callback skipped at step %d: %s. "
-                "Training continues; this only affects the wandb hyperlink, "
-                "the actual checkpoint is still pushed to the HF Hub by "
-                "the trainer's PushToHubCallback.",
+                "W&B checkpoint callback skipped at step %d: %s. "
+                "Training continues; the actual checkpoint is still pushed "
+                "to the HF Hub by the trainer's PushToHubCallback.",
                 state.global_step,
                 exc,
             )
 
+    def _latest_commit_sha(self) -> Optional[str]:
+        """Best-effort fetch of the most recent commit on the checkpoint repo.
+
+        Uses ``HfApi.list_repo_commits`` if available; returns ``None`` on
+        any failure. The async ``git push`` may not be done at the instant
+        ``on_save`` fires, so we may see the *previous* checkpoint's commit;
+        that's acceptable — it self-corrects on the next save.
+        """
+        try:
+            from huggingface_hub import HfApi
+
+            api = HfApi(token=os.environ.get("HUGGINGFACE_HUB_TOKEN"))
+            commits = api.list_repo_commits(repo_id=self._repo, repo_type="model")
+            if commits:
+                return commits[0].commit_id
+        except Exception as exc:  # noqa: BLE001
+            _log.debug("Could not fetch latest commit sha: %s", exc)
+        return None
+
 
 def _build_grpo_config(config: TrainingConfig) -> GRPOConfig:
     # NOTE on "train/loss → 0" — this is expected GRPO behaviour, not a bug.