Skip to content

Storage backends

DictStorage

hypergrid.storage.storage.DictStorage

Sparse storage backed by a defaultdict. Zero memory for empty bins.

Source code in hypergrid\storage\storage.py 
 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
class DictStorage:
    """Sparse storage backed by a defaultdict. Zero memory for empty bins."""

    def __init__(self):
        self.data = defaultdict(float)

    def add(self, idx, value):
        self.data[idx] += value

    def get(self, idx, default=0.0):
        return self.data.get(idx, default)

    def items(self):
        return self.data.items()

    def values(self):
        return self.data.values()

    def scale(self, factor):
        for k in self.data:
            self.data[k] *= factor

    def clear(self):
        self.data.clear()

    def empty_like(self):
        return DictStorage()

    def to_dict(self):
        return dict(self.data)

DenseTensorStorage

hypergrid.storage.storage.DenseTensorStorage

Dense storage backed by a numpy array. O(prod(shape)) memory.

Source code in hypergrid\storage\storage.py 
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
class DenseTensorStorage:
    """Dense storage backed by a numpy array. O(prod(shape)) memory."""

    def __init__(self, shape):
        self.shape = tuple(shape)
        self.data = np.zeros(self.shape, dtype=float)

    def add(self, idx, value):
        self.data[idx] += value

    def get(self, idx, default=0.0):
        try:
            return float(self.data[idx])
        except IndexError:
            return default

    def items(self):
        for coord in np.argwhere(self.data != 0):
            yield tuple(coord), float(self.data[tuple(coord)])

    def values(self):
        return (float(self.data[tuple(c)]) for c in np.argwhere(self.data != 0))

    def scale(self, factor):
        self.data *= factor

    def clear(self):
        self.data.fill(0.0)

    def empty_like(self, shape=None):
        return DenseTensorStorage(shape or self.shape)

    def to_dict(self):
        return {idx: v for idx, v in self.items()}

SparseTensorStorage

hypergrid.storage.storage.SparseTensorStorage

Sparse storage with explicit index bounds checking.

Source code in hypergrid\storage\storage.py 
 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
class SparseTensorStorage:
    """Sparse storage with explicit index bounds checking."""

    def __init__(self, shape):
        self.shape = tuple(shape)
        self.data = {}

    def add(self, idx, value):
        for i, s in zip(idx, self.shape):
            if not (0 <= i < s):
                raise IndexError(f"Index {idx} out of bounds for shape {self.shape}")
        self.data[idx] = self.data.get(idx, 0.0) + value

    def get(self, idx, default=0.0):
        return self.data.get(idx, default)

    def items(self):
        return self.data.items()

    def values(self):
        return self.data.values()

    def scale(self, factor):
        for k in self.data:
            self.data[k] *= factor

    def clear(self):
        self.data.clear()

    def empty_like(self, shape=None):
        return SparseTensorStorage(shape or self.shape)

    def to_dict(self):
        return dict(self.data)

    def to_dense(self):
        arr = np.zeros(self.shape)
        for idx, v in self.data.items():
            arr[idx] = v
        return arr