add different routing types

myolmoe/modeling_myolmoe.py

@@ -452,46 +452,60 @@ class OlmoeSparseMoeBlock(nn.Module):
         self.num_experts = config.num_experts
         self.top_k = config.num_experts_per_tok
         self.norm_topk_prob = config.norm_topk_prob
+        self.routing_type = getattr(config, "routing_type", "topk")  # default to topk
+        self.n_step = getattr(config, "nth_step", 2)  # used in nth-descending
         self.gate = nn.Linear(config.hidden_size, self.num_experts, bias=False)
-        self.experts = nn.ModuleList(
-            [OlmoeMLP(config) for _ in range(self.num_experts)]
-        )
+        self.experts = nn.ModuleList([OlmoeMLP(config) for _ in range(self.num_experts)])
 
     def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
         batch_size, sequence_length, hidden_dim = hidden_states.shape
         hidden_states = hidden_states.view(-1, hidden_dim)
         router_logits = self.gate(hidden_states)
-        routing_weights = F.softmax(router_logits, dim=1, dtype=torch.float)
-        # routing_weights, selected_experts = torch.topk(
-        #     routing_weights, self.top_k, dim=-1
-        # )
-        selected_experts = torch.multinomial(routing_weights, self.top_k, replacement=False)
-        routing_weights = routing_weights.gather(1, selected_experts)
+        routing_probs = F.softmax(router_logits, dim=1, dtype=torch.float)
+
+        # === Routing strategy selection ===
+        if self.routing_type == "topk":
+            routing_weights, selected_experts = torch.topk(routing_probs, self.top_k, dim=-1)
+        elif self.routing_type == "multinomial":
+            selected_experts = torch.multinomial(routing_probs, self.top_k, replacement=False)
+            routing_weights = routing_probs.gather(1, selected_experts)
+        elif self.routing_type == "botk":
+            routing_weights, selected_experts = torch.topk(routing_probs, self.top_k, dim=-1, largest=False)
+        elif self.routing_type == "topk+botk":
+            top_weights, top_experts = torch.topk(routing_probs, self.top_k, dim=-1)
+            bot_weights, bot_experts = torch.topk(routing_probs, self.top_k, dim=-1, largest=False)
+            selected_experts = torch.cat([top_experts, bot_experts], dim=-1)
+            routing_weights = torch.cat([top_weights, bot_weights], dim=-1)
+        elif self.routing_type == "nth-descending":
+            # Sort all experts descending and pick every nth
+            sorted_weights, sorted_indices = torch.sort(routing_probs, dim=-1, descending=True)
+            selected_experts = sorted_indices[:, ::self.n_step][:, :self.top_k]
+            routing_weights = routing_probs.gather(1, selected_experts)
+        else:
+            raise ValueError(f"Unknown routing type: {self.routing_type}")
 
         if self.norm_topk_prob:
-            routing_weights /= routing_weights.sum(dim=-1, keepdim=True)
+            routing_weights = routing_weights / routing_weights.sum(dim=-1, keepdim=True)
+
         routing_weights = routing_weights.to(hidden_states.dtype)
         final_hidden_states = torch.zeros(
             (batch_size * sequence_length, hidden_dim),
             dtype=hidden_states.dtype,
             device=hidden_states.device,
         )
-        expert_mask = torch.nn.functional.one_hot(
-            selected_experts, num_classes=self.num_experts
-        ).permute(2, 1, 0)
+
+        expert_mask = torch.nn.functional.one_hot(selected_experts, num_classes=self.num_experts).permute(2, 1, 0)
+
         for expert_idx in range(self.num_experts):
             expert_layer = self.experts[expert_idx]
             idx, top_x = torch.where(expert_mask[expert_idx])
-            current_state = hidden_states[None, top_x].reshape(-1, hidden_dim)
-            current_hidden_states = (
-                expert_layer(current_state) * routing_weights[top_x, idx, None]
-            )
-            final_hidden_states.index_add_(
-                0, top_x, current_hidden_states.to(hidden_states.dtype)
-            )
-        final_hidden_states = final_hidden_states.reshape(
-            batch_size, sequence_length, hidden_dim
-        )
+            if top_x.numel() == 0:
+                continue
+            current_state = hidden_states[top_x]
+            current_hidden_states = expert_layer(current_state) * routing_weights[top_x, idx, None]
+            final_hidden_states.index_add_(0, top_x, current_hidden_states.to(hidden_states.dtype))
+
+        final_hidden_states = final_hidden_states.view(batch_size, sequence_length, hidden_dim)
         return final_hidden_states, router_logits
 
 

scripts/eval.py

@@ -80,8 +80,8 @@ Examples:
     parser.add_argument(
         "--routing_type", 
         type=str, 
-        default="sparse",
-        choices=["dense", "sparse", "non_deterministic"],
+        default="topk",
+        choices=["topk", "multinomial", "botk", "topk+botk", "nth-descending"],
         help="Routing type (only used with custom models)"
     )
     parser.add_argument(