| import torch |
| import math |
| import numpy as np |
|
|
| class SequentialDistributedSampler(torch.utils.data.sampler.Sampler): |
| """ |
| Distributed Sampler that subsamples indicies sequentially, |
| making it easier to collate all results at the end. |
| Even though we only use this sampler for eval and predict (no training), |
| which means that the model params won't have to be synced (i.e. will not hang |
| for synchronization even if varied number of forward passes), we still add extra |
| samples to the sampler to make it evenly divisible (like in `DistributedSampler`) |
| to make it easy to `gather` or `reduce` resulting tensors at the end of the loop. |
| """ |
|
|
| def __init__(self, dataset, batch_size, rank=None, num_replicas=None): |
| if num_replicas is None: |
| if not torch.distributed.is_available(): |
| raise RuntimeError("Requires distributed package to be available") |
| num_replicas = torch.distributed.get_world_size() |
| if rank is None: |
| if not torch.distributed.is_available(): |
| raise RuntimeError("Requires distributed package to be available") |
| rank = torch.distributed.get_rank() |
| self.dataset = dataset |
| self.num_replicas = num_replicas |
| self.rank = rank |
| self.batch_size = batch_size |
| self.num_samples = int(math.ceil(len(self.dataset) * 1.0 / self.batch_size / self.num_replicas)) * self.batch_size |
| self.total_size = self.num_samples * self.num_replicas |
|
|
| def __iter__(self): |
| indices = list(range(len(self.dataset))) |
| |
| indices += [indices[-1]] * (self.total_size - len(indices)) |
| |
| indices = indices[self.rank * self.num_samples : (self.rank + 1) * self.num_samples] |
| return iter(indices) |
|
|
| def __len__(self): |
| return self.num_samples |
|
|
|
|
| def distributed_concat(tensor, num_total_examples): |
| output_tensors = [tensor.clone() for _ in range(torch.distributed.get_world_size())] |
| torch.distributed.all_gather(output_tensors, tensor) |
| concat = torch.cat(output_tensors, dim=0) |
| return concat[:num_total_examples] |
