kumoai 2.13.0.dev202512091732__cp311-cp311-macosx_11_0_arm64.whl → 2.14.0.dev202601051732__cp311-cp311-macosx_11_0_arm64.whl

kumoai/experimental/rfm/backend/local/graph_store.py

@@ -1,13 +1,12 @@
-import warnings
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
 from kumoapi.rfm.context import Subgraph
-from kumoapi.typing import Stype
 
 from kumoai.experimental.rfm.backend.local import LocalTable
-from kumoai.utils import InteractiveProgressLogger, ProgressLogger
+from kumoai.experimental.rfm.base import Table
+from kumoai.utils import ProgressLogger
 
 try:
     import torch
@@ -23,37 +22,32 @@ class LocalGraphStore:
     def __init__(
         self,
         graph: 'Graph',
-        verbose: Union[bool, ProgressLogger] = True,
+        verbose: bool | ProgressLogger = True,
     ) -> None:
 
         if not isinstance(verbose, ProgressLogger):
-            verbose = InteractiveProgressLogger(
-                "Materializing graph",
+            verbose = ProgressLogger.default(
+                msg="Materializing graph",
                 verbose=verbose,
             )
 
         with verbose as logger:
             self.df_dict, self.mask_dict = self.sanitize(graph)
-            self.stype_dict = self.get_stype_dict(graph)
             logger.log("Sanitized input data")
 
-            self.pkey_name_dict, self.pkey_map_dict = self.get_pkey_data(graph)
+            self.pkey_map_dict = self.get_pkey_map_dict(graph)
             num_pkeys = sum(t.has_primary_key() for t in graph.tables.values())
             if num_pkeys > 1:
                 logger.log(f"Collected primary keys from {num_pkeys} tables")
             else:
                 logger.log(f"Collected primary key from {num_pkeys} table")
 
-            (
-                self.time_column_dict,
-                self.end_time_column_dict,
-                self.time_dict,
-                self.min_time,
-                self.max_time,
-            ) = self.get_time_data(graph)
-            if self.max_time != pd.Timestamp.min:
+            self.time_dict, self.min_max_time_dict = self.get_time_data(graph)
+            if len(self.min_max_time_dict) > 0:
+                min_time = min(t for t, _ in self.min_max_time_dict.values())
+                max_time = max(t for _, t in self.min_max_time_dict.values())
                 logger.log(f"Identified temporal graph from "
-                           f"{self.min_time.date()} to {self.max_time.date()}")
+                           f"{min_time.date()} to {max_time.date()}")
             else:
                 logger.log("Identified static graph without timestamps")
 
@@ -63,14 +57,6 @@ class LocalGraphStore:
             logger.log(f"Created graph with {num_nodes:,} nodes and "
                        f"{num_edges:,} edges")
 
-    @property
-    def node_types(self) -> List[str]:
-        return list(self.df_dict.keys())
-
-    @property
-    def edge_types(self) -> List[Tuple[str, str, str]]:
-        return list(self.row_dict.keys())
-
     def get_node_id(self, table_name: str, pkey: pd.Series) -> np.ndarray:
         r"""Returns the node ID given primary keys.
 
@@ -107,7 +93,7 @@ class LocalGraphStore:
     def sanitize(
         self,
         graph: 'Graph',
-    ) -> Tuple[Dict[str, pd.DataFrame], Dict[str, np.ndarray]]:
+    ) -> tuple[dict[str, pd.DataFrame], dict[str, np.ndarray]]:
         r"""Sanitizes raw data according to table schema definition:
 
         In particular, it:
@@ -116,30 +102,24 @@ class LocalGraphStore:
         * drops duplicate primary keys
         * removes rows with missing primary keys or time values
         """
-        df_dict: Dict[str, pd.DataFrame] = {}
+        df_dict: dict[str, pd.DataFrame] = {}
         for table_name, table in graph.tables.items():
             assert isinstance(table, LocalTable)
-            df = table._data
-            df_dict[table_name] = df.copy(deep=False).reset_index(drop=True)
+            df_dict[table_name] = Table._sanitize(
+                df=table._data.copy(deep=False).reset_index(drop=True),
+                dtype_dict={
+                    column.name: column.dtype
+                    for column in table.columns
+                },
+                stype_dict={
+                    column.name: column.stype
+                    for column in table.columns
+                },
+            )
 
-        mask_dict: Dict[str, np.ndarray] = {}
+        mask_dict: dict[str, np.ndarray] = {}
         for table in graph.tables.values():
-            for col in table.columns:
-                if col.stype == Stype.timestamp:
-                    ser = df_dict[table.name][col.name]
-                    if not pd.api.types.is_datetime64_any_dtype(ser):
-                        with warnings.catch_warnings():
-                            warnings.filterwarnings(
-                                'ignore',
-                                message='Could not infer format',
-                            )
-                            ser = pd.to_datetime(ser, errors='coerce')
-                        df_dict[table.name][col.name] = ser
-                    if isinstance(ser.dtype, pd.DatetimeTZDtype):
-                        ser = ser.dt.tz_localize(None)
-                        df_dict[table.name][col.name] = ser
-
-            mask: Optional[np.ndarray] = None
+            mask: np.ndarray | None = None
             if table._time_column is not None:
                 ser = df_dict[table.name][table._time_column]
                 mask = ser.notna().to_numpy()
@@ -154,34 +134,16 @@ class LocalGraphStore:
 
         return df_dict, mask_dict
 
-    def get_stype_dict(self, graph: 'Graph') -> Dict[str, Dict[str, Stype]]:
-        stype_dict: Dict[str, Dict[str, Stype]] = {}
-        foreign_keys = {(edge.src_table, edge.fkey) for edge in graph.edges}
-        for table in graph.tables.values():
-            stype_dict[table.name] = {}
-            for column in table.columns:
-                if column == table.primary_key:
-                    continue
-                if (table.name, column.name) in foreign_keys:
-                    continue
-                stype_dict[table.name][column.name] = column.stype
-        return stype_dict
-
-    def get_pkey_data(
+    def get_pkey_map_dict(
         self,
         graph: 'Graph',
-    ) -> Tuple[
-            Dict[str, str],
-            Dict[str, pd.DataFrame],
-    ]:
-        pkey_name_dict: Dict[str, str] = {}
-        pkey_map_dict: Dict[str, pd.DataFrame] = {}
+    ) -> dict[str, pd.DataFrame]:
+        pkey_map_dict: dict[str, pd.DataFrame] = {}
 
         for table in graph.tables.values():
             if table._primary_key is None:
                 continue
 
-            pkey_name_dict[table.name] = table._primary_key
             pkey = self.df_dict[table.name][table._primary_key]
             pkey_map = pd.DataFrame(
                 dict(arange=range(len(pkey))),
@@ -203,62 +165,48 @@ class LocalGraphStore:
 
             pkey_map_dict[table.name] = pkey_map
 
-        return pkey_name_dict, pkey_map_dict
+        return pkey_map_dict
 
     def get_time_data(
         self,
         graph: 'Graph',
-    ) -> Tuple[
-            Dict[str, str],
-            Dict[str, str],
-            Dict[str, np.ndarray],
-            pd.Timestamp,
-            pd.Timestamp,
+    ) -> tuple[
+            dict[str, np.ndarray],
+            dict[str, tuple[pd.Timestamp, pd.Timestamp]],
     ]:
-        time_column_dict: Dict[str, str] = {}
-        end_time_column_dict: Dict[str, str] = {}
-        time_dict: Dict[str, np.ndarray] = {}
-        min_time = pd.Timestamp.max
-        max_time = pd.Timestamp.min
+        time_dict: dict[str, np.ndarray] = {}
+        min_max_time_dict: dict[str, tuple[pd.Timestamp, pd.Timestamp]] = {}
         for table in graph.tables.values():
-            if table._end_time_column is not None:
-                end_time_column_dict[table.name] = table._end_time_column
-
             if table._time_column is None:
                 continue
 
             time = self.df_dict[table.name][table._time_column]
-            if time.dtype != 'datetime64[ns]':
-                time = time.astype('datetime64[ns]')
             time_dict[table.name] = time.astype(int).to_numpy() // 1000**3
-            time_column_dict[table.name] = table._time_column
 
             if table.name in self.mask_dict.keys():
                 time = time[self.mask_dict[table.name]]
             if len(time) > 0:
-                min_time = min(min_time, time.min())
-                max_time = max(max_time, time.max())
+                min_max_time_dict[table.name] = (time.min(), time.max())
+            else:
+                min_max_time_dict[table.name] = (
+                    pd.Timestamp.max,
+                    pd.Timestamp.min,
+                )
 
-        return (
-            time_column_dict,
-            end_time_column_dict,
-            time_dict,
-            min_time,
-            max_time,
-        )
+        return time_dict, min_max_time_dict
 
     def get_csc(
         self,
         graph: 'Graph',
-    ) -> Tuple[
-            Dict[Tuple[str, str, str], np.ndarray],
-            Dict[Tuple[str, str, str], np.ndarray],
+    ) -> tuple[
+            dict[tuple[str, str, str], np.ndarray],
+            dict[tuple[str, str, str], np.ndarray],
     ]:
         # A mapping from raw primary keys to node indices (0 to N-1):
-        map_dict: Dict[str, pd.CategoricalDtype] = {}
+        map_dict: dict[str, pd.CategoricalDtype] = {}
         # A dictionary to manage offsets of node indices for invalid rows:
-        offset_dict: Dict[str, np.ndarray] = {}
-        for table_name in set(edge.dst_table for edge in graph.edges):
+        offset_dict: dict[str, np.ndarray] = {}
+        for table_name in {edge.dst_table for edge in graph.edges}:
             ser = self.df_dict[table_name][graph[table_name]._primary_key]
             if table_name in self.mask_dict.keys():
                 mask = self.mask_dict[table_name]
@@ -267,8 +215,8 @@ class LocalGraphStore:
             map_dict[table_name] = pd.CategoricalDtype(ser, ordered=True)
 
         # Build CSC graph representation:
-        row_dict: Dict[Tuple[str, str, str], np.ndarray] = {}
-        colptr_dict: Dict[Tuple[str, str, str], np.ndarray] = {}
+        row_dict: dict[tuple[str, str, str], np.ndarray] = {}
+        colptr_dict: dict[tuple[str, str, str], np.ndarray] = {}
         for src_table, fkey, dst_table in graph.edges:
             src_df = self.df_dict[src_table]
             dst_df = self.df_dict[dst_table]
@@ -330,7 +278,7 @@ def _argsort(input: np.ndarray) -> np.ndarray:
     return torch.from_numpy(input).argsort().numpy()
 
 
-def _lexsort(inputs: List[np.ndarray]) -> np.ndarray:
+def _lexsort(inputs: list[np.ndarray]) -> np.ndarray:
     assert len(inputs) >= 1
 
     if not WITH_TORCH:

kumoai/experimental/rfm/backend/local/sampler.py

@@ -5,7 +5,7 @@ import pandas as pd
 from kumoapi.pquery import ValidatedPredictiveQuery
 
 from kumoai.experimental.rfm.backend.local import LocalGraphStore
-from kumoai.experimental.rfm.base import Sampler, SamplerOutput, TargetOutput
+from kumoai.experimental.rfm.base import Sampler, SamplerOutput
 from kumoai.experimental.rfm.pquery import PQueryPandasExecutor
 from kumoai.utils import ProgressLogger
 
@@ -19,7 +19,7 @@ class LocalSampler(Sampler):
         graph: 'Graph',
         verbose: bool | ProgressLogger = True,
     ) -> None:
-        super().__init__(graph=graph)
+        super().__init__(graph=graph, verbose=verbose)
 
         import kumoai.kumolib as kumolib
 
@@ -38,19 +38,32 @@ class LocalSampler(Sampler):
             self._graph_store.time_dict,
         )
 
+    def _get_min_max_time_dict(
+        self,
+        table_names: list[str],
+    ) -> dict[str, tuple[pd.Timestamp, pd.Timestamp]]:
+        return {
+            key: value
+            for key, value in self._graph_store.min_max_time_dict.items()
+            if key in table_names
+        }
+
     def _sample_subgraph(
         self,
         entity_table_name: str,
         entity_pkey: pd.Series,
-        anchor_time: pd.Series,
+        anchor_time: pd.Series | Literal['entity'],
         columns_dict: dict[str, set[str]],
         num_neighbors: list[int],
     ) -> SamplerOutput:
 
-        num_neighbors_dict: dict[str, list[int]] = {
-            '__'.join(edge_type): num_neighbors
-            for edge_type in self.edge_types
-        }
+        index = self._graph_store.get_node_id(entity_table_name, entity_pkey)
+
+        if isinstance(anchor_time, pd.Series):
+            time = anchor_time.astype(int).to_numpy() // 1000**3  # to seconds
+        else:
+            assert anchor_time == 'entity'
+            time = self._graph_store.time_dict[entity_table_name][index]
 
         (
             row_dict,
@@ -60,11 +73,14 @@ class LocalSampler(Sampler):
             num_sampled_nodes_dict,
             num_sampled_edges_dict,
         ) = self._graph_sampler.sample(
-            num_neighbors_dict,
+            {
+                '__'.join(edge_type): num_neighbors
+                for edge_type in self.edge_types
+            },
             {},
             entity_table_name,
-            self._graph_store.get_node_id(entity_table_name, entity_pkey),
-            anchor_time.astype(int).to_numpy() // 1000**3,  # to seconds
+            index,
+            time,
         )
 
         df_dict: dict[str, pd.DataFrame] = {}
@@ -108,6 +124,7 @@ class LocalSampler(Sampler):
         }
 
         return SamplerOutput(
+            anchor_time=time * 1000**3,  # to nanoseconds
             df_dict=df_dict,
             inverse_dict=inverse_dict,
             batch_dict=batch_dict,
@@ -117,51 +134,80 @@ class LocalSampler(Sampler):
             num_sampled_edges_dict=num_sampled_edges_dict,
         )
 
+    def _sample_entity_table(
+        self,
+        table_name: str,
+        columns: set[str],
+        num_rows: int,
+        random_seed: int | None = None,
+    ) -> pd.DataFrame:
+        pkey_map = self._graph_store.pkey_map_dict[table_name]
+        if len(pkey_map) > num_rows:
+            pkey_map = pkey_map.sample(
+                n=num_rows,
+                random_state=random_seed,
+                ignore_index=True,
+            )
+        df = self._graph_store.df_dict[table_name]
+        df = df.iloc[pkey_map['arange']][list(columns)]
+        return df
+
     def _sample_target(
         self,
         query: ValidatedPredictiveQuery,
-        num_examples: int,
-        anchor_time: pd.Timestamp | Literal['entity'],
+        entity_df: pd.DataFrame,
+        train_index: np.ndarray,
+        train_time: pd.Series,
+        num_train_examples: int,
+        test_index: np.ndarray,
+        test_time: pd.Series,
+        num_test_examples: int,
         columns_dict: dict[str, set[str]],
         time_offset_dict: dict[
             tuple[str, str, str],
             tuple[pd.DateOffset | None, pd.DateOffset],
         ],
-        random_seed: int | None = None,
-    ) -> TargetOutput:
-
-        candidate = pd.Series([0, 1])  # TODO
-        anchor_time = pd.Series(anchor_time).repeat(len(candidate))
-        anchor_time = anchor_time.reset_index(drop=True)
-        if anchor_time.dtype != 'datetime64[ns]':
-            anchor_time = anchor_time.astype('datetime64[ns]')
+    ) -> tuple[pd.Series, np.ndarray, pd.Series, np.ndarray]:
 
-        y, mask = self._execute_query(
+        train_y, train_mask = self._sample_target_set(
             query=query,
-            entity_pkey=candidate,
-            anchor_time=anchor_time,
+            pkey=entity_df[self.primary_key_dict[query.entity_table]],
+            index=train_index,
+            anchor_time=train_time,
+            num_examples=num_train_examples,
             columns_dict=columns_dict,
             time_offset_dict=time_offset_dict,
         )
 
-        return TargetOutput(
-            entity_pkey=candidate.iloc[mask],
-            anchor_time=anchor_time.iloc[mask],
-            target=y.iloc[mask],
-            num_trials=len(y),
+        test_y, test_mask = self._sample_target_set(
+            query=query,
+            pkey=entity_df[self.primary_key_dict[query.entity_table]],
+            index=test_index,
+            anchor_time=test_time,
+            num_examples=num_test_examples,
+            columns_dict=columns_dict,
+            time_offset_dict=time_offset_dict,
         )
 
-    def _execute_query(
+        return train_y, train_mask, test_y, test_mask
+
+    # Helper Methods ##########################################################
+
+    def _sample_target_set(
         self,
         query: ValidatedPredictiveQuery,
-        entity_pkey: pd.Series,
+        pkey: pd.Series,
+        index: np.ndarray,
         anchor_time: pd.Series,
+        num_examples: int,
         columns_dict: dict[str, set[str]],
         time_offset_dict: dict[
             tuple[str, str, str],
             tuple[pd.DateOffset | None, pd.DateOffset],
         ],
+        batch_size: int = 10_000,
     ) -> tuple[pd.Series, np.ndarray]:
+
         num_hops = 1 if len(time_offset_dict) > 0 else 0
         num_neighbors_dict: dict[str, list[int]] = {}
         unix_time_offset_dict: dict[str, list[list[int | None]]] = {}
@@ -173,35 +219,59 @@ class LocalSampler(Sampler):
         for edge_type in set(self.edge_types) - set(time_offset_dict.keys()):
             num_neighbors_dict['__'.join(edge_type)] = [0] * num_hops
 
-        _, _, node_dict, batch_dict, _, _ = self._graph_sampler.sample(
-            num_neighbors_dict,
-            unix_time_offset_dict,
-            query.entity_table,
-            self._graph_store.get_node_id(query.entity_table, entity_pkey),
-            anchor_time.astype(int).to_numpy() // 1000**3,
-        )
+        count = 0
+        ys: list[pd.Series] = []
+        mask = np.full(len(index), False, dtype=bool)
+        for start in range(0, len(index), batch_size):
+            subset = pkey.iloc[index[start:start + batch_size]]
+            time = anchor_time.iloc[start:start + batch_size]
 
-        feat_dict: dict[str, pd.DataFrame] = {}
-        time_dict: dict[str, pd.Series] = {}
-        for table_name, columns in columns_dict.items():
-            df = self._graph_store.df_dict[table_name]
-            df = df.iloc[node_dict[table_name]].reset_index(drop=True)
-            df = df[list(columns)]
-            feat_dict[table_name] = df
-            if time_column := self.time_column_dict.get(table_name):
-                time_dict[table_name] = df[time_column]
+            _, _, node_dict, batch_dict, _, _ = self._graph_sampler.sample(
+                num_neighbors_dict,
+                unix_time_offset_dict,
+                query.entity_table,
+                self._graph_store.get_node_id(query.entity_table, subset),
+                time.astype(int).to_numpy() // 1000**3,  # to seconds
+            )
 
-        return PQueryPandasExecutor().execute(
-            query=query,
-            feat_dict=feat_dict,
-            time_dict=time_dict,
-            batch_dict=batch_dict,
-            anchor_time=anchor_time,
-            num_forecasts=query.num_forecasts,
-        )
+            feat_dict: dict[str, pd.DataFrame] = {}
+            time_dict: dict[str, pd.Series] = {}
+            for table_name, columns in columns_dict.items():
+                df = self._graph_store.df_dict[table_name]
+                df = df.iloc[node_dict[table_name]].reset_index(drop=True)
+                df = df[list(columns)]
+                feat_dict[table_name] = df
+
+                time_column = self.time_column_dict.get(table_name)
+                if time_column in columns:
+                    time_dict[table_name] = df[time_column]
+
+            y, _mask = PQueryPandasExecutor().execute(
+                query=query,
+                feat_dict=feat_dict,
+                time_dict=time_dict,
+                batch_dict=batch_dict,
+                anchor_time=time,
+                num_forecasts=query.num_forecasts,
+            )
+            ys.append(y)
+            mask[start:start + batch_size] = _mask
+
+            count += len(y)
+            if count >= num_examples:
+                break
+
+        if len(ys) == 0:
+            y = pd.Series([], dtype=float)
+        elif len(ys) == 1:
+            y = ys[0]
+        else:
+            y = pd.concat(ys, axis=0, ignore_index=True)
+
+        return y, mask
 
 
-# Helper Methods ##############################################################
+# Helper Functions ############################################################
 
 
 def date_offset_to_seconds(offset: pd.DateOffset) -> int:

kumoai/experimental/rfm/backend/local/table.py

@@ -1,10 +1,15 @@
-import warnings
-from typing import List, Optional
+from typing import Sequence, cast
 
 import pandas as pd
+from kumoapi.model_plan import MissingType
 
-from kumoai.experimental.rfm.base import SourceColumn, SourceForeignKey, Table
-from kumoai.experimental.rfm.infer import infer_dtype
+from kumoai.experimental.rfm.base import (
+    ColumnSpec,
+    DataBackend,
+    SourceColumn,
+    SourceForeignKey,
+    Table,
+)
 
 
 class LocalTable(Table):
@@ -52,9 +57,9 @@ class LocalTable(Table):
         self,
         df: pd.DataFrame,
         name: str,
-        primary_key: Optional[str] = None,
-        time_column: Optional[str] = None,
-        end_time_column: Optional[str] = None,
+        primary_key: MissingType | str | None = MissingType.VALUE,
+        time_column: str | None = None,
+        end_time_column: str | None = None,
     ) -> None:
 
         if df.empty:
@@ -70,40 +75,39 @@ class LocalTable(Table):
 
         super().__init__(
             name=name,
-            columns=list(df.columns),
             primary_key=primary_key,
             time_column=time_column,
             end_time_column=end_time_column,
         )
 
-    def _get_source_columns(self) -> List[SourceColumn]:
-        source_columns: List[SourceColumn] = []
-        for column in self._data.columns:
-            ser = self._data[column]
-            try:
-                dtype = infer_dtype(ser)
-            except Exception:
-                warnings.warn(f"Data type inference for column '{column}' in "
-                              f"table '{self.name}' failed. Consider changing "
-                              f"the data type of the column to use it within "
-                              f"this table.")
-                continue
-
-            source_column = SourceColumn(
-                name=column,
-                dtype=dtype,
+    @property
+    def backend(self) -> DataBackend:
+        return cast(DataBackend, DataBackend.LOCAL)
+
+    def _get_source_columns(self) -> list[SourceColumn]:
+        return [
+            SourceColumn(
+                name=column_name,
+                dtype=None,
                 is_primary_key=False,
                 is_unique_key=False,
-            )
-            source_columns.append(source_column)
-
-        return source_columns
+                is_nullable=True,
+            ) for column_name in self._data.columns
+        ]
 
-    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
+    def _get_source_foreign_keys(self) -> list[SourceForeignKey]:
         return []
 
-    def _get_sample_df(self) -> pd.DataFrame:
+    def _get_source_sample_df(self) -> pd.DataFrame:
         return self._data
 
-    def _get_num_rows(self) -> Optional[int]:
+    def _get_expr_sample_df(
+        self,
+        columns: Sequence[ColumnSpec],
+    ) -> pd.DataFrame:
+        raise RuntimeError(f"Column expressions are not supported in "
+                           f"'{self.__class__.__name__}'. Please apply your "
+                           f"expressions on the `pd.DataFrame` directly.")
+
+    def _get_num_rows(self) -> int | None:
         return len(self._data)

kumoai/experimental/rfm/backend/snow/__init__.py

@@ -27,9 +27,11 @@ def connect(**kwargs: Any) -> Connection:
 
 
 from .table import SnowTable  # noqa: E402
+from .sampler import SnowSampler  # noqa: E402
 
 __all__ = [
     'connect',
     'Connection',
     'SnowTable',
+    'SnowSampler',
 ]