Datasets:
File size: 3,397 Bytes
453129d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | from typing import List, Optional, Union
import torch
import torch.distributed as dist
def _sort_chunks_by_idxs(
input: torch.Tensor,
split_sizes: Union[torch.Tensor, List[int]],
sorted_idxs: List[int],
) -> torch.Tensor:
if isinstance(split_sizes, torch.Tensor):
split_sizes = split_sizes.tolist()
chunks = torch.split(input, split_sizes, dim=0)
return torch.cat([chunks[i] for i in sorted_idxs], dim=0)
def _all_to_all_forward(
group: dist.ProcessGroup,
input: torch.Tensor,
output_split_sizes: Optional[List[int]],
input_split_sizes: Optional[List[int]],
) -> torch.Tensor:
if dist.get_world_size(group) == 1:
return input.contiguous()
input = input.contiguous()
out_size = sum(output_split_sizes) if output_split_sizes else input.size(0)
output = torch.empty((out_size, input.size(1)), dtype=input.dtype, device=input.device)
dist.all_to_all_single(
output, input,
output_split_sizes=output_split_sizes,
input_split_sizes=input_split_sizes,
group=group,
)
return output
def _generate_weights_idx(
routing_weights: torch.Tensor,
selected_experts: torch.Tensor,
num_experts: int,
) -> torch.Tensor:
num_tokens, topk = routing_weights.shape
weights_idx = torch.zeros(
(num_tokens, num_experts), dtype=routing_weights.dtype, device=routing_weights.device
)
weights_idx.scatter_add_(1, selected_experts, routing_weights)
return weights_idx
def _unpermute(
tokens: torch.Tensor,
routing_weights: torch.Tensor,
hidden_states_shape: torch.Size,
permutation_mapping: torch.Tensor,
routing_map: torch.Tensor,
) -> torch.Tensor:
tokens_weight = routing_weights.T.contiguous().masked_select(routing_map.bool())
tokens = tokens * tokens_weight.unsqueeze(-1)
hidden_dim = hidden_states_shape[-1]
unpermuted_tokens = torch.zeros(hidden_states_shape, device=tokens.device, dtype=tokens.dtype)
expanded_mapping = permutation_mapping.unsqueeze(1).expand(-1, hidden_dim)
unpermuted_tokens.scatter_add_(0, expanded_mapping, tokens)
return unpermuted_tokens
def solution(
expert_outputs: torch.Tensor,
routing_weights: torch.Tensor,
selected_experts: torch.Tensor,
num_experts: int,
input_splits: Union[List[int], torch.Tensor],
output_splits: Union[List[int], torch.Tensor],
num_global_tokens_per_local_expert: torch.Tensor,
routing_map: torch.Tensor,
local_input_permutation_mapping: torch.Tensor,
org_hidden_states_shape: torch.Size,
group: Optional[dist.ProcessGroup] = None,
) -> torch.Tensor:
group = group or dist.group.WORLD
num_local_experts = num_experts // dist.get_world_size(group)
unpermute_order = torch.arange(num_experts).reshape(num_local_experts, -1).T.ravel().tolist()
expert_outputs = _sort_chunks_by_idxs(
expert_outputs,
num_global_tokens_per_local_expert.T.ravel(),
unpermute_order,
)
unpermute_outputs = _all_to_all_forward(group, expert_outputs, input_splits, output_splits)
weights_idx = _generate_weights_idx(routing_weights, selected_experts, num_experts)
unpermute_outputs = _unpermute(
unpermute_outputs,
weights_idx,
org_hidden_states_shape,
local_input_permutation_mapping,
routing_map,
)
return unpermute_outputs
|