Add frozen-host router shell

training/fable_router_hybrid.py

@@ -0,0 +1,304 @@
+"""Trainable router shell for the frozen Fable host and frozen donor experts.
+
+The production campaign keeps host and expert tensors immutable.  This module
+adds an explicit host-only route, a bounded expert residual, deterministic
+forced routes for counterfactual discovery, and state helpers for the small
+router-only checkpoints.
+"""
+from __future__ import annotations
+
+import contextlib
+import math
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterator
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+
+PROJECTIONS = ("gate_proj", "up_proj", "down_proj")
+
+
+def inverse_softplus(value: float) -> float:
+    if value <= 0:
+        raise ValueError("softplus target must be positive")
+    return math.log(math.expm1(value))
+
+
+class FrozenSwiGLUExpert(nn.Module):
+    def __init__(self, hidden_size: int = 2048, intermediate_size: int = 512):
+        super().__init__()
+        self.gate_proj = nn.Linear(hidden_size, intermediate_size, bias=False, device="meta")
+        self.up_proj = nn.Linear(hidden_size, intermediate_size, bias=False, device="meta")
+        self.down_proj = nn.Linear(intermediate_size, hidden_size, bias=False, device="meta")
+
+    def materialize(self, weights: dict[str, torch.Tensor], device: torch.device, dtype: torch.dtype) -> None:
+        for name in PROJECTIONS:
+            tensor = weights[f"{name}.weight"].to(device=device, dtype=dtype, non_blocking=True)
+            module = getattr(self, name)
+            module.weight = nn.Parameter(tensor, requires_grad=False)
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        return self.down_proj(F.silu(self.gate_proj(hidden_states)) * self.up_proj(hidden_states))
+
+
+class ExplicitOffRouter(nn.Module):
+    """Expert logits plus a fixed zero-logit host-only class.
+
+    The off class is explicit in the classification/ranking objective but adds
+    no new trainable parameter beyond the frozen contract's router gate.
+    """
+
+    def __init__(self, hidden_size: int, num_experts: int):
+        super().__init__()
+        self.gate = nn.Linear(hidden_size, num_experts, bias=False)
+        nn.init.normal_(self.gate.weight, mean=0.0, std=0.01)
+        self.num_experts = num_experts
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        expert_logits = self.gate(hidden_states)
+        off_logits = torch.zeros(
+            (*expert_logits.shape[:-1], 1),
+            dtype=expert_logits.dtype,
+            device=expert_logits.device,
+        )
+        return torch.cat((expert_logits, off_logits), dim=-1)
+
+
+@dataclass
+class RouteTrace:
+    logits: torch.Tensor
+    selected_experts: torch.Tensor
+    selected_weights: torch.Tensor
+    off_probability: torch.Tensor
+    active_scale: torch.Tensor
+
+
+class FrozenExpertRouterBlock(nn.Module):
+    """A sparse, bounded residual over one frozen host layer output."""
+
+    def __init__(
+        self,
+        expert_ids: list[int],
+        *,
+        hidden_size: int = 2048,
+        intermediate_size: int = 512,
+        top_k: int = 2,
+        initial_scale: float = 0.005,
+        maximum_scale: float = 0.1,
+    ):
+        super().__init__()
+        if len(expert_ids) != 32 or len(set(expert_ids)) != 32:
+            raise ValueError("a frozen bank layer must contain 32 unique experts")
+        if not 1 <= top_k <= len(expert_ids):
+            raise ValueError("top_k is outside the expert bank")
+        self.expert_ids = tuple(int(item) for item in expert_ids)
+        self.router = ExplicitOffRouter(hidden_size, len(expert_ids))
+        self.experts = nn.ModuleList(
+            FrozenSwiGLUExpert(hidden_size, intermediate_size) for _ in expert_ids
+        )
+        self.expert_scale = nn.Parameter(torch.tensor(inverse_softplus(initial_scale)))
+        self.top_k = top_k
+        self.maximum_scale = float(maximum_scale)
+        self.enabled = True
+        self._forced_expert: int | None = None
+        self._forced_scale: float | None = None
+        self.last_trace: RouteTrace | None = None
+
+    @property
+    def off_class_index(self) -> int:
+        return len(self.expert_ids)
+
+    @contextlib.contextmanager
+    def forced_route(self, local_expert: int | None, scale: float = 0.025) -> Iterator[None]:
+        if local_expert is not None and not 0 <= local_expert < len(self.expert_ids):
+            raise ValueError("forced expert index is outside the local bank")
+        old_expert, old_scale = self._forced_expert, self._forced_scale
+        self._forced_expert, self._forced_scale = local_expert, float(scale)
+        try:
+            yield
+        finally:
+            self._forced_expert, self._forced_scale = old_expert, old_scale
+
+    def load_router_warmstart(self, weight: torch.Tensor) -> None:
+        if tuple(weight.shape) != tuple(self.router.gate.weight.shape):
+            raise ValueError(
+                f"router warm-start shape {tuple(weight.shape)} does not match "
+                f"{tuple(self.router.gate.weight.shape)}"
+            )
+        with torch.no_grad():
+            self.router.gate.weight.copy_(weight.to(self.router.gate.weight))
+
+    def materialize_experts(
+        self,
+        bank_path: Path,
+        layer: int,
+        *,
+        device: torch.device,
+        dtype: torch.dtype,
+    ) -> None:
+        from safetensors import safe_open
+
+        with safe_open(str(bank_path), framework="pt", device="cpu") as bank:
+            for local_index, global_expert in enumerate(self.expert_ids):
+                prefix = f"model.layers.{layer}.mlp.experts.{global_expert}"
+                weights = {
+                    f"{projection}.weight": bank.get_tensor(f"{prefix}.{projection}.weight")
+                    for projection in PROJECTIONS
+                }
+                self.experts[local_index].materialize(weights, device, dtype)
+        for parameter in self.experts.parameters():
+            parameter.requires_grad_(False)
+
+    def _expert_output(
+        self,
+        flat: torch.Tensor,
+        selected: torch.Tensor,
+        weights: torch.Tensor,
+    ) -> torch.Tensor:
+        output = torch.zeros_like(flat)
+        detached = flat.detach()
+        for local_index, expert in enumerate(self.experts):
+            positions = (selected == local_index).nonzero(as_tuple=False)
+            if positions.numel() == 0:
+                continue
+            token_indices, rank_indices = positions.unbind(dim=1)
+            expert_values = expert(detached.index_select(0, token_indices)).detach()
+            weighted = expert_values * weights[token_indices, rank_indices].unsqueeze(-1)
+            output = output.index_add(0, token_indices, weighted)
+        return output
+
+    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
+        if not self.enabled:
+            self.last_trace = None
+            return hidden_states
+        original_shape = hidden_states.shape
+        flat = hidden_states.reshape(-1, original_shape[-1])
+        logits = self.router(flat)
+
+        if self._forced_expert is not None:
+            selected = torch.full(
+                (flat.shape[0], 1), self._forced_expert, dtype=torch.long, device=flat.device
+            )
+            weights = torch.ones((flat.shape[0], 1), dtype=flat.dtype, device=flat.device)
+            off_probability = torch.zeros(flat.shape[0], dtype=flat.dtype, device=flat.device)
+            scale = torch.as_tensor(self._forced_scale, dtype=flat.dtype, device=flat.device)
+        else:
+            probabilities = torch.softmax(logits.float(), dim=-1).to(flat.dtype)
+            expert_probabilities = probabilities[:, :-1]
+            weights, selected = expert_probabilities.topk(self.top_k, dim=-1)
+            off_probability = probabilities[:, -1]
+            scale = torch.clamp(F.softplus(self.expert_scale), max=self.maximum_scale).to(flat.dtype)
+
+        expert_output = self._expert_output(flat, selected, weights)
+        host_std = flat.float().std().detach().clamp_min(1e-6)
+        expert_std = expert_output.float().std().detach().clamp_min(1e-6)
+        expert_output = expert_output * torch.clamp(host_std / expert_std, max=2.0).to(flat.dtype)
+        self.last_trace = RouteTrace(logits, selected, weights, off_probability, scale)
+        return hidden_states + (scale * expert_output).reshape(original_shape)
+
+
+class AugmentedHostLayer(nn.Module):
+    def __init__(self, host_layer: nn.Module, expert_block: FrozenExpertRouterBlock):
+        super().__init__()
+        self.host_layer = host_layer
+        self.expert_block = expert_block
+        self.is_attention_layer = getattr(host_layer, "is_attention_layer", False)
+
+    def forward(self, hidden_states: torch.Tensor, *args: Any, **kwargs: Any) -> torch.Tensor:
+        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}")
+        return self.expert_block(output)
+
+
+def attach_router_block(model: nn.Module, layer: int, block: FrozenExpertRouterBlock) -> AugmentedHostLayer:
+    layers = model.model.layers
+    if not 0 <= layer < len(layers):
+        raise ValueError(f"layer {layer} outside host model with {len(layers)} layers")
+    wrapper = AugmentedHostLayer(layers[layer], block)
+    layers[layer] = wrapper
+    return wrapper
+
+
+def freeze_except_routers(model: nn.Module) -> dict[str, int]:
+    counts = {"hostAndExperts": 0, "router": 0, "expertScale": 0, "trainable": 0}
+    for name, parameter in model.named_parameters():
+        if ".expert_block.router.gate.weight" in name:
+            parameter.requires_grad_(True)
+            counts["router"] += parameter.numel()
+        elif name.endswith(".expert_block.expert_scale"):
+            parameter.requires_grad_(True)
+            counts["expertScale"] += parameter.numel()
+        else:
+            parameter.requires_grad_(False)
+            counts["hostAndExperts"] += parameter.numel()
+        if parameter.requires_grad:
+            counts["trainable"] += parameter.numel()
+    assert_trainable_isolation(model)
+    return counts
+
+
+def assert_trainable_isolation(model: nn.Module) -> list[str]:
+    names = [name for name, parameter in model.named_parameters() if parameter.requires_grad]
+    invalid = [
+        name
+        for name in names
+        if ".expert_block.router.gate.weight" not in name
+        and not name.endswith(".expert_block.expert_scale")
+    ]
+    if invalid:
+        raise RuntimeError(f"trainable-parameter isolation failed: {invalid[:5]}")
+    if not names:
+        raise RuntimeError("trainable-parameter isolation found no router parameters")
+    return names
+
+
+def router_state_dict(model: nn.Module) -> dict[str, torch.Tensor]:
+    return {
+        name: tensor.detach().cpu().contiguous()
+        for name, tensor in model.state_dict().items()
+        if ".expert_block.router.gate.weight" in name
+        or name.endswith(".expert_block.expert_scale")
+    }
+
+
+def load_router_state_dict(model: nn.Module, state: dict[str, torch.Tensor]) -> None:
+    expected = set(router_state_dict(model))
+    if set(state) != expected:
+        raise RuntimeError(
+            f"router checkpoint identity mismatch: missing={sorted(expected-set(state))}, "
+            f"extra={sorted(set(state)-expected)}"
+        )
+    current = model.state_dict()
+    for name, tensor in state.items():
+        current[name].copy_(tensor.to(current[name]))
+
+
+def benefit_targets(host_nll: torch.Tensor, candidate_nll: torch.Tensor, margin: float) -> torch.Tensor:
+    """Return the best expert index, or the explicit off class if none earns its cost.
+
+    ``candidate_nll`` is shaped ``[tokens, candidates]`` and must contain
+    exact detached counterfactual losses generated outside the served path.
+    """
+    if host_nll.ndim != 1 or candidate_nll.ndim != 2 or candidate_nll.shape[0] != host_nll.shape[0]:
+        raise ValueError("counterfactual NLL shapes are incompatible")
+    best_nll, best_index = candidate_nll.min(dim=-1)
+    off_index = candidate_nll.shape[-1]
+    off = torch.full_like(best_index, off_index)
+    return torch.where(best_nll + margin < host_nll, best_index, off)
+
+
+def benefit_weighted_router_loss(
+    logits: torch.Tensor,
+    targets: torch.Tensor,
+    host_nll: torch.Tensor,
+    candidate_nll: torch.Tensor,
+) -> torch.Tensor:
+    best_nll = candidate_nll.min(dim=-1).values
+    benefit = (host_nll - best_nll).clamp_min(0).detach()
+    weights = torch.where(targets == logits.shape[-1] - 1, torch.ones_like(benefit), 1 + benefit)
+    return (F.cross_entropy(logits.float(), targets, reduction="none") * weights.float()).mean()
+