Keep structural-smoke router gradients in FP32

fable-router-cloud-smoke.v1.json

@@ -81,6 +81,7 @@
     "benefitMarginNats": 0.0,
     "initialExpertScale": 0.005,
     "maximumExpertScale": 0.025,
+    "gradientLossScale": 1024,
     "minimumFreeDiskGiBBeforeBankDownload": 12,
     "minimumGpuVramGiB": 14,
     "resultRepo": "Swordnael/LFM2.5-Fable-Router-Smoke-Evidence",

training/fable_router_hybrid.py

@@ -58,7 +58,11 @@ class ExplicitOffRouter(nn.Module):
         self.num_experts = num_experts
 
     def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
-        expert_logits = self.gate(hidden_states)
+        # Router and scale are the only trainable parameters.  Keep their
+        # master precision at FP32 even when the frozen host and experts run in
+        # FP16; casting this tiny trainable gate to FP16 caused its task-loss
+        # gradient to underflow to exactly zero on T4.
+        expert_logits = self.gate(hidden_states.to(self.gate.weight.dtype))
         off_logits = torch.zeros(
             (*expert_logits.shape[:-1], 1),
             dtype=expert_logits.dtype,

training/run_fable_router_structural_smoke.py

@@ -276,7 +276,7 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
         maximum_scale=float(smoke["maximumExpertScale"]),
     )
     wrapper = attach_router_block(model, layer, block)
-    block.router.to(device=device, dtype=dtype)
+    block.router.to(device=device, dtype=torch.float32)
     block.expert_scale.data = block.expert_scale.data.to(device=device)
     block.materialize_experts(bank_path, layer, device=device, dtype=dtype)
     warm_tensors = load_file(str(warmstart), device="cpu")
@@ -302,18 +302,29 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     block.enabled = True
     model.zero_grad(set_to_none=True)
     gradient_output = model(**batch, use_cache=False)
-    gradient_output.loss.backward()
+    gradient_loss_scale = float(smoke["gradientLossScale"])
+    (gradient_output.loss * gradient_loss_scale).backward()
     router_gradient = block.router.gate.weight.grad
     scale_gradient = block.expert_scale.grad
     gradient_gate = {
         "routerFinite": bool(router_gradient is not None and torch.isfinite(router_gradient).all()),
-        "routerL1": float(router_gradient.float().abs().sum()) if router_gradient is not None else 0.0,
+        "routerL1Scaled": float(router_gradient.float().abs().sum()) if router_gradient is not None else 0.0,
+        "routerL1Unscaled": (
+            float(router_gradient.float().abs().sum() / gradient_loss_scale)
+            if router_gradient is not None else 0.0
+        ),
         "scaleFinite": bool(scale_gradient is not None and torch.isfinite(scale_gradient).all()),
-        "scaleAbsolute": float(scale_gradient.float().abs()) if scale_gradient is not None else 0.0,
+        "scaleAbsoluteScaled": float(scale_gradient.float().abs()) if scale_gradient is not None else 0.0,
+        "scaleAbsoluteUnscaled": (
+            float(scale_gradient.float().abs() / gradient_loss_scale)
+            if scale_gradient is not None else 0.0
+        ),
+        "lossScale": gradient_loss_scale,
+        "routerDtype": str(block.router.gate.weight.dtype),
     }
     result["gradientGate"] = gradient_gate
     if not all((gradient_gate["routerFinite"], gradient_gate["scaleFinite"])) or min(
-        gradient_gate["routerL1"], gradient_gate["scaleAbsolute"]
+        gradient_gate["routerL1Scaled"], gradient_gate["scaleAbsoluteScaled"]
     ) <= 0:
         raise RuntimeError(f"router gradient gate failed: {gradient_gate}")
 
@@ -461,7 +472,7 @@ def main() -> int:
             {
                 "peak_vram_mib": result["runtime"]["peakAllocatedVramMiB"],
                 "positive_oracle_tokens": result["counterfactualDiscovery"]["positiveBenefitTokens"],
-                "router_gradient_l1": result["gradientGate"]["routerL1"],
+                "router_gradient_l1_unscaled": result["gradientGate"]["routerL1Unscaled"],
             }
         )
     except BaseException as exc: