Publish credential-free structural-smoke runner

config/benching/fable-router-training-campaign.v1.json

@@ -78,6 +78,7 @@
     "microBatch": 1,
     "gradientLossScale": 1024,
     "gradientCheckpointing": true,
+    "checkpointExpertResiduals": true,
     "expertResidency": "cpu_offload_active_experts",
     "minimumFreeDiskGiB": 18,
     "privateResultRepo": "Swordnael/LFM2.5-Fable-Router-Smoke-Evidence",

training/fable_router_hybrid.py

@@ -16,6 +16,7 @@ from typing import Any, Iterator
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
+from torch.utils.checkpoint import checkpoint
 
 
 PROJECTIONS = ("gate_proj", "up_proj", "down_proj")
@@ -124,6 +125,7 @@ class FrozenExpertRouterBlock(nn.Module):
         self.top_k = top_k
         self.maximum_scale = float(maximum_scale)
         self.enabled = True
+        self.checkpoint_enabled = False
         self._forced_expert: int | None = None
         self._forced_scale: float | None = None
         self.last_trace: RouteTrace | None = None
@@ -232,6 +234,13 @@ class AugmentedHostLayer(nn.Module):
         output = self.host_layer(hidden_states, *args, **kwargs)
         if not isinstance(output, torch.Tensor):
             raise TypeError(f"unsupported LFM2 layer output type: {type(output)!r}")
+        if self.expert_block.checkpoint_enabled and self.training and torch.is_grad_enabled():
+            return checkpoint(
+                self.expert_block,
+                output,
+                use_reentrant=False,
+                preserve_rng_state=False,
+            )
         return self.expert_block(output)
 
 

training/run_fable_router_full_bank_fit.py

@@ -211,6 +211,7 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
         )
         block.materialize_experts(bank_path, layer, device=expert_device, dtype=dtype)
         block.load_router_warmstart(warm_state[f"layers.{layer}.router.gate.weight"])
+        block.checkpoint_enabled = bool(admission.get("checkpointExpertResiduals", False))
         block.enabled = False
         blocks.append(block)
         print(f"materialized frozen bank layer {layer + 1}/{admission['layers']} on {expert_device}", flush=True)
@@ -230,6 +231,7 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
         raise RuntimeError(f"expected 60 router parameters, found {len(names)}")
     for block in blocks:
         block.enabled = True
+    model.train()
     model.zero_grad(set_to_none=True)
     output = model(**batch, use_cache=False)
     scale = float(admission["gradientLossScale"])
@@ -253,6 +255,7 @@ def run(args: argparse.Namespace, result: dict[str, Any]) -> None:
     destination = Path(result["output"]) / "router-checkpoint.safetensors"
     saved = router_state_dict(model)
     save_file(saved, str(destination), metadata={"autonoma": "non-routing-full-bank-admission"})
+    model.eval()
     with torch.inference_mode():
         before = model(input_ids=batch["input_ids"], attention_mask=batch["attention_mask"], use_cache=False).logits.detach().cpu()
     with torch.no_grad():