|
import torch |
|
import torch.nn as nn |
|
import pickle |
|
import os |
|
import torch.nn.functional as F |
|
|
|
from mamba_config import MambaConfig |
|
from mlp import MLP |
|
|
|
def sinkhorn(cost, tol=0.0001): |
|
"Sinkhorn based MoE routing function" |
|
cost = torch.exp(2.0 * cost) |
|
d0 = torch.ones(cost.size(0), device=cost.device, dtype=cost.dtype) |
|
|
|
d1 = 1 / (cost.size(1) * torch.sum(cost, 0)) |
|
|
|
eps = 0.00000001 |
|
error = 1e9 |
|
d1_old = d1 |
|
while error > tol: |
|
d0 = (1 / d0.size(0)) * 1 / (torch.sum(d1 * cost, 1) + eps) |
|
d1 = (1 / d1.size(0)) * 1 / (torch.sum(d0.unsqueeze(1) * cost, 0) + eps) |
|
error = torch.mean(torch.abs(d1_old - d1)) |
|
d1_old = d1 |
|
return d1 * cost * d0.unsqueeze(1) |
|
|
|
|
|
class SwitchMLP(nn.Module): |
|
""" |
|
Top-1 Mixture of Experts Layer. Routes input to one of N MLP "experts" |
|
Curently supports Sinkhorn based expert routing. |
|
""" |
|
|
|
def __init__(self, config: MambaConfig, layer_idx=None): |
|
super().__init__() |
|
|
|
self.layer = layer_idx |
|
self.config: MambaConfig = config |
|
if config.mamba_moe_layers: |
|
self.num_moe_experts = int(config.mamba_moe_layers[layer_idx-1][-1]) |
|
else: |
|
self.num_moe_experts = self.config.num_moe_experts |
|
self.router = torch.nn.Linear(self.config.hidden_size, self.num_moe_experts) |
|
self.add_bias = config.add_bias_linear |
|
self.routing = config.routing_mode |
|
self.route_algo = sinkhorn |
|
self.router_activation = torch.sigmoid |
|
|
|
self.num_local_experts = self.num_moe_experts |
|
self.local_expert_indices = [i for i in range(self.num_local_experts)] |
|
|
|
self.local_experts = torch.nn.ModuleList() |
|
for _ in range(self.num_local_experts): |
|
expert = MLP(self.config, is_expert=True, layer_idx=layer_idx) |
|
self.local_experts.append(expert) |
|
|
|
def gather_indices(self, local_indices): |
|
return local_indices |
|
|
|
def forward(self, hidden_states, inference_params=None): |
|
|
|
hidden_shape = hidden_states.shape |
|
route = self.router(hidden_states) |
|
route = route.view(-1, self.num_moe_experts) |
|
|
|
if self.routing == 'sinkhorn': |
|
route = self.router_activation(route) |
|
max_prob, max_ind = torch.max(route, dim=1) |
|
else: |
|
route = torch.softmax(route, dim=1) |
|
max_prob, max_ind = torch.max(route, dim=1) |
|
|
|
max_prob = torch.unsqueeze(max_prob, 1) |
|
hidden_states = hidden_states.view(-1, hidden_shape[-1]) |
|
|
|
global_hidden_states = hidden_states |
|
global_indices = max_ind |
|
output_total = torch.zeros_like(global_hidden_states) |
|
|
|
|
|
for expert_num, expert in enumerate(self.local_experts): |
|
local_expert_index = self.local_expert_indices[expert_num] |
|
local_indices = (global_indices == local_expert_index).nonzero() |
|
hidden = global_hidden_states[local_indices, :] |
|
output = expert(hidden) |
|
output_total[local_indices, :] = output |
|
|
|
output_total = output_total * max_prob |
|
output_total = output_total.view(hidden_shape) |
|
|
|
return output_total |
|
|
