upgini 1.2.62a3818.dev3__tar.gz → 1.2.62a3818.dev4__tar.gz

{upgini-1.2.62a3818.dev3 → upgini-1.2.62a3818.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.62a3818.dev3
+Version: 1.2.62a3818.dev4
 Summary: Intelligent data search & enrichment for Machine Learning
 Project-URL: Bug Reports, https://github.com/upgini/upgini/issues
 Project-URL: Homepage, https://upgini.com/

upgini-1.2.62a3818.dev4/src/upgini/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.2.62a3818.dev4"

{upgini-1.2.62a3818.dev3 → upgini-1.2.62a3818.dev4}/src/upgini/autofe/all_operands.py

@@ -7,4 +7,4 @@ from upgini.autofe.vector import *  # noqa
 
 
 def find_op(name):
-    return OperatorRegistry.get_operand(name)
+    return OperatorRegistry.get_operator(name)

{upgini-1.2.62a3818.dev3 → upgini-1.2.62a3818.dev4}/src/upgini/autofe/operator.py

@@ -28,15 +28,17 @@ class OperatorRegistry(type(BaseModel)):
                 try:
                     instance = new_class()
                     cls._registry[instance.name] = new_class
+                    if instance.alias:
+                        cls._registry[instance.alias] = new_class
                 except Exception:
                     pass
         return new_class
 
     @classmethod
-    def get_operand(cls, name: str) -> Optional["Operator"]:
+    def get_operator(cls, name: str) -> Optional["Operator"]:
         # First try to resolve as a parametrized operand formula
-        for operand_cls in cls._parametrized_registry:
-            resolved = operand_cls.from_formula(name)
+        for operator_cls in cls._parametrized_registry:
+            resolved = operator_cls.from_formula(name)
             if resolved is not None:
                 return resolved
         # Fall back to direct registry lookup

upgini-1.2.62a3818.dev4/src/upgini/autofe/timeseries/__init__.py

@@ -0,0 +1,23 @@
+"""Time series feature engineering operators."""
+
+from upgini.autofe.timeseries.base import TimeSeriesBase
+from upgini.autofe.timeseries.roll import Roll
+from upgini.autofe.timeseries.lag import Lag
+from upgini.autofe.timeseries.delta import Delta, Delta2
+from upgini.autofe.timeseries.trend import TrendCoefficient
+from upgini.autofe.timeseries.volatility import EWMAVolatility, RollingVolatility, RollingVolatility2, VolatilityRatio
+from upgini.autofe.timeseries.cross import CrossSeriesInteraction
+
+__all__ = [
+    "TimeSeriesBase",
+    "Roll",
+    "Lag",
+    "Delta",
+    "Delta2",
+    "TrendCoefficient",
+    "EWMAVolatility",
+    "RollingVolatility",
+    "RollingVolatility2",
+    "VolatilityRatio",
+    "CrossSeriesInteraction",
+]

upgini-1.2.62a3818.dev4/src/upgini/autofe/timeseries/base.py

@@ -0,0 +1,105 @@
+import abc
+from typing import Dict, List, Optional
+
+import pandas as pd
+from upgini.autofe.operator import PandasOperator
+
+# Used in derived classes
+try:
+    from pydantic import field_validator as validator  # V2
+except ImportError:
+    from pydantic import validator  # V1
+
+
+class TimeSeriesBase(PandasOperator, abc.ABC):
+    is_vector: bool = True
+    date_unit: Optional[str] = None
+    offset_size: int = 0
+    offset_unit: str = "D"
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "date_unit": self.date_unit,
+                "offset_size": self.offset_size,
+                "offset_unit": self.offset_unit,
+            }
+        )
+        return res
+
+    def calculate_vector(self, data: List[pd.Series]) -> pd.Series:
+        # assuming first is date, last is value, rest is group columns
+        date = pd.to_datetime(data[0], unit=self.date_unit, errors="coerce")
+        ts = pd.concat([date] + data[1:], axis=1)
+        ts.drop_duplicates(subset=ts.columns[:-1], keep="first", inplace=True)
+        ts.set_index(date.name, inplace=True)
+        ts = ts[ts.index.notna()].sort_index()
+        ts = (
+            ts.groupby([c.name for c in data[1:-1]], group_keys=True)
+            .apply(self._shift)[data[-1].name]
+            .to_frame()
+            .reset_index()
+            .set_index(date.name)
+            .groupby([c.name for c in data[1:-1]], group_keys=True)
+            if len(data) > 2
+            else self._shift(ts)
+        )
+        ts = self._aggregate(ts)
+        ts = ts.reindex(data[1:-1] + [date] if len(data) > 2 else date).reset_index()
+        ts.index = date.index
+
+        return ts.iloc[:, -1]
+
+    def _shift(self, ts: pd.DataFrame) -> pd.DataFrame:
+        if self.offset_size > 0:
+            return ts.iloc[:, :-1].merge(
+                ts.iloc[:, -1].shift(freq=f"{self.offset_size}{self.offset_unit}"),
+                left_index=True,
+                right_index=True,
+            )
+        return ts
+
+    @abc.abstractmethod
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        pass
+
+    def _add_offset_to_formula(self, base_formula: str) -> str:
+        if self.offset_size > 0:
+            return f"{base_formula}_offset_{self.offset_size}{self.offset_unit}"
+        return base_formula
+
+    @classmethod
+    def _parse_offset_from_formula(cls, formula: str, base_regex: str) -> tuple[Optional[dict], Optional[str]]:
+        """
+        Parse the offset component from a formula.
+
+        Args:
+            formula: The formula to parse
+            base_regex: The regex pattern for the base formula (without offset)
+
+        Returns:
+            A tuple with:
+            - Dictionary with offset parameters if found, None otherwise
+            - Remaining part of the formula after removing offset component (for further parsing)
+        """
+        import re
+
+        offset_regex = f"{base_regex}_offset_(\\d+)([a-zA-Z])"
+        match = re.match(offset_regex, formula)
+
+        if match:
+            # Get groups from the offset part
+            offset_size = int(match.group(match.lastindex - 1))
+            offset_unit = match.group(match.lastindex)
+
+            # Return the parameters and the base formula for further parsing if needed
+            # Extract the base formula by using the match object
+            base_formula = formula[: match.start(match.lastindex - 1) - len("_offset_")]
+            return {"offset_size": offset_size, "offset_unit": offset_unit}, base_formula
+
+        # Check if it matches the base regex (no offset)
+        if re.match(f"^{base_regex}$", formula) or re.match(f"^{base_regex}_", formula):
+            return None, formula
+
+        return None, None

upgini-1.2.62a3818.dev4/src/upgini/autofe/timeseries/cross.py

@@ -0,0 +1,130 @@
+from typing import Dict, List, Optional
+
+import numpy as np
+import pandas as pd
+
+try:
+    from pydantic import field_validator as validator  # V2
+except ImportError:
+    from pydantic import validator  # V1
+
+from upgini.autofe.all_operands import find_op
+from upgini.autofe.operator import PandasOperator, ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+
+class CrossSeriesInteraction(TimeSeriesBase, ParametrizedOperator):
+    base_name: str = "cross"
+    interaction_op: PandasOperator
+    descriptor_indices: List[int] = []
+    left_descriptor: List[str] = []
+    right_descriptor: List[str] = []
+
+    @validator("descriptor_indices")
+    @classmethod
+    def validate_descriptor_indices(cls, v):
+        if not v:
+            raise ValueError("descriptor_indices cannot be empty for CrossSeriesInteraction")
+        return v
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        indices = self.descriptor_indices
+        left = self.left_descriptor
+        right = self.right_descriptor
+
+        if len(left) != len(indices):
+            raise ValueError(
+                f"left_descriptor length ({len(left)}) " f"must match descriptor_indices length ({len(indices)})"
+            )
+
+        if len(right) != len(indices):
+            raise ValueError(
+                f"right_descriptor length ({len(right)}) " f"must match descriptor_indices length ({len(indices)})"
+            )
+
+    def to_formula(self) -> str:
+        base_formula = f"{self.base_name}_{self._get_interaction_op_name()}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["CrossSeriesInteraction"]:
+        base_regex = r"cross_(.+)"
+
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        # Extract the operator formula
+        op_formula = match.group(1)
+
+        op = find_op(op_formula)
+        if op is None or not op.is_binary:
+            return None
+
+        # Include default values to pass validation
+        params = {
+            "interaction_op": op,
+            "descriptor_indices": [0],  # Default index
+            "left_descriptor": ["default"],  # Default left descriptor
+            "right_descriptor": ["default"],  # Default right descriptor
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, str | None]:
+        res = super().get_params()
+        res.update(
+            {
+                "interaction_op": self._get_interaction_op_name(),
+                "descriptor_indices": self.descriptor_indices,
+                "left_descriptor": self.left_descriptor,
+                "right_descriptor": self.right_descriptor,
+            }
+        )
+        return res
+
+    def _get_interaction_op_name(self) -> str:
+        return self.interaction_op.alias or self.interaction_op.to_formula()
+
+    def calculate_vector(self, data: List[pd.Series]) -> pd.Series:
+        left_mask = self._get_mask(data, self.left_descriptor)
+        left = self._extract_series(data, left_mask)
+
+        right_mask = self._get_mask(data, self.right_descriptor)
+        right = self._extract_series(data, right_mask)
+
+        interaction: pd.Series = self.interaction_op.calculate_binary(left, right)
+        interaction = interaction.reindex(self._get_index(data))
+        res = pd.Series(np.nan, index=data[-1].index, name=data[-1].name)
+        res.loc[left_mask] = interaction[left_mask].values
+        res.loc[right_mask] = interaction[right_mask].values
+        return res
+
+    def _get_mask(self, data: List[pd.Series], descriptor: List[str]) -> pd.Series:
+        mask = np.logical_and.reduce([data[i] == v for i, v in zip(self.descriptor_indices, descriptor)])
+        return mask
+
+    def _extract_series(self, data: List[pd.Series], mask: pd.Series) -> pd.Series:
+        masked_data = [d[mask] for d in data]
+        shifted = super().calculate_vector(masked_data)
+        shifted.index = self._get_index(masked_data)
+        return shifted
+
+    def _get_index(self, data: List[pd.Series]) -> pd.Series:
+        index = [d for i, d in enumerate(data[:-1]) if i not in self.descriptor_indices]
+        return index if len(index) > 1 else index[0]
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.apply(lambda x: x).iloc[:, [-1]]

upgini-1.2.62a3818.dev4/src/upgini/autofe/timeseries/delta.py

@@ -0,0 +1,125 @@
+import pandas as pd
+from typing import Dict, Optional
+
+from upgini.autofe.operator import ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+from upgini.autofe.timeseries.lag import Lag
+
+
+class Delta(TimeSeriesBase, ParametrizedOperator):
+    delta_size: int
+    delta_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = f"delta_{self.delta_size}{self.delta_unit}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["Delta"]:
+        # Base regex for Delta class
+        base_regex = r"delta_(\d+)([a-zA-Z])"
+
+        # Parse offset first
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Now parse the delta part
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        delta_size = int(match.group(1))
+        delta_unit = match.group(2)
+
+        # Create instance with appropriate parameters
+        params = {
+            "delta_size": delta_size,
+            "delta_unit": delta_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "delta_size": self.delta_size,
+                "delta_unit": self.delta_unit,
+                "offset_size": self.offset_size,
+                "offset_unit": self.offset_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        lag0 = Lag(lag_size=0, lag_unit=self.delta_unit)
+        lag = Lag(lag_size=self.delta_size, lag_unit=self.delta_unit)
+        return lag0._aggregate(ts) - lag._aggregate(ts)
+
+
+class Delta2(TimeSeriesBase, ParametrizedOperator):
+    delta_size: int
+    delta_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = f"delta2_{self.delta_size}{self.delta_unit}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["Delta2"]:
+        # Base regex for Delta2 class
+        base_regex = r"delta2_(\d+)([a-zA-Z])"
+
+        # Parse offset first
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Now parse the delta part
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        delta_size = int(match.group(1))
+        delta_unit = match.group(2)
+
+        # Create instance with appropriate parameters
+        params = {
+            "delta_size": delta_size,
+            "delta_unit": delta_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "delta_size": self.delta_size,
+                "delta_unit": self.delta_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        # Calculate first delta
+        delta1 = Delta(delta_size=self.delta_size, delta_unit=self.delta_unit)
+        first_delta = delta1._aggregate(ts)
+
+        # Calculate delta of delta (second derivative)
+        return delta1._aggregate(first_delta)

upgini-1.2.62a3818.dev4/src/upgini/autofe/timeseries/lag.py

@@ -0,0 +1,68 @@
+import numpy as np
+import pandas as pd
+from typing import Dict, Optional
+
+from upgini.autofe.operator import ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+
+class Lag(TimeSeriesBase, ParametrizedOperator):
+    lag_size: int
+    lag_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = f"lag_{self.lag_size}{self.lag_unit}"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["Lag"]:
+        # Base regex for Lag class
+        base_regex = r"lag_(\d+)([a-zA-Z])"
+
+        # Parse offset first
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Now parse the lag part
+        import re
+
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        lag_size = int(match.group(1))
+        lag_unit = match.group(2)
+
+        # Create instance with appropriate parameters
+        params = {
+            "lag_size": lag_size,
+            "lag_unit": lag_unit,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "lag_size": self.lag_size,
+                "lag_unit": self.lag_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        lag_window = self.lag_size + 1
+        return ts.rolling(f"{lag_window}{self.lag_unit}", min_periods=1).agg(self._lag)
+
+    def _lag(self, x):
+        if x.index.min() > (x.index.max() - pd.Timedelta(self.lag_size, self.lag_unit)):
+            return np.nan
+        else:
+            return x[0]

upgini-1.2.62a3818.dev4/src/upgini/autofe/timeseries/roll.py

@@ -0,0 +1,92 @@
+import pandas as pd
+from typing import Dict, Optional
+
+from upgini.autofe.operator import ParametrizedOperator
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+# Roll aggregation functions
+roll_aggregations = {
+    "norm_mean": lambda x: x[-1] / x.mean(),
+    "q25": lambda x: x.quantile(0.25),
+    "q75": lambda x: x.quantile(0.75),
+    "iqr": lambda x: x.quantile(0.75) - x.quantile(0.25),
+}
+
+try:
+    from pydantic import field_validator as validator  # V2
+except ImportError:
+    from pydantic import validator  # V1
+
+
+class Roll(TimeSeriesBase, ParametrizedOperator):
+    aggregation: str
+    window_size: int = 1
+    window_unit: str = "D"
+
+    @validator("window_unit")
+    @classmethod
+    def validate_window_unit(cls, v: str) -> str:
+        try:
+            pd.tseries.frequencies.to_offset(v)
+            return v
+        except ValueError:
+            raise ValueError(
+                f"Invalid window_unit: {v}. Must be a valid pandas frequency string (e.g. 'D', 'H', 'T', etc)"
+            )
+
+    def to_formula(self) -> str:
+        # First add window size and unit, then add aggregation, then add offset
+        base_formula = f"roll_{self.window_size}{self.window_unit}"
+        formula_with_agg = f"{base_formula}_{self.aggregation}"
+        return self._add_offset_to_formula(formula_with_agg)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["Roll"]:
+        import re
+
+        # Base regex for Roll class (with aggregation)
+        base_regex = r"roll_(\d+)([a-zA-Z])_(\w+)"
+
+        # Parse offset first - this removes the offset part if present
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Parse the window part and aggregation
+        match = re.match(f"^{base_regex}$", remaining_formula)
+
+        if not match:
+            return None
+
+        window_size = int(match.group(1))
+        window_unit = match.group(2)
+        aggregation = match.group(3)
+
+        # Create instance with appropriate parameters
+        params = {
+            "window_size": window_size,
+            "window_unit": window_unit,
+            "aggregation": aggregation,
+        }
+
+        if offset_params:
+            params.update(offset_params)
+
+        return cls(**params)
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "window_size": self.window_size,
+                "window_unit": self.window_unit,
+                "aggregation": self.aggregation,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.rolling(f"{self.window_size}{self.window_unit}", min_periods=1).agg(
+            roll_aggregations.get(self.aggregation, self.aggregation)
+        )

upgini-1.2.62a3818.dev4/src/upgini/autofe/timeseries/trend.py

@@ -0,0 +1,61 @@
+from typing import Dict, Optional, Union
+import numpy as np
+import pandas as pd
+
+from upgini.autofe.timeseries.base import TimeSeriesBase
+
+
+class TrendCoefficient(TimeSeriesBase):
+    name: str = "trend_coef"
+    step_size: int = 1
+    step_unit: str = "D"
+
+    def to_formula(self) -> str:
+        base_formula = "trend_coef"
+        return self._add_offset_to_formula(base_formula)
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["TrendCoefficient"]:
+        # Base regex for TrendCoefficient class
+        base_regex = r"trend_coef"
+
+        # Parse offset first
+        offset_params, remaining_formula = cls._parse_offset_from_formula(formula, base_regex)
+
+        if remaining_formula is None:
+            return None
+
+        # Basic pattern (no offset)
+        if remaining_formula == "trend_coef":
+            params = {}
+            if offset_params:
+                params.update(offset_params)
+            return cls(**params)
+
+        return None
+
+    def get_params(self) -> Dict[str, Optional[str]]:
+        res = super().get_params()
+        res.update(
+            {
+                "step_size": self.step_size,
+                "step_unit": self.step_unit,
+                "offset_size": self.offset_size,
+                "offset_unit": self.offset_unit,
+            }
+        )
+        return res
+
+    def _aggregate(self, ts: pd.DataFrame) -> pd.DataFrame:
+        return ts.apply(self._trend_coef).iloc[:, [-1]].fillna(0)
+
+    def _trend_coef(self, x: Union[pd.DataFrame, pd.Series]) -> Union[pd.DataFrame, pd.Series]:
+        return_series = isinstance(x, pd.Series)
+        x = pd.DataFrame(x)
+        resampled = (
+            x.iloc[:, -1].resample(f"{self.step_size}{self.step_unit}").fillna(method="ffill").fillna(method="bfill")
+        )
+        idx = np.arange(len(resampled))
+        coeffs = np.polyfit(idx, resampled, 1)
+        x.iloc[:, -1] = coeffs[0]
+        return x.iloc[:, -1] if return_series else x