| from typing import List, Optional |
|
|
| import torch |
| import torch.distributed as dist |
|
|
|
|
| def _local_pth_sum(grad_tensors: List[torch.Tensor], p: float) -> torch.Tensor: |
| dev = None |
| acc = None |
| for g in grad_tensors: |
| if g is None: |
| continue |
| g_local = g |
| if dev is None: |
| dev = g_local.device |
| acc = torch.tensor(0.0, device=dev, dtype=torch.float32) |
| gn = torch.norm(g_local.detach().to(torch.float32), p=p) |
| acc = acc + (gn ** p) |
| if acc is None: |
| acc = torch.tensor( |
| 0.0, |
| device=next((t.device for t in grad_tensors if t is not None), torch.device("cuda", 0)), |
| dtype=torch.float32, |
| ) |
| return acc |
|
|
|
|
| def _fsdp2_reduce_group( |
| grad_tensors: List[torch.Tensor], |
| norm_type: float, |
| reduce_groups: List[tuple], |
| ) -> torch.Tensor: |
| p = float(norm_type) |
| val = _local_pth_sum(grad_tensors, p) |
| for _, group in reduce_groups: |
| if group is not None: |
| dist.all_reduce(val, op=dist.ReduceOp.SUM, group=group) |
| return val |
|
|
|
|
| def solution( |
| non_ep_grad_tensors: List[torch.Tensor], |
| ep_grad_tensors: List[torch.Tensor], |
| max_norm: float, |
| norm_type: float = 2.0, |
| ep_size: int = 1, |
| fsdp_group: Optional[dist.ProcessGroup] = None, |
| ep_fsdp_group: Optional[dist.ProcessGroup] = None, |
| ep_group: Optional[dist.ProcessGroup] = None, |
| ) -> torch.Tensor: |
| if ep_size > 1 and ep_grad_tensors: |
| scale = 1.0 / float(ep_size) |
| for t in ep_grad_tensors: |
| if t is not None: |
| t.detach().mul_(scale) |
|
|
| non_ep_total = _fsdp2_reduce_group( |
| non_ep_grad_tensors, |
| norm_type=norm_type, |
| reduce_groups=[("fsdp", fsdp_group)], |
| ) |
|
|
| ep_total = _fsdp2_reduce_group( |
| ep_grad_tensors, |
| norm_type=norm_type, |
| reduce_groups=[("ep_fsdp", ep_fsdp_group), ("ep", ep_group)], |
| ) |
|
|
| total_norm = (non_ep_total + ep_total) ** (1.0 / float(norm_type)) |
|
|
| if total_norm > max_norm: |
| coef = (max_norm / total_norm) |
| for t in non_ep_grad_tensors: |
| if t is not None: |
| t.mul_(coef.to(t.device)) |
| for t in ep_grad_tensors: |
| if t is not None: |
| t.mul_(coef.to(t.device)) |
|
|
| return total_norm |
|
|
