Skip to content

Splits#

thunder.layout.split.Split #

Bases: Layout

Source code in thunder/layout/split.py 
 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
class Split(Layout):
    def __init__(
        self, split: SplitType, entries: Sequence, *args: Any, names: Sequence[str] | None = None, **kwargs: Any
    ):
        """
        Splits data according to split function.
        Parameters
        ----------
        split: Callable
            Split function, or a sklearn splitter.
        entries: Sequence
            Series of ids or torch Dataset or Connectome Layer.
        args: Any
            args for split.
        names: Optional[Sequence[str]]
            Names of folds, e.g. 'train', 'val', test'
        kwargs: Any
            kwargs for split.
        Examples
        ----------
        ```python
        from sklearn.model_selection import KFold

        ids = [0, 1, ...]
        layout = Split(KFold(3), ids, names=["train", "test"])
        ```
        """
        if not callable(split):
            if not hasattr(split, "split"):
                raise TypeError(f"Expected either a function, or a sklearn splitter, got {type(split)!r}")
            split = split.split

        ids = entries_to_ids(entries)
        # TODO: safer way to unify types
        splits = [tuple(map(jsonify, xs)) for xs in split(ids, *args, **kwargs)]
        if names is not None:
            # TODO
            assert len(set(names)) == len(names)
            assert len(splits[0]) == len(names)

        self.entries = entries
        self.splits = splits
        self.names = names
        self.fold: int | None = None

    def __getitem__(self, item: int):
        return self._subset(item)

    def __getattr__(self, name: str):
        if self.names is None:
            raise AttributeError(name)
        return self._subset(self.names.index(name))

    def _subset(self, idx):
        # TODO
        assert self.fold is not None
        return entries_subset(self.entries, self.splits[self.fold][idx])

    def build(self, experiment: Path, config: Config):
        config.dump(experiment / "experiment.config")
        name = experiment.name
        for fold, split in enumerate(self.splits):
            folder = experiment / f"fold_{fold}"
            folder.mkdir()
            save(split, folder / "split.json")

            local = config.copy().update(ExpName=f"{name}({fold})", GroupName=name)
            local.dump(folder / "experiment.config")
            yield Node(name=str(fold))

    def load(self, experiment: Path, node: Node | None) -> tuple[Config, Path, dict[str, Any]]:
        folder = experiment / f"fold_{node.name}"
        return (
            Config.load(folder / "experiment.config"),
            folder,
            {
                "fold": int(node.name),
                "split": tuple(load(folder / "split.json")),
            },
        )

    def set(self, fold: int, split: Sequence[Sequence] | None = None):
        self.fold = fold
        if split is None:
            warnings.warn("No reference split provided. Your results might be inconsistent!", UserWarning)
        else:
            if split != self.splits[fold]:
                # TODO: consistency error?
                raise ValueError

build(experiment, config) #

Source code in thunder/layout/split.py 
87
88
89
90
91
92
93
94
95
96
97
def build(self, experiment: Path, config: Config):
    config.dump(experiment / "experiment.config")
    name = experiment.name
    for fold, split in enumerate(self.splits):
        folder = experiment / f"fold_{fold}"
        folder.mkdir()
        save(split, folder / "split.json")

        local = config.copy().update(ExpName=f"{name}({fold})", GroupName=name)
        local.dump(folder / "experiment.config")
        yield Node(name=str(fold))

load(experiment, node) #

Source code in thunder/layout/split.py 
 99
100
101
102
103
104
105
106
107
108
def load(self, experiment: Path, node: Node | None) -> tuple[Config, Path, dict[str, Any]]:
    folder = experiment / f"fold_{node.name}"
    return (
        Config.load(folder / "experiment.config"),
        folder,
        {
            "fold": int(node.name),
            "split": tuple(load(folder / "split.json")),
        },
    )

set(fold, split=None) #

Source code in thunder/layout/split.py 
110
111
112
113
114
115
116
117
def set(self, fold: int, split: Sequence[Sequence] | None = None):
    self.fold = fold
    if split is None:
        warnings.warn("No reference split provided. Your results might be inconsistent!", UserWarning)
    else:
        if split != self.splits[fold]:
            # TODO: consistency error?
            raise ValueError

thunder.layout.split.SingleSplit #

Bases: Layout

Source code in thunder/layout/split.py 
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
class SingleSplit(Layout):
    def __init__(
        self,
        entries: Sequence,
        *,
        shuffle: bool = True,
        random_state: np.random.RandomState | int | None = 0,
        **sizes: int | float,
    ):
        """
        Creates single fold experiment, with custom number of sets.
        Parameters
        ----------
        entries: Sequence
            Sequence of ids or
        shuffle: bool
            Whether to shuffle entries.
        random_state : Union[np.random.RandomState, int, None]
        sizes: Union[int, float]
            Size of each split.
        Examples
        ----------
        ```python
        ids = [...]
        layout = SingleSplit(ids, train=0.7, val=0.1, test=0.2)
        ```
        """
        if not isinstance(random_state, np.random.RandomState):
            random_state = np.random.RandomState(random_state)

        ids = entries_to_ids(entries)
        self.entries = entries
        self.split = dict(
            zip(
                sizes.keys(),
                multi_split(ids, list(sizes.values()), shuffle=shuffle, random_state=random_state),
                strict=True,
            )
        )

    def __getattr__(self, name: str):
        if name not in self.split:
            raise AttributeError(name)
        return entries_subset(self.entries, self.split[name])

    def build(self, experiment: Path, config: Config):
        config.dump(experiment / "experiment.config")
        name = experiment.name
        save(self.split, experiment / "split.json")

        local = config.copy().update(ExpName=name, GroupName=name)
        local.dump(experiment / "experiment.config")
        return []

    def load(self, experiment: Path, node: Node | None) -> tuple[Config, Path, dict[str, Any]]:
        return (
            Config.load(experiment / "experiment.config"),
            experiment,
            {
                "split": load(experiment / "split.json"),
            },
        )

    def set(self, split: dict[str, Sequence] | None = None):
        if split is None:
            warnings.warn("No reference split provided. Your results might be inconsistent!", UserWarning)
        else:
            if split != self.split:
                # TODO: consistency error?
                raise ValueError

build(experiment, config) #

Source code in thunder/layout/split.py 
165
166
167
168
169
170
171
172
def build(self, experiment: Path, config: Config):
    config.dump(experiment / "experiment.config")
    name = experiment.name
    save(self.split, experiment / "split.json")

    local = config.copy().update(ExpName=name, GroupName=name)
    local.dump(experiment / "experiment.config")
    return []

load(experiment, node) #

Source code in thunder/layout/split.py 
174
175
176
177
178
179
180
181
def load(self, experiment: Path, node: Node | None) -> tuple[Config, Path, dict[str, Any]]:
    return (
        Config.load(experiment / "experiment.config"),
        experiment,
        {
            "split": load(experiment / "split.json"),
        },
    )

set(split=None) #

Source code in thunder/layout/split.py 
183
184
185
186
187
188
189
def set(self, split: dict[str, Sequence] | None = None):
    if split is None:
        warnings.warn("No reference split provided. Your results might be inconsistent!", UserWarning)
    else:
        if split != self.split:
            # TODO: consistency error?
            raise ValueError