structured-data-models 0.2.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- sdm/__init__.py +58 -0
- sdm/_constants.py +6 -0
- sdm/_inference.py +42 -0
- sdm/_kernels/__init__.py +10 -0
- sdm/_kernels/rmsnorm_cast.py +92 -0
- sdm/_kernels/segment_multi_reduce.py +141 -0
- sdm/_kernels/triton/__init__.py +7 -0
- sdm/_kernels/triton/rmsnorm_cast.py +136 -0
- sdm/_kernels/triton/segment_multi_reduce.py +173 -0
- sdm/_memory.py +34 -0
- sdm/_warnings.py +29 -0
- sdm/cache.py +163 -0
- sdm/ensemble.py +501 -0
- sdm/evaluation/__init__.py +11 -0
- sdm/evaluation/classification.py +205 -0
- sdm/explain/__init__.py +12 -0
- sdm/explain/base.py +123 -0
- sdm/explain/gradient.py +112 -0
- sdm/models/__init__.py +20 -0
- sdm/models/_huggingface.py +58 -0
- sdm/models/base.py +966 -0
- sdm/models/callback.py +106 -0
- sdm/models/ecoc.py +197 -0
- sdm/models/kumo/__init__.py +13 -0
- sdm/models/kumo/relational/NOTICE +5 -0
- sdm/models/kumo/relational/__init__.py +11 -0
- sdm/models/kumo/relational/graph.py +101 -0
- sdm/models/kumo/relational/invariant_gnn.py +122 -0
- sdm/models/kumo/relational/model.py +602 -0
- sdm/models/kumo/relational/recipe.py +18 -0
- sdm/models/kumo/relational/task.py +113 -0
- sdm/models/kumo/tabular/__init__.py +17 -0
- sdm/models/kumo/tabular/batching.py +139 -0
- sdm/models/kumo/tabular/block.py +100 -0
- sdm/models/kumo/tabular/cell_embedding.py +85 -0
- sdm/models/kumo/tabular/icl.py +136 -0
- sdm/models/kumo/tabular/model.py +299 -0
- sdm/models/kumo/tabular/recipe.py +71 -0
- sdm/models/kumo/tabular/row_embedding.py +214 -0
- sdm/models/tabfm/LICENSE +209 -0
- sdm/models/tabfm/__init__.py +11 -0
- sdm/models/tabfm/block.py +94 -0
- sdm/models/tabfm/cell_embedding.py +219 -0
- sdm/models/tabfm/ckpt.py +242 -0
- sdm/models/tabfm/icl.py +107 -0
- sdm/models/tabfm/model.py +261 -0
- sdm/models/tabfm/recipe.py +46 -0
- sdm/models/tabfm/row_embedding.py +241 -0
- sdm/models/tabiclv2/LICENSE +33 -0
- sdm/models/tabiclv2/__init__.py +11 -0
- sdm/models/tabiclv2/block.py +81 -0
- sdm/models/tabiclv2/ckpt.py +134 -0
- sdm/models/tabiclv2/icl.py +420 -0
- sdm/models/tabiclv2/model.py +293 -0
- sdm/models/tabiclv2/recipe.py +46 -0
- sdm/models/tabiclv2/row_embedding.py +254 -0
- sdm/nn/__init__.py +28 -0
- sdm/nn/_buffer.py +91 -0
- sdm/nn/attention.py +825 -0
- sdm/nn/glu.py +78 -0
- sdm/nn/linear.py +46 -0
- sdm/nn/rms_norm.py +59 -0
- sdm/nn/rope.py +107 -0
- sdm/nn/scaling.py +240 -0
- sdm/nn/set_transformer.py +162 -0
- sdm/nn/softplus.py +65 -0
- sdm/processing/__init__.py +96 -0
- sdm/processing/base.py +254 -0
- sdm/processing/categorical/__init__.py +16 -0
- sdm/processing/categorical/_categorical.py +60 -0
- sdm/processing/categorical/align.py +540 -0
- sdm/processing/categorical/count.py +121 -0
- sdm/processing/categorical/impute.py +107 -0
- sdm/processing/categorical/shuffle.py +204 -0
- sdm/processing/common/__init__.py +32 -0
- sdm/processing/common/callable.py +29 -0
- sdm/processing/common/choice.py +185 -0
- sdm/processing/common/drop.py +28 -0
- sdm/processing/common/ensemble.py +187 -0
- sdm/processing/common/identity.py +18 -0
- sdm/processing/common/select.py +107 -0
- sdm/processing/common/sequential.py +158 -0
- sdm/processing/common/shuffle.py +195 -0
- sdm/processing/common/stype.py +199 -0
- sdm/processing/common/table.py +120 -0
- sdm/processing/common/task.py +135 -0
- sdm/processing/common/to_numerical.py +60 -0
- sdm/processing/datetime/__init__.py +8 -0
- sdm/processing/datetime/calendar.py +196 -0
- sdm/processing/ensemble.py +203 -0
- sdm/processing/execution.py +418 -0
- sdm/processing/numerical/__init__.py +38 -0
- sdm/processing/numerical/_stats.py +29 -0
- sdm/processing/numerical/cast.py +33 -0
- sdm/processing/numerical/clip.py +48 -0
- sdm/processing/numerical/clip_soft.py +54 -0
- sdm/processing/numerical/constant.py +235 -0
- sdm/processing/numerical/flip_sign.py +78 -0
- sdm/processing/numerical/impute.py +52 -0
- sdm/processing/numerical/pca.py +62 -0
- sdm/processing/numerical/power.py +325 -0
- sdm/processing/numerical/quantile.py +306 -0
- sdm/processing/numerical/quantile_clip.py +63 -0
- sdm/processing/numerical/random_projection.py +86 -0
- sdm/processing/numerical/rank_gaussian.py +168 -0
- sdm/processing/numerical/robust_scale.py +88 -0
- sdm/processing/numerical/sigma_clip.py +123 -0
- sdm/processing/numerical/standardize.py +71 -0
- sdm/processing/output/__init__.py +14 -0
- sdm/processing/output/reduce.py +86 -0
- sdm/processing/output/softmax.py +48 -0
- sdm/processing/output/sort.py +16 -0
- sdm/processing/recipe.py +154 -0
- sdm/processing/text/__init__.py +12 -0
- sdm/processing/text/sentence_transformer.py +451 -0
- sdm/processing/text/tfidf.py +478 -0
- sdm/relational/__init__.py +16 -0
- sdm/relational/backend/__init__.py +12 -0
- sdm/relational/backend/_cugraph.py +546 -0
- sdm/relational/backend/_pyg_lib.py +175 -0
- sdm/relational/data.py +393 -0
- sdm/relational/join.py +173 -0
- sdm/relational/sampler.py +259 -0
- sdm/relational/task.py +465 -0
- sdm/stype.py +396 -0
- sdm/task.py +53 -0
- sdm/tensor/__init__.py +20 -0
- sdm/tensor/categorical.py +953 -0
- sdm/tensor/columnar.py +1127 -0
- sdm/tensor/io/__init__.py +22 -0
- sdm/tensor/io/arrow.py +120 -0
- sdm/tensor/io/cudf.py +47 -0
- sdm/tensor/mixin.py +124 -0
- sdm/tensor/nullable.py +963 -0
- sdm/tensor/string.py +526 -0
- sdm/tensor/table.py +2035 -0
- sdm/tensor/var_len.py +1486 -0
- sdm/testing/__init__.py +14 -0
- sdm/testing/decorators.py +61 -0
- sdm/testing/memory.py +92 -0
- structured_data_models-0.2.0.dist-info/METADATA +142 -0
- structured_data_models-0.2.0.dist-info/RECORD +152 -0
- structured_data_models-0.2.0.dist-info/WHEEL +5 -0
- structured_data_models-0.2.0.dist-info/licenses/LICENSE +204 -0
- structured_data_models-0.2.0.dist-info/licenses/THIRD_PARTY_LICENSES.md +40 -0
- structured_data_models-0.2.0.dist-info/licenses/sdm/models/kumo/relational/NOTICE +5 -0
- structured_data_models-0.2.0.dist-info/licenses/sdm/models/tabfm/LICENSE +209 -0
- structured_data_models-0.2.0.dist-info/licenses/sdm/models/tabiclv2/LICENSE +33 -0
- structured_data_models-0.2.0.dist-info/licenses/third_party/contributor-covenant/LICENSE +20 -0
- structured_data_models-0.2.0.dist-info/licenses/third_party/pytorch/LICENSE +84 -0
- structured_data_models-0.2.0.dist-info/licenses/third_party/tabpfn-extensions/LICENSE +202 -0
- structured_data_models-0.2.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,199 @@
|
|
|
1
|
+
# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
|
2
|
+
# SPDX-License-Identifier: Apache-2.0
|
|
3
|
+
|
|
4
|
+
from typing import cast
|
|
5
|
+
|
|
6
|
+
import torch
|
|
7
|
+
from torch.nn import ModuleDict
|
|
8
|
+
|
|
9
|
+
from sdm import EnsembleTable, Stype
|
|
10
|
+
from sdm.processing import (
|
|
11
|
+
EnsembleInvertibleMixin,
|
|
12
|
+
EnsembleProcessor,
|
|
13
|
+
Processor,
|
|
14
|
+
)
|
|
15
|
+
|
|
16
|
+
|
|
17
|
+
class StypeDispatch(EnsembleProcessor, EnsembleInvertibleMixin):
|
|
18
|
+
r"""Apply separate processor pipelines to columns grouped by semantic type.
|
|
19
|
+
|
|
20
|
+
For each configured route, matching columns from a
|
|
21
|
+
:class:`~sdm.tensor.TableTensor` or
|
|
22
|
+
:class:`~sdm.EnsembleTable` are passed to that processor. Ordinary
|
|
23
|
+
processors learn separate state for each compatible ensemble group, while
|
|
24
|
+
ensemble-aware processors operate on all groups directly. Compatible
|
|
25
|
+
members are processed together and route outputs are concatenated in
|
|
26
|
+
semantic type order while preserving logical member order. A route may
|
|
27
|
+
change column values, names, count, or order. With the default passthrough
|
|
28
|
+
behavior, unconfigured semantic types follow in input order.
|
|
29
|
+
|
|
30
|
+
Inverse transform supports routes that preserve their semantic type. Every
|
|
31
|
+
active route must be invertible, and routes must not share an output
|
|
32
|
+
semantic type. Passthrough columns are preserved.
|
|
33
|
+
|
|
34
|
+
Args:
|
|
35
|
+
numerical: Processor or stateless callable route for numerical
|
|
36
|
+
columns.
|
|
37
|
+
categorical: Processor or stateless callable route for categorical
|
|
38
|
+
columns.
|
|
39
|
+
datetime: Processor or stateless callable route for datetime columns.
|
|
40
|
+
text: Processor or stateless callable route for text columns.
|
|
41
|
+
id: Processor or stateless callable route for identifier columns.
|
|
42
|
+
"""
|
|
43
|
+
|
|
44
|
+
def __init__(
|
|
45
|
+
self,
|
|
46
|
+
*,
|
|
47
|
+
numerical: object = None,
|
|
48
|
+
categorical: object = None,
|
|
49
|
+
datetime: object = None,
|
|
50
|
+
id: object = None,
|
|
51
|
+
text: object = None,
|
|
52
|
+
) -> None:
|
|
53
|
+
super().__init__()
|
|
54
|
+
self.processors: ModuleDict[EnsembleProcessor] = ModuleDict()
|
|
55
|
+
for stype, processor in (
|
|
56
|
+
(Stype.numerical, numerical),
|
|
57
|
+
(Stype.categorical, categorical),
|
|
58
|
+
(Stype.datetime, datetime),
|
|
59
|
+
(Stype.text, text),
|
|
60
|
+
(Stype.id, id),
|
|
61
|
+
):
|
|
62
|
+
if processor is None:
|
|
63
|
+
continue
|
|
64
|
+
processor = EnsembleProcessor.as_processor(processor)
|
|
65
|
+
self.processors[str(stype)] = processor
|
|
66
|
+
|
|
67
|
+
self.handles_stypes = frozenset(
|
|
68
|
+
Stype(stype) for stype in self.processors
|
|
69
|
+
)
|
|
70
|
+
self.requires_fit = any(
|
|
71
|
+
processor.requires_fit for processor in self.processors.values()
|
|
72
|
+
)
|
|
73
|
+
self._active_routes: tuple[str, ...] | None = None
|
|
74
|
+
|
|
75
|
+
def get_extra_state(
|
|
76
|
+
self,
|
|
77
|
+
) -> tuple[str, ...] | None:
|
|
78
|
+
r""":meta private:""" # noqa: D415
|
|
79
|
+
return self._active_routes
|
|
80
|
+
|
|
81
|
+
def set_extra_state(self, state: object) -> None:
|
|
82
|
+
r""":meta private:""" # noqa: D415
|
|
83
|
+
self._active_routes = cast(tuple[str, ...] | None, state)
|
|
84
|
+
|
|
85
|
+
def _find_active_routes(
|
|
86
|
+
self,
|
|
87
|
+
ensemble_table: EnsembleTable,
|
|
88
|
+
) -> tuple[str, ...]:
|
|
89
|
+
return tuple(
|
|
90
|
+
stype
|
|
91
|
+
for stype in self.processors
|
|
92
|
+
if any(
|
|
93
|
+
len(group.columns[Stype(stype)]) > 0
|
|
94
|
+
for group in ensemble_table._iter_groups()
|
|
95
|
+
)
|
|
96
|
+
)
|
|
97
|
+
|
|
98
|
+
def _fit_ensemble(
|
|
99
|
+
self,
|
|
100
|
+
ensemble_table: EnsembleTable,
|
|
101
|
+
*,
|
|
102
|
+
generator: torch.Generator | None = None,
|
|
103
|
+
) -> None:
|
|
104
|
+
self._active_routes = self._find_active_routes(ensemble_table)
|
|
105
|
+
for stype in self._active_routes:
|
|
106
|
+
self.processors[stype].fit_ensemble(
|
|
107
|
+
ensemble_table.select_stypes(stype),
|
|
108
|
+
generator=generator,
|
|
109
|
+
)
|
|
110
|
+
|
|
111
|
+
def _fit_transform_ensemble(
|
|
112
|
+
self,
|
|
113
|
+
ensemble_table: EnsembleTable,
|
|
114
|
+
*,
|
|
115
|
+
generator: torch.Generator | None = None,
|
|
116
|
+
) -> EnsembleTable:
|
|
117
|
+
self._active_routes = self._find_active_routes(ensemble_table)
|
|
118
|
+
outputs = [
|
|
119
|
+
self.processors[stype].fit_transform_ensemble(
|
|
120
|
+
ensemble_table.select_stypes(stype),
|
|
121
|
+
generator=generator,
|
|
122
|
+
)
|
|
123
|
+
for stype in self._active_routes
|
|
124
|
+
]
|
|
125
|
+
outputs.append(self._remainder_ensemble(ensemble_table))
|
|
126
|
+
if len(outputs) == 0:
|
|
127
|
+
return ensemble_table.select_stypes(())
|
|
128
|
+
return EnsembleTable.concatenate_columns(outputs)
|
|
129
|
+
|
|
130
|
+
def _transform_ensemble(
|
|
131
|
+
self,
|
|
132
|
+
ensemble_table: EnsembleTable,
|
|
133
|
+
) -> EnsembleTable:
|
|
134
|
+
active_routes = self._active_routes
|
|
135
|
+
if not self.requires_fit or active_routes is None:
|
|
136
|
+
active_routes = self._find_active_routes(ensemble_table)
|
|
137
|
+
self._active_routes = active_routes
|
|
138
|
+
outputs = [
|
|
139
|
+
self.processors[stype].transform_ensemble(
|
|
140
|
+
ensemble_table.select_stypes(stype)
|
|
141
|
+
)
|
|
142
|
+
for stype in active_routes
|
|
143
|
+
]
|
|
144
|
+
outputs.append(self._remainder_ensemble(ensemble_table))
|
|
145
|
+
if len(outputs) == 0:
|
|
146
|
+
return ensemble_table.select_stypes(())
|
|
147
|
+
return EnsembleTable.concatenate_columns(outputs)
|
|
148
|
+
|
|
149
|
+
def _inverse_transform_ensemble(
|
|
150
|
+
self,
|
|
151
|
+
ensemble_table: EnsembleTable,
|
|
152
|
+
) -> EnsembleTable:
|
|
153
|
+
active_routes = self._active_routes
|
|
154
|
+
if not self.requires_fit or active_routes is None:
|
|
155
|
+
active_routes = self._find_active_routes(ensemble_table)
|
|
156
|
+
self._active_routes = active_routes
|
|
157
|
+
|
|
158
|
+
outputs = []
|
|
159
|
+
for stype in active_routes:
|
|
160
|
+
processor = self.processors[stype]
|
|
161
|
+
if not isinstance(processor, EnsembleInvertibleMixin):
|
|
162
|
+
raise TypeError(
|
|
163
|
+
f"{processor.__class__.__name__!r} is not invertible."
|
|
164
|
+
)
|
|
165
|
+
# TODO This is wrong. A processor may not map to same stype back!
|
|
166
|
+
outputs.append(
|
|
167
|
+
processor.inverse_transform_ensemble(
|
|
168
|
+
ensemble_table.select_stypes(stype)
|
|
169
|
+
)
|
|
170
|
+
)
|
|
171
|
+
|
|
172
|
+
outputs.append(self._remainder_ensemble(ensemble_table))
|
|
173
|
+
return EnsembleTable.concatenate_columns(outputs)
|
|
174
|
+
|
|
175
|
+
def _remainder_ensemble(
|
|
176
|
+
self,
|
|
177
|
+
ensemble_table: EnsembleTable,
|
|
178
|
+
) -> EnsembleTable:
|
|
179
|
+
return ensemble_table.select_stypes(
|
|
180
|
+
tuple(
|
|
181
|
+
stype for stype in Stype if str(stype) not in self.processors
|
|
182
|
+
)
|
|
183
|
+
)
|
|
184
|
+
|
|
185
|
+
def __repr__(self, *, indent: int = 0) -> str:
|
|
186
|
+
if len(self.processors) == 0:
|
|
187
|
+
return super().__repr__(indent=indent)
|
|
188
|
+
|
|
189
|
+
reprs = []
|
|
190
|
+
for stype, processor in self.processors.items():
|
|
191
|
+
processor = cast(Processor, processor)
|
|
192
|
+
processor_repr = processor.__repr__(indent=indent + 2)
|
|
193
|
+
processor_repr = processor_repr[indent + 2 :]
|
|
194
|
+
reprs.append(f"{' ' * (indent + 2)}{stype}={processor_repr}")
|
|
195
|
+
return (
|
|
196
|
+
f"{' ' * indent}{self.__class__.__name__}(\n"
|
|
197
|
+
+ ",\n".join(reprs)
|
|
198
|
+
+ f",\n{' ' * indent})"
|
|
199
|
+
)
|
|
@@ -0,0 +1,120 @@
|
|
|
1
|
+
# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
|
2
|
+
# SPDX-License-Identifier: Apache-2.0
|
|
3
|
+
|
|
4
|
+
from typing import Literal, cast
|
|
5
|
+
|
|
6
|
+
import torch
|
|
7
|
+
from torch.nn import ModuleDict
|
|
8
|
+
|
|
9
|
+
from sdm import EnsembleTable, Stype
|
|
10
|
+
from sdm.processing import EnsembleProcessor, Processor
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class TableDispatch(EnsembleProcessor):
|
|
14
|
+
"""Apply separate feature processors to task and related tables.
|
|
15
|
+
|
|
16
|
+
:class:`TableDispatch` is resolved only during model execution.
|
|
17
|
+
|
|
18
|
+
Args:
|
|
19
|
+
task: Processor used for the task table.
|
|
20
|
+
related: Processor used for related tables.
|
|
21
|
+
"""
|
|
22
|
+
|
|
23
|
+
def __init__(
|
|
24
|
+
self,
|
|
25
|
+
*,
|
|
26
|
+
task: object = None,
|
|
27
|
+
related: object = None,
|
|
28
|
+
) -> None:
|
|
29
|
+
super().__init__()
|
|
30
|
+
self.processors: ModuleDict[EnsembleProcessor] = ModuleDict()
|
|
31
|
+
for route, processor in (("task", task), ("related", related)):
|
|
32
|
+
if processor is None:
|
|
33
|
+
continue
|
|
34
|
+
self.processors[route] = EnsembleProcessor.as_processor(processor)
|
|
35
|
+
|
|
36
|
+
self.requires_fit = any(
|
|
37
|
+
processor.requires_fit for processor in self.processors.values()
|
|
38
|
+
)
|
|
39
|
+
self._route: Literal["task", "related"] | None = None
|
|
40
|
+
|
|
41
|
+
@property
|
|
42
|
+
def handles_stypes(self) -> frozenset[Stype]:
|
|
43
|
+
r""":meta private:""" # noqa: D415
|
|
44
|
+
return frozenset(
|
|
45
|
+
stype
|
|
46
|
+
for processor in self.processors.values()
|
|
47
|
+
for stype in processor.handles_stypes
|
|
48
|
+
)
|
|
49
|
+
|
|
50
|
+
def _fit_ensemble(
|
|
51
|
+
self,
|
|
52
|
+
ensemble_table: EnsembleTable,
|
|
53
|
+
*,
|
|
54
|
+
generator: torch.Generator | None = None,
|
|
55
|
+
) -> None:
|
|
56
|
+
if self._route is None:
|
|
57
|
+
raise RuntimeError(
|
|
58
|
+
f"{self.__class__.__name__!r} has no resolved table route; "
|
|
59
|
+
"use it in a 'Recipe' through model execution"
|
|
60
|
+
)
|
|
61
|
+
if self._route in self.processors:
|
|
62
|
+
self.processors[self._route].fit_ensemble(
|
|
63
|
+
ensemble_table,
|
|
64
|
+
generator=generator,
|
|
65
|
+
)
|
|
66
|
+
|
|
67
|
+
def _fit_transform_ensemble(
|
|
68
|
+
self,
|
|
69
|
+
ensemble_table: EnsembleTable,
|
|
70
|
+
*,
|
|
71
|
+
generator: torch.Generator | None = None,
|
|
72
|
+
) -> EnsembleTable:
|
|
73
|
+
if self._route is None:
|
|
74
|
+
raise RuntimeError(
|
|
75
|
+
f"{self.__class__.__name__!r} has no resolved table route; "
|
|
76
|
+
"use it in a 'Recipe' through model execution"
|
|
77
|
+
)
|
|
78
|
+
if self._route not in self.processors:
|
|
79
|
+
return ensemble_table
|
|
80
|
+
return self.processors[self._route].fit_transform_ensemble(
|
|
81
|
+
ensemble_table,
|
|
82
|
+
generator=generator,
|
|
83
|
+
)
|
|
84
|
+
|
|
85
|
+
def _transform_ensemble(
|
|
86
|
+
self,
|
|
87
|
+
ensemble_table: EnsembleTable,
|
|
88
|
+
) -> EnsembleTable:
|
|
89
|
+
if self._route is None:
|
|
90
|
+
raise RuntimeError(
|
|
91
|
+
f"{self.__class__.__name__!r} has no resolved table route; "
|
|
92
|
+
"use it in a 'Recipe' through model execution"
|
|
93
|
+
)
|
|
94
|
+
if self._route not in self.processors:
|
|
95
|
+
return ensemble_table
|
|
96
|
+
return self.processors[self._route].transform_ensemble(ensemble_table)
|
|
97
|
+
|
|
98
|
+
def get_extra_state(self) -> str | None:
|
|
99
|
+
r""":meta private:""" # noqa: D415
|
|
100
|
+
return self._route
|
|
101
|
+
|
|
102
|
+
def set_extra_state(self, state: object) -> None:
|
|
103
|
+
r""":meta private:""" # noqa: D415
|
|
104
|
+
self._route = cast(Literal["task", "related"] | None, state)
|
|
105
|
+
|
|
106
|
+
def __repr__(self, *, indent: int = 0) -> str:
|
|
107
|
+
if len(self.processors) == 0:
|
|
108
|
+
return super().__repr__(indent=indent)
|
|
109
|
+
|
|
110
|
+
reprs = []
|
|
111
|
+
for route, processor in self.processors.items():
|
|
112
|
+
processor = cast(Processor, processor)
|
|
113
|
+
processor_repr = processor.__repr__(indent=indent + 2)
|
|
114
|
+
processor_repr = processor_repr[indent + 2 :]
|
|
115
|
+
reprs.append(f"{' ' * (indent + 2)}{route}={processor_repr}")
|
|
116
|
+
return (
|
|
117
|
+
f"{' ' * indent}{self.__class__.__name__}(\n"
|
|
118
|
+
+ ",\n".join(reprs)
|
|
119
|
+
+ f",\n{' ' * indent})"
|
|
120
|
+
)
|
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
|
2
|
+
# SPDX-License-Identifier: Apache-2.0
|
|
3
|
+
|
|
4
|
+
from typing import Literal, cast
|
|
5
|
+
|
|
6
|
+
import torch
|
|
7
|
+
from torch.nn import ModuleDict
|
|
8
|
+
|
|
9
|
+
from sdm import EnsembleTable, Stype, TableTensor
|
|
10
|
+
from sdm.processing import EnsembleProcessor, Processor
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
class TaskDispatch(EnsembleProcessor):
|
|
14
|
+
"""Apply separate processors based on the semantic type of the target.
|
|
15
|
+
|
|
16
|
+
:class:`TaskDispatch` is resolved only during model execution.
|
|
17
|
+
|
|
18
|
+
Args:
|
|
19
|
+
classification: Processor selected for a categorical target.
|
|
20
|
+
regression: Processor selected for a numerical target.
|
|
21
|
+
"""
|
|
22
|
+
|
|
23
|
+
def __init__(
|
|
24
|
+
self,
|
|
25
|
+
*,
|
|
26
|
+
classification: object = None,
|
|
27
|
+
regression: object = None,
|
|
28
|
+
) -> None:
|
|
29
|
+
super().__init__()
|
|
30
|
+
self.processors: ModuleDict[EnsembleProcessor] = ModuleDict()
|
|
31
|
+
for task, processor in (
|
|
32
|
+
("classification", classification),
|
|
33
|
+
("regression", regression),
|
|
34
|
+
):
|
|
35
|
+
if processor is None:
|
|
36
|
+
continue
|
|
37
|
+
processor = EnsembleProcessor.as_processor(processor)
|
|
38
|
+
self.processors[task] = processor
|
|
39
|
+
|
|
40
|
+
self.requires_fit = any(
|
|
41
|
+
processor.requires_fit for processor in self.processors.values()
|
|
42
|
+
)
|
|
43
|
+
self._task: Literal["classification", "regression"] | None = None
|
|
44
|
+
|
|
45
|
+
@property
|
|
46
|
+
def handles_stypes(self) -> frozenset[Stype]:
|
|
47
|
+
r""":meta private:""" # noqa: D415
|
|
48
|
+
if self._task is None:
|
|
49
|
+
return frozenset(
|
|
50
|
+
stype
|
|
51
|
+
for processor in self.processors.values()
|
|
52
|
+
for stype in processor.handles_stypes
|
|
53
|
+
)
|
|
54
|
+
if self._task not in self.processors:
|
|
55
|
+
return frozenset()
|
|
56
|
+
return self.processors[self._task].handles_stypes
|
|
57
|
+
|
|
58
|
+
def _processor(self) -> EnsembleProcessor:
|
|
59
|
+
if self._task is None:
|
|
60
|
+
raise RuntimeError(
|
|
61
|
+
f"{self.__class__.__name__!r} has no resolved task; use it "
|
|
62
|
+
"in a 'Recipe' through model execution"
|
|
63
|
+
)
|
|
64
|
+
return self.processors[self._task]
|
|
65
|
+
|
|
66
|
+
def _fit(
|
|
67
|
+
self,
|
|
68
|
+
table: TableTensor,
|
|
69
|
+
*,
|
|
70
|
+
generator: torch.Generator | None = None,
|
|
71
|
+
) -> None:
|
|
72
|
+
self._processor().fit(table, generator=generator)
|
|
73
|
+
|
|
74
|
+
def _fit_transform(
|
|
75
|
+
self,
|
|
76
|
+
table: TableTensor,
|
|
77
|
+
*,
|
|
78
|
+
generator: torch.Generator | None = None,
|
|
79
|
+
) -> TableTensor:
|
|
80
|
+
return self._processor().fit_transform(table, generator=generator)
|
|
81
|
+
|
|
82
|
+
def _transform(self, table: TableTensor) -> TableTensor:
|
|
83
|
+
return self._processor().transform(table)
|
|
84
|
+
|
|
85
|
+
def _fit_ensemble(
|
|
86
|
+
self,
|
|
87
|
+
ensemble_table: EnsembleTable,
|
|
88
|
+
*,
|
|
89
|
+
generator: torch.Generator | None = None,
|
|
90
|
+
) -> None:
|
|
91
|
+
self._processor().fit_ensemble(ensemble_table, generator=generator)
|
|
92
|
+
|
|
93
|
+
def _fit_transform_ensemble(
|
|
94
|
+
self,
|
|
95
|
+
ensemble_table: EnsembleTable,
|
|
96
|
+
*,
|
|
97
|
+
generator: torch.Generator | None = None,
|
|
98
|
+
) -> EnsembleTable:
|
|
99
|
+
return self._processor().fit_transform_ensemble(
|
|
100
|
+
ensemble_table,
|
|
101
|
+
generator=generator,
|
|
102
|
+
)
|
|
103
|
+
|
|
104
|
+
def _transform_ensemble(
|
|
105
|
+
self,
|
|
106
|
+
ensemble_table: EnsembleTable,
|
|
107
|
+
) -> EnsembleTable:
|
|
108
|
+
return self._processor().transform_ensemble(ensemble_table)
|
|
109
|
+
|
|
110
|
+
def get_extra_state(self) -> str | None:
|
|
111
|
+
r""":meta private:""" # noqa: D415
|
|
112
|
+
return self._task
|
|
113
|
+
|
|
114
|
+
def set_extra_state(self, state: object) -> None:
|
|
115
|
+
r""":meta private:""" # noqa: D415
|
|
116
|
+
self._task = cast(
|
|
117
|
+
Literal["classification", "regression"] | None,
|
|
118
|
+
state,
|
|
119
|
+
)
|
|
120
|
+
|
|
121
|
+
def __repr__(self, *, indent: int = 0) -> str:
|
|
122
|
+
if len(self.processors) == 0:
|
|
123
|
+
return super().__repr__(indent=indent)
|
|
124
|
+
|
|
125
|
+
reprs = []
|
|
126
|
+
for task, processor in self.processors.items():
|
|
127
|
+
processor = cast(Processor, processor)
|
|
128
|
+
processor_repr = processor.__repr__(indent=indent + 2)
|
|
129
|
+
processor_repr = processor_repr[indent + 2 :]
|
|
130
|
+
reprs.append(f"{' ' * (indent + 2)}{task}={processor_repr}")
|
|
131
|
+
return (
|
|
132
|
+
f"{' ' * indent}{self.__class__.__name__}(\n"
|
|
133
|
+
+ ",\n".join(reprs)
|
|
134
|
+
+ f",\n{' ' * indent})"
|
|
135
|
+
)
|
|
@@ -0,0 +1,60 @@
|
|
|
1
|
+
# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
|
2
|
+
# SPDX-License-Identifier: Apache-2.0
|
|
3
|
+
|
|
4
|
+
from typing import cast
|
|
5
|
+
|
|
6
|
+
import torch
|
|
7
|
+
|
|
8
|
+
from sdm import Stype, TableTensor
|
|
9
|
+
from sdm.processing import Processor
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
class ToNumerical(Processor):
|
|
13
|
+
"""Move categorical columns into the numerical block.
|
|
14
|
+
|
|
15
|
+
This is an stype conversion step:
|
|
16
|
+
:class:`~sdm.tensor.CategoricalTensor` already stores ordinal category ids
|
|
17
|
+
and the category vocabulary. ``ToNumerical`` reuses those existing ids,
|
|
18
|
+
casts them to the numerical dtype, and clears the categorical block so
|
|
19
|
+
numerical-only models can consume both original numerical and categorical
|
|
20
|
+
features. Missing categorical values remain ``-1``.
|
|
21
|
+
|
|
22
|
+
Unhandled semantic types are preserved unchanged.
|
|
23
|
+
|
|
24
|
+
"""
|
|
25
|
+
|
|
26
|
+
requires_fit = False
|
|
27
|
+
handles_stypes = frozenset({Stype.numerical, Stype.categorical})
|
|
28
|
+
|
|
29
|
+
def _transform(self, table: TableTensor) -> TableTensor:
|
|
30
|
+
"""Return ``table`` with categorical columns moved to ``numerical``."""
|
|
31
|
+
# Already numerical-only: nothing to move.
|
|
32
|
+
if all(
|
|
33
|
+
stype == Stype.numerical or block.size(-1) == 0
|
|
34
|
+
for stype, block in table.items()
|
|
35
|
+
):
|
|
36
|
+
return table
|
|
37
|
+
|
|
38
|
+
# Casting to the (floating-point) numerical dtype also unwraps a
|
|
39
|
+
# CategoricalTensor to its raw ordinal ids as a plain tensor.
|
|
40
|
+
categorical = table.categorical.to(table.numerical.dtype)
|
|
41
|
+
columns = (
|
|
42
|
+
*table.columns[Stype.numerical],
|
|
43
|
+
*table.columns[Stype.categorical],
|
|
44
|
+
)
|
|
45
|
+
numerical = (
|
|
46
|
+
categorical
|
|
47
|
+
if table.numerical.size(-1) == 0
|
|
48
|
+
else torch.cat((table.numerical, categorical), dim=-1)
|
|
49
|
+
)
|
|
50
|
+
out = table.__class__(
|
|
51
|
+
columns={Stype.numerical: columns},
|
|
52
|
+
numerical=numerical,
|
|
53
|
+
)
|
|
54
|
+
return cast(
|
|
55
|
+
TableTensor,
|
|
56
|
+
torch.cat(
|
|
57
|
+
(table.drop_stypes((Stype.numerical, Stype.categorical)), out),
|
|
58
|
+
dim=-1,
|
|
59
|
+
),
|
|
60
|
+
)
|
|
@@ -0,0 +1,8 @@
|
|
|
1
|
+
# SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
|
|
2
|
+
# SPDX-License-Identifier: Apache-2.0
|
|
3
|
+
|
|
4
|
+
"""Datetime preprocessing transforms."""
|
|
5
|
+
|
|
6
|
+
from sdm.processing.datetime.calendar import AddCalendarFields
|
|
7
|
+
|
|
8
|
+
__all__ = ["AddCalendarFields"]
|