Log router health, WGAN grad-norm split, n_sec accuracy, GPU/throughput to W&B

Adds Router.gate_stats (per-router gate entropy + per-expert utilization),
logged both per-batch (entropy only, train loop) and per-epoch (full
stats, over the whole val set) — the router-collapse failure mode from
the roadmap's rollout postmortem is now visible during training instead
of only after a full rollout+analysis run. Also splits WGAN critic/
generator grad norms instead of summing them, logs critic LR, n_sec head
accuracy, GPU peak memory + samples/sec, model parameter counts (in
wandb.config), and an is_best flag — all wired into both metrics.csv and
W&B.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

giant/model/network.py

@@ -566,6 +566,30 @@ class Router(nn.Module):
         """
         return torch.zeros((), device=cond_cont.device)
 
+    def gate_stats(
+        self, cond_cont: torch.Tensor, cond_cat: torch.Tensor
+    ) -> tuple[torch.Tensor, torch.Tensor]:
+        """Diagnostics for catching a router that fails to specialize.
+
+        Returns `(norm_entropy, importance)`:
+          - `norm_entropy`: scalar, the batch-mean of each row's gate entropy
+            divided by `log(n_experts)`, in [0, 1] and comparable across
+            routers with different `n_experts` (1.0 = uniform/collapsed
+            gating, 0.0 = fully hard routing).
+          - `importance`: (n_experts,) tensor, `gate(...).sum(dim=0)` — the
+            *unnormalized* per-expert weight mass for this batch. Callers
+            wanting a global utilization share across many batches must sum
+            this across batches first and normalize once at the end;
+            averaging per-batch shares instead would treat every batch as
+            equally important regardless of size and understate a
+            rarely-but-fully-used expert.
+        """
+        gate = self.gate(cond_cont, cond_cat)  # (B, n_experts)
+        row_entropy = -(gate * (gate + 1e-8).log()).sum(dim=-1)  # (B,)
+        norm_entropy = row_entropy.mean() / math.log(self.n_experts)
+        importance = gate.sum(dim=0)  # (n_experts,)
+        return norm_entropy, importance
+
 
 ROUTER_REGISTRY: dict[str, type[Router]] = {}