| | 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, |
| | ) |
| |
|
