upgini 1.2.97__tar.gz → 1.2.98__tar.gz

{upgini-1.2.97 → upgini-1.2.98}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.97
+Version: 1.2.98
 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.98/src/upgini/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.2.98"

{upgini-1.2.97 → upgini-1.2.98}/src/upgini/autofe/feature.py

@@ -18,10 +18,7 @@ class Column:
         self.data = data
         self.calculate_all = calculate_all
 
-    def get_display_name(self, cache: bool = True, shorten: bool = False, **kwargs) -> str:
-        return self.name
-
-    def set_op_params(self, params: Dict[str, str]) -> "Column":
+    def set_op_params(self, params: Dict[str, str], **kwargs) -> "Column":
         return self
 
     def get_op_params(self, **kwargs):
@@ -37,8 +34,21 @@ class Column:
     def get_column_nodes(self) -> List["Column"]:
         return [self]
 
-    def get_columns(self, **kwargs) -> List[str]:
-        return [self.name]
+    def get_columns(self, unhash=False, **kwargs):
+        name = self.name
+        return [self._unhash(name) if unhash else name]
+
+    def get_display_name(self, cache: bool = True, shorten: bool = False, **kwargs) -> str:
+        return self.get_columns(**kwargs)[0]
+
+    def _unhash(self, feature_name: str) -> str:
+        last_component_idx = feature_name.rfind("_")
+        if not feature_name.startswith("f_"):
+            return feature_name  # etalon feature
+        elif last_component_idx == 1:
+            return feature_name[2:]  # fully hashed name, cannot unhash
+        else:
+            return feature_name[2:last_component_idx]
 
     @property
     def children(self) -> List[Union["Feature", "Column"]]:
@@ -81,7 +91,7 @@ class Feature:
         self.cached_display_name = cached_display_name
         self.alias = alias
 
-    def set_op_params(self, params: Optional[Dict[str, str]]) -> "Feature":
+    def set_op_params(self, params: Optional[Dict[str, str]], **kwargs) -> "Feature":
         obj_dict = pydantic_dump_method(self.op)().copy()
         obj_dict.update(params or {})
         self.op = pydantic_parse_method(self.op.__class__)(obj_dict)
@@ -89,13 +99,13 @@ class Feature:
 
         for child in self.children:
             child_params = {
-                k[len(child.get_display_name()) + 1 :]: v
+                k[len(child.get_display_name(**kwargs)) + 1 :]: v
                 for k, v in params.items()
-                if k.startswith(child.get_display_name())
+                if k.startswith(child.get_display_name(**kwargs))
             }
             if not child_params:
                 child_params = params
-            child.set_op_params(child_params)
+            child.set_op_params(child_params, **kwargs)
         return self
 
     def get_op_params(self, **kwargs) -> Dict[str, str]:

{upgini-1.2.97 → upgini-1.2.98}/src/upgini/autofe/unary.py

@@ -3,7 +3,7 @@ from typing import Dict, List, Optional
 import numpy as np
 import pandas as pd
 
-from upgini.autofe.operator import PandasOperator, VectorizableMixin
+from upgini.autofe.operator import PandasOperator, ParametrizedOperator, VectorizableMixin
 from upgini.autofe.utils import pydantic_validator
 
 
@@ -198,3 +198,24 @@ class Cluster(PandasOperator):
     input_type: Optional[str] = "vector"
     output_type: Optional[str] = "category"
     is_categorical: bool = True
+
+
+class OutlierDistance(PandasOperator, ParametrizedOperator):
+    name: str = "outlier_dist"
+    is_unary: bool = True
+    input_type: Optional[str] = "vector"
+    output_type: Optional[str] = "float"
+    class_value: Optional[str] = None
+
+    def to_formula(self) -> str:
+        return f"outlier_dist_{self.class_value if self.class_value is not None else 'all'}"
+
+    @classmethod
+    def from_formula(cls, formula: str) -> Optional["OutlierDistance"]:
+        if formula == "outlier_dist":
+            return cls()
+
+        if formula.startswith("outlier_dist_"):
+            class_value = formula.split("_")[-1]
+            return cls(class_value=None if class_value == "all" else class_value)
+        return None

{upgini-1.2.97 → upgini-1.2.98}/src/upgini/features_enricher.py

@@ -4174,7 +4174,7 @@ if response.status_code == 200:
 
                 description = {}
 
-                feature_meta = get_feature_by_name(autofe_feature.get_display_name(shorten=True))
+                feature_meta = get_feature_by_name(autofe_feature.get_display_name(shorten=True, unhash=True))
                 if feature_meta is None:
                     self.logger.warning(f"Feature meta for display index {m.display_index} not found")
                     continue

{upgini-1.2.97 → upgini-1.2.98}/src/upgini/metrics.py

@@ -399,14 +399,14 @@ class EstimatorWrapper:
                 self.converted_to_str.append(c)
             elif c in self.cat_features:
                 if x[c].dtype == "bool" or (x[c].dtype == "category" and x[c].cat.categories.dtype == "bool"):
-                    x[c] = x[c].astype(np.int64)
+                    x[c] = x[c].astype(pd.Int64Dtype())
                     self.converted_to_int.append(c)
                 elif x[c].dtype == "category" and is_integer_dtype(x[c].cat.categories):
                     self.logger.info(
                         f"Convert categorical feature {c} with integer categories"
                         " to int64 and remove from cat_features"
                     )
-                    x[c] = x[c].astype(np.int64)
+                    x[c] = x[c].astype(pd.Int64Dtype())
                     self.converted_to_int.append(c)
                     self.cat_features.remove(c)
                 elif is_float_dtype(x[c]) or (x[c].dtype == "category" and is_float_dtype(x[c].cat.categories)):
@@ -419,7 +419,7 @@ class EstimatorWrapper:
             else:
                 if x[c].dtype == "bool" or (x[c].dtype == "category" and x[c].cat.categories.dtype == "bool"):
                     self.logger.info(f"Convert bool feature {c} to int64")
-                    x[c] = x[c].astype(np.int64)
+                    x[c] = x[c].astype(pd.Int64Dtype())
                     self.converted_to_int.append(c)
                 elif not is_valid_numeric_array_data(x[c]) and not is_numeric_dtype(x[c]):
                     try:
@@ -442,7 +442,7 @@ class EstimatorWrapper:
         if self.converted_to_int:
             self.logger.info(f"Convert to int features on calculate metrics: {self.converted_to_int}")
             for c in self.converted_to_int:
-                x[c] = x[c].astype(np.int64)
+                x[c] = x[c].astype(pd.Int64Dtype())
 
         if self.converted_to_str:
             self.logger.info(f"Convert to str features on calculate metrics: {self.converted_to_str}")
@@ -896,7 +896,7 @@ class LightGBMWrapper(EstimatorWrapper):
                     x[c] = x[c].astype("category")
 
         for c in x.columns:
-            if x[c].dtype not in ["category", "int64", "float64", "bool"]:
+            if x[c].dtype not in ["category", "int64", "float64", "bool", "Int64"]:
                 self.logger.warning(f"Feature {c} is not numeric and will be dropped")
                 self.dropped_features.append(c)
                 x = x.drop(columns=c, errors="ignore")
@@ -987,7 +987,7 @@ class OtherEstimatorWrapper(EstimatorWrapper):
                     x[c] = x[c].astype("category")
             params["cat_features"] = self.cat_features
         for c in x.columns:
-            if x[c].dtype not in ["category", "int64", "float64", "bool"]:
+            if x[c].dtype not in ["category", "int64", "float64", "bool", "Int64"]:
                 self.logger.warning(f"Feature {c} is not numeric and will be dropped")
                 self.dropped_features.append(c)
                 x = x.drop(columns=c, errors="ignore")

upgini-1.2.97/src/upgini/__about__.py

@@ -1 +0,0 @@
-__version__ = "1.2.97"