kumoai 2.13.0.dev202511271731__cp312-cp312-win_amd64.whl → 2.14.0.dev202512111731__cp312-cp312-win_amd64.whl

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

@@ -0,0 +1,313 @@
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+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
+from kumoai.experimental.rfm.pquery import PQueryPandasExecutor
+from kumoai.utils import ProgressLogger
+
+if TYPE_CHECKING:
+    from kumoai.experimental.rfm import Graph
+
+
+class LocalSampler(Sampler):
+    def __init__(
+        self,
+        graph: 'Graph',
+        verbose: bool | ProgressLogger = True,
+    ) -> None:
+        super().__init__(graph=graph)
+
+        import kumoai.kumolib as kumolib
+
+        self._graph_store = LocalGraphStore(graph, verbose)
+        self._graph_sampler = kumolib.NeighborSampler(
+            list(self.table_stype_dict.keys()),
+            self.edge_types,
+            {
+                '__'.join(edge_type): colptr
+                for edge_type, colptr in self._graph_store.colptr_dict.items()
+            },
+            {
+                '__'.join(edge_type): row
+                for edge_type, row in self._graph_store.row_dict.items()
+            },
+            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 | Literal['entity'],
+        columns_dict: dict[str, set[str]],
+        num_neighbors: list[int],
+    ) -> SamplerOutput:
+
+        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,
+            col_dict,
+            node_dict,
+            batch_dict,
+            num_sampled_nodes_dict,
+            num_sampled_edges_dict,
+        ) = self._graph_sampler.sample(
+            {
+                '__'.join(edge_type): num_neighbors
+                for edge_type in self.edge_types
+            },
+            {},
+            entity_table_name,
+            index,
+            time,
+        )
+
+        df_dict: dict[str, pd.DataFrame] = {}
+        inverse_dict: dict[str, np.ndarray] = {}
+        for table_name, node in node_dict.items():
+            df = self._graph_store.df_dict[table_name]
+            columns = columns_dict[table_name]
+            if self.end_time_column_dict.get(table_name, None) in columns:
+                df = df.iloc[node]
+            elif len(columns) == 0:
+                df = df.iloc[node]
+            else:
+                # Only store unique rows in `df` above a certain threshold:
+                unique_node, inverse = np.unique(node, return_inverse=True)
+                if len(node) > 1.05 * len(unique_node):
+                    df = df.iloc[unique_node]
+                    inverse_dict[table_name] = inverse
+                else:
+                    df = df.iloc[node]
+            df = df.reset_index(drop=True)
+            df = df[list(columns)]
+            df_dict[table_name] = df
+
+        num_sampled_nodes_dict = {
+            table_name: num_sampled_nodes.tolist()
+            for table_name, num_sampled_nodes in
+            num_sampled_nodes_dict.items()
+        }
+
+        row_dict = {
+            edge_type: row_dict['__'.join(edge_type)]
+            for edge_type in self.edge_types
+        }
+        col_dict = {
+            edge_type: col_dict['__'.join(edge_type)]
+            for edge_type in self.edge_types
+        }
+        num_sampled_edges_dict = {
+            edge_type: num_sampled_edges_dict['__'.join(edge_type)].tolist()
+            for edge_type in self.edge_types
+        }
+
+        return SamplerOutput(
+            anchor_time=time * 1000**3,  # to nanoseconds
+            df_dict=df_dict,
+            inverse_dict=inverse_dict,
+            batch_dict=batch_dict,
+            num_sampled_nodes_dict=num_sampled_nodes_dict,
+            row_dict=row_dict,
+            col_dict=col_dict,
+            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,
+        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],
+        ],
+    ) -> tuple[pd.Series, np.ndarray, pd.Series, np.ndarray]:
+
+        train_y, train_mask = self._sample_target_set(
+            query=query,
+            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,
+        )
+
+        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,
+        )
+
+        return train_y, train_mask, test_y, test_mask
+
+    def _sample_target_set(
+        self,
+        query: ValidatedPredictiveQuery,
+        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]]] = {}
+        for edge_type, (start, end) in time_offset_dict.items():
+            unix_time_offset_dict['__'.join(edge_type)] = [[
+                date_offset_to_seconds(start) if start is not None else None,
+                date_offset_to_seconds(end),
+            ]]
+        for edge_type in set(self.edge_types) - set(time_offset_dict.keys()):
+            num_neighbors_dict['__'.join(edge_type)] = [0] * num_hops
+
+        if anchor_time.dtype != 'datetime64[ns]':
+            anchor_time = anchor_time.astype('datetime64')
+
+        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]
+
+            _, _, 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
+            )
+
+            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 ##############################################################
+
+
+def date_offset_to_seconds(offset: pd.DateOffset) -> int:
+    r"""Convert a :class:`pandas.DateOffset` into a number of seconds.
+
+    .. note::
+        We are conservative and take months and years as their maximum value.
+        Additional values are then dropped in label computation where we know
+        the actual dates.
+    """
+    MAX_DAYS_IN_MONTH = 31
+    MAX_DAYS_IN_YEAR = 366
+
+    SECONDS_IN_MINUTE = 60
+    SECONDS_IN_HOUR = 60 * SECONDS_IN_MINUTE
+    SECONDS_IN_DAY = 24 * SECONDS_IN_HOUR
+
+    total_sec = 0
+    multiplier = getattr(offset, 'n', 1)  # The multiplier (if present).
+
+    for attr, value in offset.__dict__.items():
+        if value is None or value == 0:
+            continue
+        scaled_value = value * multiplier
+        if attr == 'years':
+            total_sec += scaled_value * MAX_DAYS_IN_YEAR * SECONDS_IN_DAY
+        elif attr == 'months':
+            total_sec += scaled_value * MAX_DAYS_IN_MONTH * SECONDS_IN_DAY
+        elif attr == 'days':
+            total_sec += scaled_value * SECONDS_IN_DAY
+        elif attr == 'hours':
+            total_sec += scaled_value * SECONDS_IN_HOUR
+        elif attr == 'minutes':
+            total_sec += scaled_value * SECONDS_IN_MINUTE
+        elif attr == 'seconds':
+            total_sec += scaled_value
+
+    return total_sec

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

@@ -0,0 +1,109 @@
+import warnings
+from typing import List, Optional
+
+import pandas as pd
+
+from kumoai.experimental.rfm.base import SourceColumn, SourceForeignKey, Table
+from kumoai.experimental.rfm.infer import infer_dtype
+
+
+class LocalTable(Table):
+    r"""A table backed by a :class:`pandas.DataFrame`.
+
+    A :class:`LocalTable` fully specifies the relevant metadata, *i.e.*
+    selected columns, column semantic types, primary keys and time columns.
+    :class:`LocalTable` is used to create a :class:`Graph`.
+
+    .. code-block:: python
+
+        import pandas as pd
+        import kumoai.experimental.rfm as rfm
+
+        # Load data from a CSV file:
+        df = pd.read_csv("data.csv")
+
+        # Create a table from a `pandas.DataFrame` and infer its metadata ...
+        table = rfm.LocalTable(df, name="my_table").infer_metadata()
+
+        # ... or create a table explicitly:
+        table = rfm.LocalTable(
+            df=df,
+            name="my_table",
+            primary_key="id",
+            time_column="time",
+            end_time_column=None,
+        )
+
+        # Verify metadata:
+        table.print_metadata()
+
+        # Change the semantic type of a column:
+        table[column].stype = "text"
+
+    Args:
+        df: The data frame to create this table from.
+        name: The name of this table.
+        primary_key: The name of the primary key of this table, if it exists.
+        time_column: The name of the time column of this table, if it exists.
+        end_time_column: The name of the end time column of this table, if it
+            exists.
+    """
+    def __init__(
+        self,
+        df: pd.DataFrame,
+        name: str,
+        primary_key: Optional[str] = None,
+        time_column: Optional[str] = None,
+        end_time_column: Optional[str] = None,
+    ) -> None:
+
+        if df.empty:
+            raise ValueError("Data frame is empty")
+        if isinstance(df.columns, pd.MultiIndex):
+            raise ValueError("Data frame must not have a multi-index")
+        if not df.columns.is_unique:
+            raise ValueError("Data frame must have unique column names")
+        if any(col == '' for col in df.columns):
+            raise ValueError("Data frame must have non-empty column names")
+
+        self._data = df.copy(deep=False)
+
+        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,
+                is_primary_key=False,
+                is_unique_key=False,
+            )
+            source_columns.append(source_column)
+
+        return source_columns
+
+    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
+        return []
+
+    def _get_sample_df(self) -> pd.DataFrame:
+        return self._data
+
+    def _get_num_rows(self) -> Optional[int]:
+        return len(self._data)

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

@@ -0,0 +1,35 @@
+from typing import Any, TypeAlias
+
+try:
+    import snowflake.connector
+except ImportError:
+    raise ImportError("No module named 'snowflake'. Please install Kumo SDK "
+                      "with the 'snowflake' extension via "
+                      "`pip install kumoai[snowflake]`.")
+
+Connection: TypeAlias = snowflake.connector.SnowflakeConnection
+
+
+def connect(**kwargs: Any) -> Connection:
+    r"""Opens a connection to a :class:`snowflake` database.
+
+    If available, will return a connection to the active session.
+
+    kwargs: Connection arguments, following the :class:`snowflake` protocol.
+    """
+    try:
+        from snowflake.snowpark.context import get_active_session
+        return get_active_session().connection
+    except Exception:
+        pass
+
+    return snowflake.connector.connect(**kwargs)
+
+
+from .table import SnowTable  # noqa: E402
+
+__all__ = [
+    'connect',
+    'Connection',
+    'SnowTable',
+]

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

@@ -0,0 +1,117 @@
+import re
+from typing import List, Optional, Sequence
+
+import pandas as pd
+from kumoapi.typing import Dtype
+
+from kumoai.experimental.rfm.backend.snow import Connection
+from kumoai.experimental.rfm.base import SourceColumn, SourceForeignKey, Table
+
+
+class SnowTable(Table):
+    r"""A table backed by a :class:`sqlite` database.
+
+    Args:
+        connection: The connection to a :class:`snowflake` database.
+        name: The name of this table.
+        database: The database.
+        schema: The schema.
+        columns: The selected columns of this table.
+        primary_key: The name of the primary key of this table, if it exists.
+        time_column: The name of the time column of this table, if it exists.
+        end_time_column: The name of the end time column of this table, if it
+            exists.
+    """
+    def __init__(
+        self,
+        connection: Connection,
+        name: str,
+        database: str | None = None,
+        schema: str | None = None,
+        columns: Optional[Sequence[str]] = None,
+        primary_key: Optional[str] = None,
+        time_column: Optional[str] = None,
+        end_time_column: Optional[str] = None,
+    ) -> None:
+
+        if database is not None and schema is None:
+            raise ValueError(f"Missing 'schema' for table '{name}' in "
+                             f"database '{database}'")
+
+        self._connection = connection
+        self._database = database
+        self._schema = schema
+
+        super().__init__(
+            name=name,
+            columns=columns,
+            primary_key=primary_key,
+            time_column=time_column,
+            end_time_column=end_time_column,
+        )
+
+    @property
+    def fqn_name(self) -> str:
+        names: List[str] = []
+        if self._database is not None:
+            assert self._schema is not None
+            names.extend([self._database, self._schema])
+        elif self._schema is not None:
+            names.append(self._schema)
+        names.append(self._name)
+        return '.'.join(names)
+
+    def _get_source_columns(self) -> List[SourceColumn]:
+        source_columns: List[SourceColumn] = []
+        with self._connection.cursor() as cursor:
+            try:
+                cursor.execute(f"DESCRIBE TABLE {self.fqn_name}")
+            except Exception as e:
+                raise ValueError(
+                    f"Table '{self.fqn_name}' does not exist") from e
+
+            for row in cursor.fetchall():
+                column, type, _, _, _, is_pkey, is_unique = row[:7]
+
+                type = type.strip().upper()
+                if type.startswith('NUMBER'):
+                    dtype = Dtype.int
+                elif type.startswith('VARCHAR'):
+                    dtype = Dtype.string
+                elif type == 'FLOAT':
+                    dtype = Dtype.float
+                elif type == 'BOOLEAN':
+                    dtype = Dtype.bool
+                elif re.search('DATE|TIMESTAMP', type):
+                    dtype = Dtype.date
+                else:
+                    continue
+
+                source_column = SourceColumn(
+                    name=column,
+                    dtype=dtype,
+                    is_primary_key=is_pkey.strip().upper() == 'Y',
+                    is_unique_key=is_unique.strip().upper() == 'Y',
+                )
+                source_columns.append(source_column)
+
+        return source_columns
+
+    def _get_source_foreign_keys(self) -> List[SourceForeignKey]:
+        source_fkeys: List[SourceForeignKey] = []
+        with self._connection.cursor() as cursor:
+            cursor.execute(f"SHOW IMPORTED KEYS IN TABLE {self.fqn_name}")
+            for row in cursor.fetchall():
+                _, _, _, dst_table, pkey, _, _, _, fkey = row[:9]
+                source_fkeys.append(SourceForeignKey(fkey, dst_table, pkey))
+        return source_fkeys
+
+    def _get_sample_df(self) -> pd.DataFrame:
+        with self._connection.cursor() as cursor:
+            columns = ', '.join(self._source_column_dict.keys())
+            cursor.execute(f"SELECT {columns} FROM {self.fqn_name} LIMIT 1000")
+            table = cursor.fetch_arrow_all()
+            return table.to_pandas(types_mapper=pd.ArrowDtype)
+
+    def _get_num_rows(self) -> Optional[int]:
+        return None

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

@@ -0,0 +1,30 @@
+from pathlib import Path
+from typing import Any, TypeAlias, Union
+
+try:
+    import adbc_driver_sqlite.dbapi as adbc
+except ImportError:
+    raise ImportError("No module named 'adbc_driver_sqlite'. Please install "
+                      "Kumo SDK with the 'sqlite' extension via "
+                      "`pip install kumoai[sqlite]`.")
+
+Connection: TypeAlias = adbc.AdbcSqliteConnection
+
+
+def connect(uri: Union[str, Path, None] = None, **kwargs: Any) -> Connection:
+    r"""Opens a connection to a :class:`sqlite` database.
+
+    uri: The path to the database file to be opened.
+    kwargs: Additional connection arguments, following the
+        :class:`adbc_driver_sqlite` protocol.
+    """
+    return adbc.connect(uri, **kwargs)
+
+
+from .table import SQLiteTable  # noqa: E402
+
+__all__ = [
+    'connect',
+    'Connection',
+    'SQLiteTable',
+]