File size: 5,373 Bytes
eb90a8a | 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 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 | # adaptation of pytorch-geometrics DataLoader
import torch
from torch.utils.data.dataloader import default_collate
from torch_geometric.data import Data, Batch
from torch._six import container_abcs, string_classes, int_classes
# from src.data.batch import Batch
class Collater(object):
def __init__(self, follow_batch, ndevices):
self.follow_batch = follow_batch
self.ndevices = ndevices
def collate(self, batch):
elem = batch[0]
if isinstance(elem, Data):
data = batch
count = torch.tensor([data.num_nodes for data in data])
cumsum = count.cumsum(0)
cumsum = torch.cat([cumsum.new_zeros(1), cumsum], dim=0)
device_id = self.ndevices * cumsum.to(torch.float) / cumsum[-1].item()
device_id = (device_id[:-1] + device_id[1:]) / 2.0
device_id = device_id.to(torch.long) # round.
split = device_id.bincount().cumsum(
0) # Count the frequency of each value in an array of non-negative ints.
split = torch.cat([split.new_zeros(1), split], dim=0)
split = torch.unique(split, sorted=True)
split = split.tolist()
graphs = []
for i in range(len(split) - 1):
data1 = data[split[i]:split[i + 1]]
graph = Batch.from_data_list(data1, self.follow_batch)
graphs += [graph]
return graphs #Batch.from_data_list(batch, self.follow_batch)
elif isinstance(elem, torch.Tensor):
return default_collate(batch)
elif isinstance(elem, float):
return torch.tensor(batch, dtype=torch.float)
elif isinstance(elem, int_classes):
return torch.tensor(batch)
elif isinstance(elem, string_classes):
return batch
elif isinstance(elem, container_abcs.Mapping):
return {key: self.collate([d[key] for d in batch]) for key in elem}
elif isinstance(elem, tuple) and hasattr(elem, '_fields'):
return type(elem)(*(self.collate(s) for s in zip(*batch)))
elif isinstance(elem, container_abcs.Sequence):
return [self.collate(s) for s in zip(*batch)]
raise TypeError('DataLoader found invalid type: {}'.format(type(elem)))
def __call__(self, batch):
return self.collate(batch)
class DataLoader(torch.utils.data.DataLoader):
r"""Data loader which merges data objects from a
:class:`torch_geometric.data.dataset` to a mini-batch.
Args:
dataset (Dataset): The dataset from which to load the data.
batch_size (int, optional): How many samples per batch to load.
(default: :obj:`1`)
shuffle (bool, optional): If set to :obj:`True`, the data will be
reshuffled at every epoch. (default: :obj:`False`)
follow_batch (list or tuple, optional): Creates assignment batch
vectors for each key in the list. (default: :obj:`[]`)
"""
def __init__(self, dataset, batch_size=1, shuffle=False, follow_batch=[], n_devices=1,
**kwargs):
super(DataLoader,
self).__init__(dataset, batch_size, shuffle,
collate_fn=Collater(follow_batch, n_devices), **kwargs)
class DataListLoader(torch.utils.data.DataLoader):
r"""Data loader which merges data objects from a
:class:`torch_geometric.data.dataset` to a python list.
.. note::
This data loader should be used for multi-gpu support via
:class:`torch_geometric.nn.DataParallel`.
Args:
dataset (Dataset): The dataset from which to load the data.
batch_size (int, optional): How many samples per batch to load.
(default: :obj:`1`)
shuffle (bool, optional): If set to :obj:`True`, the data will be
reshuffled at every epoch (default: :obj:`False`)
"""
def __init__(self, dataset, batch_size=1, shuffle=False, **kwargs):
super(DataListLoader, self).__init__(
dataset, batch_size, shuffle,
collate_fn=lambda data_list: data_list, **kwargs)
class DenseCollater(object):
def collate(self, data_list):
batch = Batch()
for key in data_list[0].keys:
batch[key] = default_collate([d[key] for d in data_list])
return batch
def __call__(self, batch):
return self.collate(batch)
class DenseDataLoader(torch.utils.data.DataLoader):
r"""Data loader which merges data objects from a
:class:`torch_geometric.data.dataset` to a mini-batch.
.. note::
To make use of this data loader, all graphs in the dataset needs to
have the same shape for each its attributes.
Therefore, this data loader should only be used when working with
*dense* adjacency matrices.
Args:
dataset (Dataset): The dataset from which to load the data.
batch_size (int, optional): How many samples per batch to load.
(default: :obj:`1`)
shuffle (bool, optional): If set to :obj:`True`, the data will be
reshuffled at every epoch (default: :obj:`False`)
"""
def __init__(self, dataset, batch_size=1, shuffle=False, **kwargs):
super(DenseDataLoader, self).__init__(
dataset, batch_size, shuffle, collate_fn=DenseCollater(), **kwargs)
|