| import math |
| import bisect |
|
|
| import imgaug |
| import numpy as np |
|
|
| import torch |
| import torch.distributed as dist |
| from torch.utils.data import Sampler, ConcatDataset, BatchSampler |
|
|
| from concern.config import Configurable, State |
|
|
|
|
| def default_worker_init_fn(worker_id): |
| np.random.seed(worker_id) |
| imgaug.seed(worker_id) |
|
|
|
|
| class DataLoader(Configurable, torch.utils.data.DataLoader): |
| dataset = State() |
| batch_size = State(default=256) |
| num_workers = State(default=10) |
| is_train = State(default=True) |
| collect_fn = State(default=None) |
| drop_last = State(default=True) |
| shuffle = State() |
|
|
| def __init__(self, **kwargs): |
| self.load_all(**kwargs) |
| if self.collect_fn is None: |
| self.collect_fn = torch.utils.data.dataloader.default_collate |
| cmd = kwargs.get('cmd', {}) |
| self.is_train = cmd['is_train'] |
| if 'batch_size' in cmd: |
| self.batch_size = cmd['batch_size'] |
| if self.shuffle is None: |
| self.shuffle = self.is_train |
| self.num_workers = cmd.get('num_workers', self.num_workers) |
|
|
| if cmd.get('distributed'): |
| sampler = DistributedSampler( |
| self.dataset, shuffle=self.shuffle, |
| num_replicas=cmd['num_gpus']) |
| batch_sampler = BatchSampler( |
| sampler, self.batch_size//cmd['num_gpus'], False) |
| torch.utils.data.DataLoader.__init__( |
| self, self.dataset, batch_sampler=batch_sampler, |
| num_workers=self.num_workers, pin_memory=False, |
| drop_last=self.drop_last, collate_fn=self.collect_fn, |
| worker_init_fn=default_worker_init_fn) |
| else: |
| torch.utils.data.DataLoader.__init__( |
| self, self.dataset, |
| batch_size=self.batch_size, num_workers=self.num_workers, |
| drop_last=self.drop_last, shuffle=self.shuffle, |
| pin_memory=True, collate_fn=self.collect_fn, |
| worker_init_fn=default_worker_init_fn) |
| self.collect_fn = str(self.collect_fn) |
|
|
|
|
| class SuccessiveRandomSampler(Sampler): |
| '''Random Sampler that yields sorted data in successive ranges. |
| Args: |
| dataset: Dataset used for sampling. |
| ''' |
| def __init__(self, dataset): |
| self.dataset = dataset |
| self.epoch = 0 |
|
|
| def __iter__(self): |
| if self.shuffle: |
| |
| g = torch.Generator() |
| g.manual_seed(self.epoch) |
| indices = torch.randperm(len(self.dataset)).tolist() |
| else: |
| indices = torch.arange(len(self.dataset)).tolist() |
|
|
| |
| indices += indices[: (self.total_size - len(indices))] |
| assert len(indices) == self.total_size |
|
|
| |
| offset = self.num_samples * self.rank |
| indices = indices[offset: offset + self.num_samples] |
| assert len(indices) == self.num_samples |
|
|
| return iter(indices) |
|
|
| def __len__(self): |
| return len(self.dataset) |
|
|
| def set_epoch(self, epoch): |
| self.epoch = epoch |
|
|
|
|
| class DistributedSampler(Sampler): |
| """Sampler that restricts data loading to a subset of the dataset. |
| It is especially useful in conjunction with |
| :class:`torch.nn.parallel.DistributedDataParallel`. In such case, each |
| process can pass a DistributedSampler instance as a DataLoader sampler, |
| and load a subset of the original dataset that is exclusive to it. |
| .. note:: |
| Dataset is assumed to be of constant size. |
| Arguments: |
| dataset: Dataset used for sampling. |
| num_replicas (optional): Number of processes participating in |
| distributed training. |
| rank (optional): Rank of the current process within num_replicas. |
| """ |
|
|
| def __init__(self, dataset, num_replicas=None, rank=None, shuffle=True): |
| if num_replicas is None: |
| if not dist.is_available(): |
| raise RuntimeError( |
| "Requires distributed package to be available") |
| num_replicas = dist.get_world_size() |
| if rank is None: |
| if not dist.is_available(): |
| raise RuntimeError( |
| "Requires distributed package to be available") |
| rank = dist.get_rank() |
| self.dataset = dataset |
| self.num_replicas = num_replicas |
| self.rank = rank |
| self.epoch = 0 |
| self.num_samples = int( |
| math.ceil(len(self.dataset) * 1.0 / self.num_replicas)) |
| self.total_size = self.num_samples * self.num_replicas |
| self.shuffle = shuffle |
|
|
| def __iter__(self): |
| if self.shuffle: |
| |
| g = torch.Generator() |
| g.manual_seed(self.epoch) |
| indices = torch.randperm(len(self.dataset)).tolist() |
| else: |
| indices = torch.arange(len(self.dataset)).tolist() |
|
|
| |
| indices += indices[: (self.total_size - len(indices))] |
| assert len(indices) == self.total_size |
|
|
| |
| offset = self.num_samples * self.rank |
| indices = indices[offset: offset + self.num_samples] |
| assert len(indices) == self.num_samples |
|
|
| return iter(indices) |
|
|
| def __len__(self): |
| return self.num_samples |
|
|
| def set_epoch(self, epoch): |
| self.epoch = epoch |
|
|
|
|
| class InfiniteOrderedSampler(Sampler): |
| def __init__(self, data_source, limit_size): |
| self.data_source = data_source |
| self.limit_size = limit_size |
|
|
| def __iter__(self): |
| n = len(self.data_source) |
|
|
| def wrapper(): |
| cnt = 0 |
| while cnt < self.limit_size: |
| if cnt % n == 0: |
| idx = torch.randperm(n).tolist() |
| yield idx[cnt % n] |
| cnt += 1 |
| return wrapper() |
|
|
| def __len__(self): |
| return self.limit_size |
|
|
|
|
| class InfiniteDataLoader(Configurable, torch.utils.data.DataLoader): |
| dataset = State() |
| batch_size = State(default=256) |
| num_workers = State(default=10) |
| limit_size = State(default=2 ** 31) |
|
|
| def __init__(self, **kwargs): |
| self.load_all(**kwargs) |
|
|
| cmd = kwargs['cmd'] |
| if 'batch_size' in cmd: |
| self.batch_size = cmd['batch_size'] |
|
|
| sampler = InfiniteOrderedSampler(self.dataset, self.limit_size) |
|
|
| torch.utils.data.DataLoader.__init__( |
| self, self.dataset, |
| batch_size=self.batch_size, num_workers=self.num_workers, |
| sampler=sampler, worker_init_fn=default_worker_init_fn, |
| ) |
|
|
|
|
| class RandomSampleSampler(Sampler): |
| def __init__(self, data_source, weights=None, size=2 ** 31): |
| self.data_source = data_source |
| if weights is None: |
| self.probabilities = np.full(len(data_source), 1 / len(data_source)) |
| else: |
| self.probabilities = np.array(weights) / np.sum(weights) |
| self.cum_prob = np.cumsum(self.probabilities) |
| self.size = size |
|
|
| def __iter__(self): |
| def wrapper(): |
| for i in range(self.size): |
| yield bisect.bisect(self.cum_prob, torch.rand(1)[0], hi=len(self.data_source) - 1) |
| return wrapper() |
|
|
| def __len__(self): |
| return self.size |
|
|
|
|
| class RandomSampleDataLoader(Configurable, torch.utils.data.DataLoader): |
| datasets = State() |
| weights = State() |
| batch_size = State(default=256) |
| num_workers = State(default=10) |
| size = State(default=2 ** 31) |
|
|
| def __init__(self, **kwargs): |
| self.load_all(**kwargs) |
|
|
| cmd = kwargs['cmd'] |
| if 'batch_size' in cmd: |
| self.batch_size = cmd['batch_size'] |
|
|
| probs = [] |
| for dataset, weight in zip(self.datasets, self.weights): |
| probs.append(np.full(len(dataset), weight / len(dataset))) |
|
|
| dataset = ConcatDataset(self.datasets) |
| probs = np.concatenate(probs) |
| assert(len(dataset) == len(probs)) |
|
|
| sampler = RandomSampleSampler(dataset, probs, self.size) |
|
|
| torch.utils.data.DataLoader.__init__( |
| self, dataset, |
| batch_size=self.batch_size, num_workers=self.num_workers, |
| sampler=sampler, worker_init_fn=default_worker_init_fn, |
| ) |
|
|
