kumoai 2.13.0.dev202511261731__cp313-cp313-macosx_11_0_arm64.whl → 2.13.0.dev202512081731__cp313-cp313-macosx_11_0_arm64.whl

kumoai/experimental/rfm/base/sampler.py

@@ -0,0 +1,373 @@
+import copy
+import re
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+import pandas as pd
+from kumoapi.pquery import ValidatedPredictiveQuery
+from kumoapi.pquery.AST import Aggregation, ASTNode
+from kumoapi.rfm.context import EdgeLayout, Link, Subgraph, Table
+from kumoapi.typing import Stype
+
+if TYPE_CHECKING:
+    from kumoai.experimental.rfm import Graph
+
+
+@dataclass
+class BackwardSamplerOutput:
+    df_dict: dict[str, pd.DataFrame]
+    inverse_dict: dict[str, np.ndarray]
+    batch_dict: dict[str, np.ndarray]
+    num_sampled_nodes_dict: dict[str, list[int]]
+    row_dict: dict[tuple[str, str, str], np.ndarray]
+    col_dict: dict[tuple[str, str, str], np.ndarray]
+    num_sampled_edges_dict: dict[tuple[str, str, str], list[int]]
+
+
+@dataclass
+class ForwardSamplerOutput:
+    entity_pkey: pd.Series
+    anchor_time: pd.Series
+    target: pd.Series
+
+
+class Sampler(ABC):
+    def __init__(self, graph: 'Graph') -> None:
+        self._edge_types: list[tuple[str, str, str]] = []
+        for edge in graph.edges:
+            edge_type = (edge.src_table, edge.fkey, edge.dst_table)
+            self._edge_types.append(edge_type)
+            self._edge_types.append(Subgraph.rev_edge_type(edge_type))
+
+        self._primary_key_dict: dict[str, str] = {
+            table.name: table._primary_key
+            for table in graph.tables.values()
+            if table._primary_key is not None
+        }
+
+        self._time_column_dict: dict[str, str] = {
+            table.name: table._time_column
+            for table in graph.tables.values()
+            if table._time_column is not None
+        }
+
+        self._end_time_column_dict: dict[str, str] = {
+            table.name: table._end_time_column
+            for table in graph.tables.values()
+            if table._end_time_column is not None
+        }
+
+        foreign_keys = {(edge.src_table, edge.fkey) for edge in graph.edges}
+        self._table_stype_dict: dict[str, dict[str, Stype]] = {}
+        for table in graph.tables.values():
+            self._table_stype_dict[table.name] = {}
+            for column in table.columns:
+                if column == table.primary_key:
+                    continue
+                if (table.name, column.name) in foreign_keys:
+                    continue
+                self._table_stype_dict[table.name][column.name] = column.stype
+
+    @property
+    def edge_types(self) -> list[tuple[str, str, str]]:
+        return self._edge_types
+
+    @property
+    def primary_key_dict(self) -> dict[str, str]:
+        return self._primary_key_dict
+
+    @property
+    def time_column_dict(self) -> dict[str, str]:
+        return self._time_column_dict
+
+    @property
+    def end_time_column_dict(self) -> dict[str, str]:
+        return self._end_time_column_dict
+
+    @property
+    def table_stype_dict(self) -> dict[str, dict[str, Stype]]:
+        return self._table_stype_dict
+
+    def sample_subgraph(
+        self,
+        entity_table_names: tuple[str, ...],
+        entity_pkey: pd.Series,
+        anchor_time: pd.Series,
+        num_neighbors: list[int],
+        exclude_cols_dict: dict[str, list[str]] | None = None,
+    ) -> Subgraph:
+
+        # Exclude all columns that leak target information:
+        table_stype_dict: dict[str, dict[str, Stype]] = self._table_stype_dict
+        if exclude_cols_dict is not None:
+            table_stype_dict = copy.deepcopy(table_stype_dict)
+            for table_name, exclude_cols in exclude_cols_dict.items():
+                for column_name in exclude_cols:
+                    del table_stype_dict[table_name][column_name]
+
+        # Collect all columns being used as features:
+        columns_dict: dict[str, set[str]] = {
+            table_name: set(stype_dict.keys())
+            for table_name, stype_dict in table_stype_dict.items()
+        }
+        # Make sure to store primary key information for entity tables:
+        for table_name in entity_table_names:
+            columns_dict[table_name].add(self.primary_key_dict[table_name])
+
+        if anchor_time.dtype != 'datetime64[ns]':
+            anchor_time = anchor_time.astype('datetime64[ns]')
+
+        out = self._sample_backward(
+            entity_table_name=entity_table_names[0],
+            entity_pkey=entity_pkey,
+            anchor_time=anchor_time,
+            columns_dict=columns_dict,
+            num_neighbors=num_neighbors,
+        )
+
+        subgraph = Subgraph(
+            anchor_time=anchor_time.astype(int).to_numpy(),
+            table_dict={},
+            link_dict={},
+        )
+
+        for table_name, batch in out.batch_dict.items():
+            if len(batch) == 0:
+                continue
+
+            primary_key: str | None = None
+            if table_name in entity_table_names:
+                primary_key = self.primary_key_dict[table_name]
+
+            df = out.df_dict[table_name].reset_index(drop=True)
+            if end_time_column := self.end_time_column_dict.get(table_name):
+                # Set end time to NaT for all values greater than anchor time:
+                assert table_name not in out.inverse_dict
+                ser = df[end_time_column]
+                if ser.dtype != 'datetime64[ns]':
+                    ser = ser.astype('datetime64[ns]')
+                mask = ser > anchor_time.iloc[batch]
+                ser.iloc[mask] = pd.NaT
+                df[end_time_column] = ser
+
+            stype_dict = table_stype_dict[table_name]
+            for column_name, stype in stype_dict.items():
+                if stype == Stype.text:
+                    df[column_name] = _normalize_text(df[column_name])
+
+            subgraph.table_dict[table_name] = Table(
+                df=df,
+                row=out.inverse_dict.get(table_name),
+                batch=batch,
+                num_sampled_nodes=out.num_sampled_nodes_dict[table_name],
+                stype_dict=stype_dict,
+                primary_key=primary_key,
+            )
+
+        for edge_type in out.row_dict.keys():
+            row: np.ndarray | None = out.row_dict[edge_type]
+            col: np.ndarray | None = out.col_dict[edge_type]
+
+            if row is None or col is None or len(row) == 0:
+                continue
+
+            # Do not store reverse edge type if it is an exact replica:
+            rev_edge_type = Subgraph.rev_edge_type(edge_type)
+            if (rev_edge_type in subgraph.link_dict
+                    and np.array_equal(row, out.col_dict[rev_edge_type])
+                    and np.array_equal(col, out.row_dict[rev_edge_type])):
+                subgraph.link_dict[edge_type] = Link(
+                    layout=EdgeLayout.REV,
+                    row=None,
+                    col=None,
+                    num_sampled_edges=out.num_sampled_edges_dict[edge_type],
+                )
+                continue
+
+            # Do not store non-informative edges:
+            layout = EdgeLayout.COO
+            if np.array_equal(row, np.arange(len(row))):
+                row = None
+            if np.array_equal(col, np.arange(len(col))):
+                col = None
+
+            # Store in compressed representation if more efficient:
+            num_cols = subgraph.table_dict[edge_type[2]].num_rows
+            if col is not None and len(col) > num_cols + 1:
+                layout = EdgeLayout.CSC
+                colcount = np.bincount(col, minlength=num_cols)
+                col = np.empty(num_cols + 1, dtype=col.dtype)
+                col[0] = 0
+                np.cumsum(colcount, out=col[1:])
+
+            subgraph.link_dict[edge_type] = Link(
+                layout=layout,
+                row=row,
+                col=col,
+                num_sampled_edges=out.num_sampled_edges_dict[edge_type],
+            )
+
+        return subgraph
+
+    def sample_forward(
+        self,
+        query: ValidatedPredictiveQuery,
+        num_examples: int,
+        anchor_time: pd.Timestamp | Literal['entity'],
+        random_seed: int | None = None,
+    ) -> ForwardSamplerOutput:
+
+        columns_dict: dict[str, set[str]] = defaultdict(set)
+        for fqn in query.all_query_columns + [query.entity_column]:
+            table_name, column_name = fqn.split('.')
+            columns_dict[table_name].add(column_name)
+
+        if time_column := self.time_column_dict[query.entity_table]:
+            columns_dict[table_name].add(time_column)
+        if end_time_column := self.end_time_column_dict[query.entity_table]:
+            columns_dict[table_name].add(end_time_column)
+
+        time_offset_dict: dict[
+            tuple[str, str, str],
+            tuple[pd.DateOffset | None, pd.DateOffset],
+        ] = {}
+
+        def _add_time_offset(node: ASTNode, num_forecasts: int = 1) -> None:
+            if isinstance(node, Aggregation):
+                table_name = node._get_target_column_name().split('.')[0]
+                columns_dict[table_name].add(self.time_column_dict[table_name])
+
+                edge_types = [
+                    edge_type for edge_type in self.edge_types
+                    if edge_type[0] == table_name
+                    and edge_type[2] == query.entity_table
+                ]
+                if len(edge_types) != 1:
+                    raise ValueError(f"Could not find a unique foreign key "
+                                     f"from table '{table_name}' to "
+                                     f"'{query.entity_table}'")
+                if edge_types[0] not in time_offset_dict:
+                    start = node.aggr_time_range.start_date_offset
+                    end = node.aggr_time_range.end_date_offset * num_forecasts
+                else:
+                    start, end = time_offset_dict[edge_types[0]]
+                    start = min_date_offset(
+                        start,
+                        node.aggr_time_range.start_date_offset,
+                    )
+                    end = max_date_offset(
+                        end,
+                        node.aggr_time_range.end_date_offset * num_forecasts,
+                    )
+                time_offset_dict[edge_types[0]] = (start, end)
+
+            for child in node.children:
+                _add_time_offset(child, num_forecasts)
+
+        _add_time_offset(query.target_ast, query.num_forecasts)
+        _add_time_offset(query.entity_ast)
+        if query.whatif_ast is not None:
+            _add_time_offset(query.whatif_ast)
+
+        return self._sample_forward(
+            query=query,
+            num_examples=num_examples,
+            anchor_time=anchor_time,
+            columns_dict=columns_dict,
+            time_offset_dict=time_offset_dict,
+            random_seed=random_seed,
+        )
+
+    # Abstract Methods ########################################################
+
+    @abstractmethod
+    def _sample_backward(
+        self,
+        entity_table_name: str,
+        entity_pkey: pd.Series,
+        anchor_time: pd.Series,
+        columns_dict: dict[str, set[str]],
+        num_neighbors: list[int],
+    ) -> BackwardSamplerOutput:
+        pass
+
+    @abstractmethod
+    def _sample_forward(
+        self,
+        query: ValidatedPredictiveQuery,
+        num_examples: int,
+        anchor_time: pd.Timestamp | Literal['entity'],
+        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,
+    ) -> ForwardSamplerOutput:
+        pass
+
+
+# Helper Functions ############################################################
+
+PUNCTUATION = re.compile(r"[\'\"\.,\(\)\!\?\;\:]")
+MULTISPACE = re.compile(r"\s+")
+
+
+def _normalize_text(
+    ser: pd.Series,
+    max_words: int | None = 50,
+) -> pd.Series:
+    r"""Normalizes text into a list of lower-case words.
+
+    Args:
+        ser: The :class:`pandas.Series` to normalize.
+        max_words: The maximum number of words to return.
+            This will auto-shrink any large text column to avoid blowing up
+            context size.
+    """
+    if len(ser) == 0 or pd.api.types.is_list_like(ser.iloc[0]):
+        return ser
+
+    def normalize_fn(line: str) -> list[str]:
+        line = PUNCTUATION.sub(" ", line)
+        line = re.sub(r"<br\s*/?>", " ", line)  # Handle <br /> or <br>
+        line = MULTISPACE.sub(" ", line)
+        words = line.split()
+        if max_words is not None:
+            words = words[:max_words]
+        return words
+
+    ser = ser.fillna('').astype(str)
+
+    if max_words is not None:
+        # We estimate the number of words as 5 characters + 1 space in an
+        # English text on average. We need this pre-filter here, as word
+        # splitting on a giant text can be very expensive:
+        ser = ser.str[:6 * max_words]
+
+    ser = ser.str.lower()
+    ser = ser.map(normalize_fn)
+
+    return ser
+
+
+def min_date_offset(*args: pd.DateOffset | None) -> pd.DateOffset | None:
+    if any(arg is None for arg in args):
+        return None
+
+    anchor = pd.Timestamp('2000-01-01')
+    timestamps = [anchor + arg for arg in args]
+    assert len(timestamps) > 0
+    argmin = min(range(len(timestamps)), key=lambda i: timestamps[i])
+    return args[argmin]
+
+
+def max_date_offset(*args: pd.DateOffset) -> pd.DateOffset:
+    anchor = pd.Timestamp('2000-01-01')
+    timestamps = [anchor + arg for arg in args]
+    assert len(timestamps) > 0
+    argmax = max(range(len(timestamps)), key=lambda i: timestamps[i])
+    return args[argmax]

kumoai/experimental/rfm/base/source.py

@@ -0,0 +1,18 @@
+from dataclasses import dataclass
+
+from kumoapi.typing import Dtype
+
+
+@dataclass
+class SourceColumn:
+    name: str
+    dtype: Dtype
+    is_primary_key: bool
+    is_unique_key: bool
+
+
+@dataclass
+class SourceForeignKey:
+    name: str
+    dst_table: str
+    primary_key: str