File size: 5,135 Bytes
6e1294c |
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 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 |
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0
# DeepSpeed Team
from collections import defaultdict
from typing import Any, Dict, List, Set, Tuple, Union, cast
import torch
from torch import nn
from .layer import MoE
def has_moe_layers(m: nn.Module) -> Tuple[bool, int]:
has_moe = False
num_experts = 0
for module in m.modules():
if isinstance(module, MoE):
has_moe = True
num_experts = module.num_experts
break
return has_moe, num_experts
def is_moe_param(param: torch.Tensor) -> bool:
if hasattr(param, "allreduce") and not param.allreduce:
return True
return False
def split_params_into_shared_and_expert_params(
params: List[torch.nn.Parameter]) -> Tuple[List[torch.nn.Parameter], List[torch.nn.Parameter]]:
shared_params: List[nn.Parameter] = []
expert_params: List[nn.Parameter] = []
for p in params:
if is_moe_param(p):
expert_params.append(p)
else:
shared_params.append(p)
return shared_params, expert_params
def split_params_grads_into_shared_and_expert_params(
group: List[torch.nn.Parameter]) -> Tuple[List[torch.Tensor], List[torch.Tensor]]:
"""Split grad of parameters into grads of non-expert params
and grads of expert params. This is useful while computing
grad-norms for clipping and overflow detection
group (List[torch.nn.Parameter]):
Args:
The group of parameters to split
Returns:
Tuple[List[torch.Tensor], List[torch.Tensor]]:
list of gradients for non MoE params, list of gradients of MoE params
"""
expert_grads: List[torch.Tensor] = []
shared_grads: List[torch.Tensor] = []
for p in group:
if p.grad is not None:
if is_moe_param(p):
expert_grads.append(p.grad.to(p.dtype))
else:
shared_grads.append(p.grad.to(p.dtype))
return shared_grads, expert_grads
def split_params_into_different_moe_groups_for_optimizer(
param_groups: Union[Dict[str, Any], Tuple[Dict[str, Any], ...], List[Dict[str, Any]]],
max_group_size: Union[int, float] = 178956971) -> List[Dict[str, Any]]:
"""Split parameters into different MoE groups for optimizer
Args:
param_groups (Union[Dict[str, Any], Tuple[Dict[str, Any], ...], List[Dict[str, Any]]])
The list of parameter groups to split
Returns:
List[Dict[str, Any]]:
list of MoE/non-MoE groups for optimizer
"""
if isinstance(param_groups, tuple):
param_groups = list(param_groups) # Tuple cannot be modified
elif isinstance(param_groups, dict):
param_groups = [param_groups]
elif not isinstance(param_groups, list):
raise ValueError(f"Unknown param group type of {type(param_groups)}")
# gather all data parallel group names
data_parallel_group_names: Set[str] = set()
for param_group in param_groups:
for param in cast(List[nn.Parameter], param_group["params"]):
if is_moe_param(param):
data_parallel_group_names.add(param.group_name)
# Create the param MoE groups, leave param assign to next step
group_moe: Dict[str, Dict[str, Dict[str, Any]]] = defaultdict(lambda: defaultdict(dict))
for param_group in param_groups:
for key in data_parallel_group_names:
group_moe[param_group['name']][key] = {
**param_group,
'name': key,
'moe': True,
'params': [],
}
# Assign param
for param_group in param_groups:
new_params: List[nn.Parameter] = []
for param in cast(List[nn.Parameter], param_group['params']):
if is_moe_param(param):
group_moe[param_group['name']][param.group_name]['params'].append(param)
else:
new_params.append(param)
param_group['params'] = new_params
# Flatten the moe groups
if max_group_size is not None:
for moe_group in group_moe.values():
for param_group in moe_group.values():
cur_group: List[nn.Parameter] = []
all_groups: List[List[nn.Parameter]] = []
size_of_cur_group = 0
for param in cast(List[nn.Parameter], param_group['params']):
if size_of_cur_group + param.numel() <= max_group_size:
cur_group.append(param)
size_of_cur_group += param.numel()
else:
all_groups.append(cur_group)
cur_group = [param]
size_of_cur_group = param.numel()
if cur_group:
all_groups.append(cur_group)
for group in all_groups:
param_groups.append({**param_group, 'params': group})
else:
for moe_group in group_moe.values():
for param_group in moe_group.values():
param_groups.append(param_group)
return param_groups
|