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