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
|
from collections.abc import Mapping
from typing import Any, Callable, List, Optional, Sequence
import torch
from torch.utils.data import DataLoader
def to_device(inputs: Any, device: Optional[torch.device] = None) -> Any:
if hasattr(inputs, 'to'):
return inputs.to(device)
elif isinstance(inputs, Mapping):
return {key: to_device(value, device) for key, value in inputs.items()}
elif isinstance(inputs, tuple) and hasattr(inputs, '_fields'):
return type(inputs)(*(to_device(s, device) for s in zip(*inputs)))
elif isinstance(inputs, Sequence) and not isinstance(inputs, str):
return [to_device(s, device) for s in zip(*inputs)]
return inputs
class CachedLoader:
r"""A loader to cache mini-batch outputs, e.g., obtained during
:class:`NeighborLoader` iterations.
Args:
loader (torch.utils.data.DataLoader): The data loader.
device (torch.device, optional): The device to load the data to.
(default: :obj:`None`)
transform (callable, optional): A function/transform that takes in
a sampled mini-batch and returns a transformed version.
(default: :obj:`None`)
"""
def __init__(
self,
loader: DataLoader,
device: Optional[torch.device] = None,
transform: Optional[Callable] = None,
):
self.loader = loader
self.device = device
self.transform = transform
self._cache: List[Any] = []
def clear(self):
r"""Clears the cache."""
self._cache = []
def __iter__(self) -> Any:
if len(self._cache):
for batch in self._cache:
yield batch
return
for batch in self.loader:
if self.transform is not None:
batch = self.transform(batch)
batch = to_device(batch, self.device)
self._cache.append(batch)
yield batch
def __len__(self) -> int:
return len(self.loader)
def __repr__(self) -> str:
return f'{self.__class__.__name__}({self.loader})'
|
