File size: 1,936 Bytes
32da3e8 | 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 |
import os
import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel
from typing import Tuple
def setup_distributed() -> Tuple[int, int, torch.device]:
if "RANK" in os.environ and "WORLD_SIZE" in os.environ:
rank = int(os.environ["RANK"])
world_size = int(os.environ["WORLD_SIZE"])
dist.init_process_group(backend="nccl")
local_rank = int(os.environ.get("LOCAL_RANK", rank % torch.cuda.device_count()))
torch.cuda.set_device(local_rank)
device = torch.device("cuda", local_rank)
else:
rank = 0
world_size = 1
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
return rank, world_size, device
def cleanup_distributed():
if dist.is_initialized():
dist.destroy_process_group()
from contextlib import contextmanager
@contextmanager
def main_process_first(rank: int):
"""
Context manager that ensures main process (rank 0) runs first.
Useful for downloading models/data where only one process should download.
Usage:
with main_process_first(rank):
model = load_model() # rank 0 downloads, others wait then load from cache
"""
is_main = rank == 0
if not is_main and dist.is_initialized():
dist.barrier()
yield
if is_main and dist.is_initialized():
dist.barrier()
def synchronize_gradients(model: torch.nn.Module):
"""
In a distributed setting, to enable jvp, we need to call model.module instead of model directly.
If so, we synchronize gradients across all processes.
"""
if not isinstance(model, DistributedDataParallel):
return
torch.cuda.synchronize()
for param in model.module.parameters():
if param.requires_grad and param.grad is not None:
dist.all_reduce(param.grad, op=dist.ReduceOp.SUM)
param.grad /= dist.get_world_size()
|