upgini 1.2.86.dev1__py3-none-any.whl → 1.2.87.dev3__py3-none-any.whl

upgini/__about__.py

@@ -1 +1 @@
-__version__ = "1.2.86.dev1"
+__version__ = "1.2.87.dev3"

upgini/features_enricher.py

@@ -30,7 +30,7 @@ from pandas.api.types import (
 from scipy.stats import ks_2samp
 from sklearn.base import TransformerMixin
 from sklearn.exceptions import NotFittedError
-from sklearn.model_selection import BaseCrossValidator
+from sklearn.model_selection import BaseCrossValidator, TimeSeriesSplit
 
 from upgini.autofe.feature import Feature
 from upgini.autofe.timeseries import TimeSeriesBase
@@ -71,6 +71,7 @@ from upgini.resource_bundle import ResourceBundle, bundle, get_custom_bundle
 from upgini.search_task import SearchTask
 from upgini.spinner import Spinner
 from upgini.utils import combine_search_keys, find_numbers_with_decimal_comma
+from upgini.utils.blocked_time_series import BlockedTimeSeriesSplit
 from upgini.utils.country_utils import (
     CountrySearchKeyConverter,
     CountrySearchKeyDetector,
@@ -114,7 +115,9 @@ from upgini.utils.postal_code_utils import (
 try:
     from upgini.utils.progress_bar import CustomProgressBar as ProgressBar
 except Exception:
-    from upgini.utils.fallback_progress_bar import CustomFallbackProgressBar as ProgressBar
+    from upgini.utils.fallback_progress_bar import (
+        CustomFallbackProgressBar as ProgressBar,
+    )
 
 from upgini.utils.sort import sort_columns
 from upgini.utils.target_utils import (
@@ -239,6 +242,7 @@ class FeaturesEnricher(TransformerMixin):
         add_date_if_missing: bool = True,
         disable_force_downsampling: bool = False,
         id_columns: Optional[List[str]] = None,
+        generate_search_key_features: bool = True,
         **kwargs,
     ):
         self.bundle = get_custom_bundle(custom_bundle_config)
@@ -365,6 +369,8 @@ class FeaturesEnricher(TransformerMixin):
         self.exclude_columns = exclude_columns
         self.baseline_score_column = baseline_score_column
         self.add_date_if_missing = add_date_if_missing
+        self.generate_search_key_features = generate_search_key_features
+
         self.features_info_display_handle = None
         self.data_sources_display_handle = None
         self.autofe_features_display_handle = None
@@ -1045,6 +1051,7 @@ class FeaturesEnricher(TransformerMixin):
                     self._check_train_and_eval_target_distribution(y_sorted, fitting_eval_set_dict)
 
                     has_date = self._get_date_column(search_keys) is not None
+                    has_time = has_date and isinstance(_cv, TimeSeriesSplit) or isinstance(_cv, BlockedTimeSeriesSplit)
                     model_task_type = self.model_task_type or define_task(y_sorted, has_date, self.logger, silent=True)
                     cat_features = list(set(client_cat_features + cat_features_from_backend))
                     baseline_cat_features = [f for f in cat_features if f in fitting_X.columns]
@@ -1077,7 +1084,7 @@ class FeaturesEnricher(TransformerMixin):
                             add_params=custom_loss_add_params,
                             groups=groups,
                             text_features=text_features,
-                            has_date=has_date,
+                            has_time=has_time,
                         )
                         baseline_cv_result = baseline_estimator.cross_val_predict(
                             fitting_X, y_sorted, baseline_score_column
@@ -1112,7 +1119,7 @@ class FeaturesEnricher(TransformerMixin):
                             add_params=custom_loss_add_params,
                             groups=groups,
                             text_features=text_features,
-                            has_date=has_date,
+                            has_time=has_time,
                         )
                         enriched_cv_result = enriched_estimator.cross_val_predict(fitting_enriched_X, enriched_y_sorted)
                         enriched_metric = enriched_cv_result.get_display_metric()
@@ -1773,7 +1780,13 @@ class FeaturesEnricher(TransformerMixin):
         date_column = self._get_date_column(search_keys)
         generated_features = []
         if date_column is not None:
-            converter = DateTimeSearchKeyConverter(date_column, self.date_format, self.logger, self.bundle)
+            converter = DateTimeSearchKeyConverter(
+                date_column,
+                self.date_format,
+                self.logger,
+                self.bundle,
+                generate_cyclical_features=self.generate_search_key_features,
+            )
             # Leave original date column values
             df_with_date_features = converter.convert(df, keep_time=True)
             df_with_date_features[date_column] = df[date_column]
@@ -1781,7 +1794,7 @@ class FeaturesEnricher(TransformerMixin):
             generated_features = converter.generated_features
 
         email_columns = SearchKey.find_all_keys(search_keys, SearchKey.EMAIL)
-        if email_columns:
+        if email_columns and self.generate_search_key_features:
             generator = EmailDomainGenerator(email_columns)
             df = generator.generate(df)
             generated_features.extend(generator.generated_features)
@@ -2204,10 +2217,12 @@ class FeaturesEnricher(TransformerMixin):
                         {"name": name, "value": key_example(sk_type)} for name in sk_meta.unnestKeyNames
                     ]
                 else:
-                    search_keys_with_values[sk_type.name] = [{
-                        "name": sk_meta.originalName,
-                        "value": key_example(sk_type),
-                    }]
+                    search_keys_with_values[sk_type.name] = [
+                        {
+                            "name": sk_meta.originalName,
+                            "value": key_example(sk_type),
+                        }
+                    ]
 
         keys_section = json.dumps(search_keys_with_values)
         features_for_transform = self._search_task.get_features_for_transform()
@@ -2360,7 +2375,13 @@ if response.status_code == 200:
             generated_features = []
             date_column = self._get_date_column(search_keys)
             if date_column is not None:
-                converter = DateTimeSearchKeyConverter(date_column, self.date_format, self.logger, bundle=self.bundle)
+                converter = DateTimeSearchKeyConverter(
+                    date_column,
+                    self.date_format,
+                    self.logger,
+                    bundle=self.bundle,
+                    generate_cyclical_features=self.generate_search_key_features,
+                )
                 df = converter.convert(df, keep_time=True)
                 self.logger.info(f"Date column after convertion: {df[date_column]}")
                 generated_features.extend(converter.generated_features)
@@ -2370,7 +2391,7 @@ if response.status_code == 200:
                     df = self._add_current_date_as_key(df, search_keys, self.logger, self.bundle)
 
             email_columns = SearchKey.find_all_keys(search_keys, SearchKey.EMAIL)
-            if email_columns:
+            if email_columns and self.generate_search_key_features:
                 generator = EmailDomainGenerator(email_columns)
                 df = generator.generate(df)
                 generated_features.extend(generator.generated_features)
@@ -2860,6 +2881,7 @@ if response.status_code == 200:
                 self.date_format,
                 self.logger,
                 bundle=self.bundle,
+                generate_cyclical_features=self.generate_search_key_features,
             )
             df = converter.convert(df, keep_time=True)
             if converter.has_old_dates:
@@ -2872,7 +2894,7 @@ if response.status_code == 200:
                 df = self._add_current_date_as_key(df, self.fit_search_keys, self.logger, self.bundle)
 
         email_columns = SearchKey.find_all_keys(self.fit_search_keys, SearchKey.EMAIL)
-        if email_columns:
+        if email_columns and self.generate_search_key_features:
             generator = EmailDomainGenerator(email_columns)
             df = generator.generate(df)
             self.fit_generated_features.extend(generator.generated_features)
@@ -3564,7 +3586,9 @@ if response.status_code == 200:
             maybe_date_col = SearchKey.find_key(self.search_keys, [SearchKey.DATE, SearchKey.DATETIME])
             if X is not None and maybe_date_col is not None and maybe_date_col in X.columns:
                 # TODO cast date column to single dtype
-                date_converter = DateTimeSearchKeyConverter(maybe_date_col, self.date_format)
+                date_converter = DateTimeSearchKeyConverter(
+                    maybe_date_col, self.date_format, generate_cyclical_features=False
+                )
                 converted_X = date_converter.convert(X)
                 min_date = converted_X[maybe_date_col].min()
                 max_date = converted_X[maybe_date_col].max()
@@ -3603,7 +3627,7 @@ if response.status_code == 200:
             self.__log_warning(bundle.get("current_date_added"))
             df[FeaturesEnricher.CURRENT_DATE] = datetime.date.today()
             search_keys[FeaturesEnricher.CURRENT_DATE] = SearchKey.DATE
-            converter = DateTimeSearchKeyConverter(FeaturesEnricher.CURRENT_DATE)
+            converter = DateTimeSearchKeyConverter(FeaturesEnricher.CURRENT_DATE, generate_cyclical_features=False)
             df = converter.convert(df)
         return df
 

upgini/metrics.py

@@ -6,16 +6,26 @@ import re
 from collections import defaultdict
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Literal, Optional, Tuple, Union
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Protocol,
+    Tuple,
+    Union,
+    runtime_checkable,
+)
 
 import lightgbm as lgb
 import numpy as np
 import pandas as pd
 from catboost import CatBoostClassifier, CatBoostRegressor
-from category_encoders.cat_boost import CatBoostEncoder
 from lightgbm import LGBMClassifier, LGBMRegressor
 from numpy import log1p
-from pandas.api.types import is_numeric_dtype, is_integer_dtype, is_float_dtype
+from pandas.api.types import is_float_dtype, is_integer_dtype, is_numeric_dtype
 from sklearn.metrics import check_scoring, get_scorer, make_scorer, roc_auc_score
 
 from upgini.utils.blocked_time_series import BlockedTimeSeriesSplit
@@ -32,10 +42,7 @@ except ImportError:
     available_scorers = SCORERS
 from sklearn.metrics import mean_squared_error
 from sklearn.metrics._regression import _check_reg_targets, check_consistent_length
-from sklearn.model_selection import (  # , TimeSeriesSplit
-    BaseCrossValidator,
-    TimeSeriesSplit,
-)
+from sklearn.model_selection import BaseCrossValidator, TimeSeriesSplit
 
 from upgini.errors import ValidationError
 from upgini.metadata import ModelTaskType
@@ -57,6 +64,16 @@ CATBOOST_REGRESSION_PARAMS = {
     "allow_writing_files": False,
 }
 
+CATBOOST_TS_PARAMS = {
+    "learning_rate": 0.05,
+    "early_stopping_rounds": 20,
+    "use_best_model": True,
+    "one_hot_max_size": 100,
+    "verbose": False,
+    "random_state": 42,
+    "allow_writing_files": False,
+}
+
 CATBOOST_BINARY_PARAMS = {
     "iterations": 250,
     "learning_rate": 0.05,
@@ -311,6 +328,7 @@ class EstimatorWrapper:
         self.target_type = target_type
         self.add_params = add_params
         self.cv_estimators = None
+        self.cv_cat_encoders: Optional[List[Optional[HasTransform]]] = None
         self.groups = groups
         self.text_features = text_features
         self.logger = logger or logging.getLogger()
@@ -391,9 +409,7 @@ class EstimatorWrapper:
                     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)):
-                    self.logger.info(
-                        f"Convert float cat feature {c} to string"
-                    )
+                    self.logger.info(f"Convert float cat feature {c} to string")
                     x[c] = x[c].astype(str)
                     self.converted_to_str.append(c)
                 elif x[c].dtype not in ["category", "int64"]:
@@ -439,7 +455,9 @@ class EstimatorWrapper:
 
         return x, y, {}
 
-    def calculate_shap(self, x: pd.DataFrame, y: pd.Series, estimator) -> Optional[Dict[str, float]]:
+    def calculate_shap(
+        self, x: pd.DataFrame, y: pd.Series, estimator, cat_encoder: Optional[HasTransform]
+    ) -> Optional[Dict[str, float]]:
         return None
 
     def cross_val_predict(
@@ -470,9 +488,11 @@ class EstimatorWrapper:
                 fit_params=fit_params,
                 return_estimator=True,
                 error_score="raise",
+                random_state=DEFAULT_RANDOM_STATE,
             )
             metrics_by_fold = cv_results["test_score"]
             self.cv_estimators = cv_results["estimator"]
+            self.cv_cat_encoders = cv_results["cat_encoder"]
 
             self.check_fold_metrics(metrics_by_fold)
 
@@ -480,14 +500,14 @@ class EstimatorWrapper:
 
             splits = self.cv.split(x, y, groups)
 
-            for estimator, split in zip(self.cv_estimators, splits):
+            for estimator, cat_encoder, split in zip(self.cv_estimators, self.cv_cat_encoders, splits):
                 _, validation_idx = split
                 cv_x = x.iloc[validation_idx]
                 if isinstance(y, pd.Series):
                     cv_y = y.iloc[validation_idx]
                 else:
                     cv_y = y[validation_idx]
-                shaps = self.calculate_shap(cv_x, cv_y, estimator)
+                shaps = self.calculate_shap(cv_x, cv_y, estimator, cat_encoder)
                 if shaps is not None:
                     for feature, shap_value in shaps.items():
                         shap_values_all_folds[feature].append(shap_value)
@@ -527,8 +547,19 @@ class EstimatorWrapper:
             metric, metric_std = roc_auc_score(y, x[baseline_score_column]), None
         else:
             metrics = []
-            for est in self.cv_estimators:
-                metrics.append(self.scorer(est, x, y))
+            for est, cat_encoder in zip(self.cv_estimators, self.cv_cat_encoders):
+                x_copy = x.copy()
+                if cat_encoder is not None:
+                    if hasattr(cat_encoder, "feature_names_in_"):
+                        encoded = cat_encoder.transform(x_copy[cat_encoder.feature_names_in_])
+                    else:
+                        encoded = cat_encoder.transform(x[self.cat_features])
+                    if isinstance(self.cv, TimeSeriesSplit) or isinstance(self.cv, BlockedTimeSeriesSplit):
+                        encoded = encoded.astype(int)
+                    else:
+                        encoded = encoded.astype("category")
+                    x_copy[self.cat_features] = encoded
+                metrics.append(self.scorer(est, x_copy, y))
 
             metric, metric_std = self._calculate_metric_from_folds(metrics)
         return _CrossValResults(metric=metric, metric_std=metric_std, shap_values=None)
@@ -551,7 +582,7 @@ class EstimatorWrapper:
         text_features: Optional[List[str]] = None,
         add_params: Optional[Dict[str, Any]] = None,
         groups: Optional[List[str]] = None,
-        has_date: Optional[bool] = None,
+        has_time: bool = False,
     ) -> EstimatorWrapper:
         scorer, metric_name, multiplier = define_scorer(target_type, scoring)
         kwargs = {
@@ -568,7 +599,7 @@ class EstimatorWrapper:
         if estimator is None:
             if EstimatorWrapper.default_estimator == "catboost":
                 logger.info("Using CatBoost as default estimator")
-                params = {"has_time": has_date}
+                params = {"has_time": has_time}
                 if target_type == ModelTaskType.MULTICLASS:
                     params = _get_add_params(params, CATBOOST_MULTICLASS_PARAMS)
                     params = _get_add_params(params, add_params)
@@ -578,7 +609,10 @@ class EstimatorWrapper:
                     params = _get_add_params(params, add_params)
                     estimator = CatBoostWrapper(CatBoostClassifier(**params), **kwargs)
                 elif target_type == ModelTaskType.REGRESSION:
-                    params = _get_add_params(params, CATBOOST_REGRESSION_PARAMS)
+                    if not isinstance(cv, TimeSeriesSplit) and not isinstance(cv, BlockedTimeSeriesSplit):
+                        params = _get_add_params(params, CATBOOST_TS_PARAMS)
+                    else:
+                        params = _get_add_params(params, CATBOOST_REGRESSION_PARAMS)
                     params = _get_add_params(params, add_params)
                     estimator = CatBoostWrapper(CatBoostRegressor(**params), **kwargs)
                 else:
@@ -610,8 +644,8 @@ class EstimatorWrapper:
                 estimator_copy = deepcopy(estimator)
             kwargs["estimator"] = estimator_copy
             if is_catboost_estimator(estimator):
-                if has_date is not None:
-                    estimator_copy.set_params(has_time=has_date)
+                if has_time is not None:
+                    estimator_copy.set_params(has_time=has_time)
                 estimator = CatBoostWrapper(**kwargs)
             else:
                 if isinstance(estimator, (LGBMClassifier, LGBMRegressor)):
@@ -769,15 +803,24 @@ class CatBoostWrapper(EstimatorWrapper):
             else:
                 raise e
 
-    def calculate_shap(self, x: pd.DataFrame, y: pd.Series, estimator) -> Optional[Dict[str, float]]:
+    def calculate_shap(self, x: pd.DataFrame, y: pd.Series, estimator, cat_encoder) -> Optional[Dict[str, float]]:
         try:
             from catboost import Pool
 
+            if cat_encoder is not None:
+                if isinstance(self.cv, TimeSeriesSplit) or isinstance(self.cv, BlockedTimeSeriesSplit):
+                    encoded = cat_encoder.transform(x[self.cat_features]).astype(int)
+                    cat_features = None
+                else:
+                    encoded = cat_encoder.transform(x[self.cat_features])
+                    cat_features = encoded.columns.to_list()
+                x[self.cat_features] = encoded
+
             # Create Pool for fold data, if need (for example, when categorical features are present)
             fold_pool = Pool(
                 x,
                 y,
-                cat_features=self.cat_features,
+                cat_features=cat_features,
                 text_features=self.text_features,
                 embedding_features=self.grouped_embedding_features,
             )
@@ -834,7 +877,6 @@ class LightGBMWrapper(EstimatorWrapper):
             text_features=text_features,
             logger=logger,
         )
-        self.cat_encoder = None
         self.n_classes = None
 
     def _prepare_to_fit(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, pd.Series, np.ndarray, dict]:
@@ -846,10 +888,10 @@ class LightGBMWrapper(EstimatorWrapper):
                 params["eval_metric"] = "auc"
             params["callbacks"] = [lgb.early_stopping(stopping_rounds=LIGHTGBM_EARLY_STOPPING_ROUNDS, verbose=False)]
         if self.cat_features:
-            encoder = CatBoostEncoder(random_state=DEFAULT_RANDOM_STATE, cols=self.cat_features, return_df=True)
-            encoded = encoder.fit_transform(x[self.cat_features].astype("object"), y_numpy).astype("category")
-            x[self.cat_features] = encoded
-            self.cat_encoder = encoder
+            for c in self.cat_features:
+                if x[c].dtype != "category":
+                    x[c] = x[c].astype("category")
+
         for c in x.columns:
             if x[c].dtype not in ["category", "int64", "float64", "bool"]:
                 self.logger.warning(f"Feature {c} is not numeric and will be dropped")
@@ -859,15 +901,26 @@ class LightGBMWrapper(EstimatorWrapper):
 
     def _prepare_to_calculate(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, dict]:
         x, y_numpy, params = super()._prepare_to_calculate(x, y)
-        if self.cat_features is not None and self.cat_encoder is not None:
-            encoded = self.cat_encoder.transform(x[self.cat_features].astype("object"), y_numpy).astype("category")
-            x[self.cat_features] = encoded
+        if self.cat_features:
+            for c in self.cat_features:
+                if x[c].dtype != "category":
+                    x[c] = x[c].astype("category")
         return x, y_numpy, params
 
-    def calculate_shap(self, x: pd.DataFrame, y: pd.Series, estimator) -> Optional[Dict[str, float]]:
+    def calculate_shap(
+        self, x: pd.DataFrame, y: pd.Series, estimator, cat_encoder: Optional[HasTransform]
+    ) -> Optional[Dict[str, float]]:
         try:
+            x_copy = x.copy()
+            if cat_encoder is not None:
+                if isinstance(self.cv, TimeSeriesSplit) or isinstance(self.cv, BlockedTimeSeriesSplit):
+                    encoded = cat_encoder.transform(x_copy[self.cat_features]).astype(int)
+                else:
+                    encoded = cat_encoder.transform(x_copy[self.cat_features]).astype("category")
+                x_copy[self.cat_features] = encoded
+
             shap_matrix = estimator.predict(
-                x,
+                x_copy,
                 predict_disable_shape_check=True,
                 raw_score=True,
                 pred_leaf=False,
@@ -926,10 +979,10 @@ class OtherEstimatorWrapper(EstimatorWrapper):
         num_features = [col for col in x.columns if col not in self.cat_features]
         x[num_features] = x[num_features].fillna(-999)
         if self.cat_features:
-            encoder = CatBoostEncoder(random_state=DEFAULT_RANDOM_STATE, return_df=True)
-            encoded = encoder.fit_transform(x[self.cat_features].astype("object"), y_numpy).astype("category")
-            x[self.cat_features] = encoded
-            self.cat_encoder = encoder
+            for c in self.cat_features:
+                if x[c].dtype != "category":
+                    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"]:
                 self.logger.warning(f"Feature {c} is not numeric and will be dropped")
@@ -940,15 +993,22 @@ class OtherEstimatorWrapper(EstimatorWrapper):
     def _prepare_to_calculate(self, x: pd.DataFrame, y: pd.Series) -> Tuple[pd.DataFrame, np.ndarray, dict]:
         x, y_numpy, params = super()._prepare_to_calculate(x, y)
         if self.cat_features is not None:
+            for c in self.cat_features:
+                if x[c].dtype != "category":
+                    x[c] = x[c].astype("category")
             num_features = [col for col in x.columns if col not in self.cat_features]
-            x[num_features] = x[num_features].fillna(-999)
-            if self.cat_features and self.cat_encoder is not None:
-                x[self.cat_features] = self.cat_encoder.transform(
-                    x[self.cat_features].astype("object"), y_numpy
-                ).astype("category")
+        else:
+            num_features = x.columns
+        x[num_features] = x[num_features].fillna(-999)
+
         return x, y_numpy, params
 
 
+@runtime_checkable
+class HasTransform(Protocol):
+    def transform(self, X: pd.DataFrame, y: Optional[Union[pd.Series, np.ndarray]] = None) -> pd.DataFrame: ...
+
+
 def validate_scoring_argument(scoring: Union[Callable, str, None]):
     if scoring is None:
         return

upgini/utils/datetime_utils.py

@@ -41,6 +41,7 @@ class DateTimeSearchKeyConverter:
         date_format: Optional[str] = None,
         logger: Optional[logging.Logger] = None,
         bundle: Optional[ResourceBundle] = None,
+        generate_cyclical_features: bool = True,
     ):
         self.date_column = date_column
         self.date_format = date_format
@@ -51,6 +52,7 @@ class DateTimeSearchKeyConverter:
             self.logger.setLevel("FATAL")
         self.generated_features: List[str] = []
         self.bundle = bundle or get_custom_bundle()
+        self.generate_cyclical_features = generate_cyclical_features
         self.has_old_dates = False
 
     @staticmethod
@@ -121,61 +123,63 @@ class DateTimeSearchKeyConverter:
                 df[cos_feature] = np.cos(2 * np.pi * df[column] / period)
                 self.generated_features.append(cos_feature)
 
-        # df["quarter"] = df[self.date_column].dt.quarter
+        if self.generate_cyclical_features:
 
-        # # Calculate the start date of the quarter for each timestamp
-        # df["quarter_start"] = df[self.date_column].dt.to_period("Q").dt.start_time
+            df["quarter"] = df[self.date_column].dt.quarter
 
-        # # Calculate the day in the quarter
-        # df["day_in_quarter"] = (df[self.date_column] - df["quarter_start"]).dt.days + 1
+            # Calculate the start date of the quarter for each timestamp
+            df["quarter_start"] = df[self.date_column].dt.to_period("Q").dt.start_time
 
-        # # Vectorized calculation of days_in_quarter
-        # quarter = df["quarter"]
-        # start = df["quarter_start"]
-        # year = start.dt.year
-        # month = start.dt.month
+            # Calculate the day in the quarter
+            df["day_in_quarter"] = (df[self.date_column] - df["quarter_start"]).dt.days + 1
 
-        # quarter_end_year = np.where(quarter == 4, year + 1, year)
-        # quarter_end_month = np.where(quarter == 4, 1, month + 3)
+            # Vectorized calculation of days_in_quarter
+            quarter = df["quarter"]
+            start = df["quarter_start"]
+            year = start.dt.year
+            month = start.dt.month
 
-        # end = pd.to_datetime({"year": quarter_end_year, "month": quarter_end_month, "day": 1})
-        # end.index = df.index
+            quarter_end_year = np.where(quarter == 4, year + 1, year)
+            quarter_end_month = np.where(quarter == 4, 1, month + 3)
 
-        # df["days_in_quarter"] = (end - start).dt.days
+            end = pd.to_datetime({"year": quarter_end_year, "month": quarter_end_month, "day": 1})
+            end.index = df.index
 
-        # add_cyclical_features(df, "day_in_quarter", df["days_in_quarter"])  # Days in the quarter
+            df["days_in_quarter"] = (end - start).dt.days
 
-        # df.drop(columns=["quarter", "quarter_start", "day_in_quarter", "days_in_quarter"], inplace=True)
+            add_cyclical_features(df, "day_in_quarter", df["days_in_quarter"])  # Days in the quarter
 
-        df[seconds] = (df[self.date_column] - df[self.date_column].dt.floor("D")).dt.seconds
+            df.drop(columns=["quarter", "quarter_start", "day_in_quarter", "days_in_quarter"], inplace=True)
 
-        seconds_without_na = df[seconds].dropna()
-        if (seconds_without_na != 0).any() and seconds_without_na.nunique() > 1:
-            self.logger.info("Time found in date search key. Add extra features based on time")
+            df[seconds] = (df[self.date_column] - df[self.date_column].dt.floor("D")).dt.seconds
 
-            # Extract basic components
-            df["second"] = df[self.date_column].dt.second
-            df["minute"] = df[self.date_column].dt.minute
-            df["hour"] = df[self.date_column].dt.hour
+            seconds_without_na = df[seconds].dropna()
+            if (seconds_without_na != 0).any() and seconds_without_na.nunique() > 1:
+                self.logger.info("Time found in date search key. Add extra features based on time")
 
-            # Apply cyclical transformations
-            add_cyclical_features(df, "second", 60)  # Seconds in a minute
-            add_cyclical_features(df, "minute", 60)  # Minutes in an hour
-            add_cyclical_features(df, "minute", 30)  # Minutes in half an hour
-            add_cyclical_features(df, "hour", 24)  # Hours in a day
+                # Extract basic components
+                df["second"] = df[self.date_column].dt.second
+                df["minute"] = df[self.date_column].dt.minute
+                df["hour"] = df[self.date_column].dt.hour
 
-            # Drop intermediate columns if not needed
-            df.drop(columns=["second", "minute", "hour"], inplace=True)
-        else:
-            keep_time = False
+                # Apply cyclical transformations
+                add_cyclical_features(df, "second", 60)  # Seconds in a minute
+                add_cyclical_features(df, "minute", 60)  # Minutes in an hour
+                add_cyclical_features(df, "minute", 30)  # Minutes in half an hour
+                add_cyclical_features(df, "hour", 24)  # Hours in a day
+
+                # Drop intermediate columns if not needed
+                df.drop(columns=["second", "minute", "hour"], inplace=True)
+            else:
+                keep_time = False
 
-        for generated_feature in self.generated_features[:]:
-            if df[generated_feature].dropna().nunique() <= 1:
-                self.logger.warning(f"Generated constant feature {generated_feature} will be dropped")
-                df.drop(columns=generated_feature, inplace=True)
-                self.generated_features.remove(generated_feature)
+            for generated_feature in self.generated_features[:]:
+                if df[generated_feature].dropna().nunique() <= 1:
+                    self.logger.warning(f"Generated constant feature {generated_feature} will be dropped")
+                    df.drop(columns=generated_feature, inplace=True)
+                    self.generated_features.remove(generated_feature)
 
-        df.drop(columns=seconds, inplace=True)
+            df.drop(columns=seconds, inplace=True)
 
         if keep_time:
             df[self.DATETIME_COL] = df[self.date_column].astype(np.int64) // 1_000_000
@@ -247,99 +251,107 @@ def is_time_series(df: pd.DataFrame, date_col: str) -> bool:
 
 
 def is_blocked_time_series(df: pd.DataFrame, date_col: str, search_keys: List[str]) -> bool:
-    df = df.copy()
-    seconds = "datetime_seconds"
-    if isinstance(df[date_col].dtype, pd.PeriodDtype):
-        df[date_col] = df[date_col].dt.to_timestamp()
-    else:
-        df[date_col] = pd.to_datetime(df[date_col])
-    df[date_col] = df[date_col].dt.tz_localize(None)
-    df[seconds] = (df[date_col] - df[date_col].dt.floor("D")).dt.seconds
-
-    seconds_without_na = df[seconds].dropna()
-    columns_to_drop = [c for c in search_keys if c != date_col] + [seconds]
-    df.drop(columns=columns_to_drop, inplace=True)
-    # Date, not datetime
-    if (seconds_without_na != 0).any() and seconds_without_na.nunique() > 1:
-        return False
+    try:
+        df = df.copy()
+        seconds = "datetime_seconds"
+        if isinstance(df[date_col].dtype, pd.PeriodDtype):
+            df[date_col] = df[date_col].dt.to_timestamp()
+        elif is_numeric_dtype(df[date_col]):
+            df[date_col] = pd.to_datetime(df[date_col], unit="ms")
+        else:
+            df[date_col] = pd.to_datetime(df[date_col])
+        df[date_col] = df[date_col].dt.tz_localize(None)
+        df[seconds] = (df[date_col] - df[date_col].dt.floor("D")).dt.seconds
 
-    nunique_dates = df[date_col].nunique()
-    # Unique dates count more than 270
-    if nunique_dates < 270:
-        return False
+        seconds_without_na = df[seconds].dropna()
+        columns_to_drop = [c for c in search_keys if c != date_col] + [seconds]
+        df.drop(columns=columns_to_drop, inplace=True)
+        # Date, not datetime
+        if (seconds_without_na != 0).any() and seconds_without_na.nunique() > 1:
+            return False
 
-    min_date = df[date_col].min()
-    max_date = df[date_col].max()
-    days_delta = (max_date - min_date).days + 1
-    # Missing dates less than 30% (unique dates count and days delta between earliest and latest dates)
-    if nunique_dates / days_delta < 0.3:
-        return False
+        nunique_dates = df[date_col].nunique()
+        # Unique dates count more than 270
+        if nunique_dates < 270:
+            return False
+
+        min_date = df[date_col].min()
+        max_date = df[date_col].max()
+        days_delta = (max_date - min_date).days + 1
+        # Missing dates less than 30% (unique dates count and days delta between earliest and latest dates)
+        if nunique_dates / days_delta < 0.3:
+            return False
 
-    accumulated_changing_columns = set()
+        accumulated_changing_columns = set()
 
-    def check_differences(group: pd.DataFrame):
-        changing_columns = group.columns[group.nunique(dropna=False) > 1].to_list()
-        accumulated_changing_columns.update(changing_columns)
+        def check_differences(group: pd.DataFrame):
+            changing_columns = group.columns[group.nunique(dropna=False) > 1].to_list()
+            accumulated_changing_columns.update(changing_columns)
 
-    def is_multiple_rows(group: pd.DataFrame) -> bool:
-        return group.shape[0] > 1
+        def is_multiple_rows(group: pd.DataFrame) -> bool:
+            return group.shape[0] > 1
 
-    grouped = df.groupby(date_col)[[c for c in df.columns if c != date_col]]
-    dates_with_multiple_rows = grouped.apply(is_multiple_rows).sum()
+        grouped = df.groupby(date_col)[[c for c in df.columns if c != date_col]]
+        dates_with_multiple_rows = grouped.apply(is_multiple_rows).sum()
 
-    # share of dates with more than one record is more than 99%
-    if dates_with_multiple_rows / nunique_dates < 0.99:
-        return False
+        # share of dates with more than one record is more than 99%
+        if dates_with_multiple_rows / nunique_dates < 0.99:
+            return False
 
-    if df.shape[1] <= 3:
-        return True
+        if df.shape[1] <= 3:
+            return True
 
-    grouped.apply(check_differences)
-    return len(accumulated_changing_columns) <= 2
+        grouped.apply(check_differences)
+        return len(accumulated_changing_columns) <= 2
+    except Exception:
+        return False
 
 
 def is_dates_distribution_valid(
     df: pd.DataFrame,
     search_keys: Dict[str, SearchKey],
 ) -> bool:
-    maybe_date_col = SearchKey.find_key(search_keys, [SearchKey.DATE, SearchKey.DATETIME])
+    try:
+        maybe_date_col = SearchKey.find_key(search_keys, [SearchKey.DATE, SearchKey.DATETIME])
 
-    if EVAL_SET_INDEX in df.columns:
-        X = df.query(f"{EVAL_SET_INDEX} == 0")
-    else:
-        X = df
+        if EVAL_SET_INDEX in df.columns:
+            X = df.query(f"{EVAL_SET_INDEX} == 0")
+        else:
+            X = df
 
-    if maybe_date_col is None:
-        for col in X.columns:
-            if col in search_keys:
-                continue
-            try:
-                if isinstance(X[col].dtype, pd.PeriodDtype):
+        if maybe_date_col is None:
+            for col in X.columns:
+                if col in search_keys:
+                    continue
+                try:
+                    if isinstance(X[col].dtype, pd.PeriodDtype):
+                        pass
+                    elif pd.__version__ >= "2.0.0":
+                        # Format mixed to avoid massive warnings
+                        pd.to_datetime(X[col], format="mixed")
+                    else:
+                        pd.to_datetime(X[col])
+                    maybe_date_col = col
+                    break
+                except Exception:
                     pass
-                elif pd.__version__ >= "2.0.0":
-                    # Format mixed to avoid massive warnings
-                    pd.to_datetime(X[col], format="mixed")
-                else:
-                    pd.to_datetime(X[col])
-                maybe_date_col = col
-                break
-            except Exception:
-                pass
-
-    if maybe_date_col is None:
-        return
-
-    if isinstance(X[maybe_date_col].dtype, pd.PeriodDtype):
-        dates = X[maybe_date_col].dt.to_timestamp().dt.date
-    elif pd.__version__ >= "2.0.0":
-        dates = pd.to_datetime(X[maybe_date_col], format="mixed").dt.date
-    else:
-        dates = pd.to_datetime(X[maybe_date_col]).dt.date
-
-    date_counts = dates.value_counts().sort_index()
-
-    date_counts_1 = date_counts[: round(len(date_counts) / 2)]
-    date_counts_2 = date_counts[round(len(date_counts) / 2) :]
-    ratio = date_counts_2.mean() / date_counts_1.mean()
-
-    return ratio >= 0.8 and ratio <= 1.2
+
+        if maybe_date_col is None:
+            return
+
+        if isinstance(X[maybe_date_col].dtype, pd.PeriodDtype):
+            dates = X[maybe_date_col].dt.to_timestamp().dt.date
+        elif pd.__version__ >= "2.0.0":
+            dates = pd.to_datetime(X[maybe_date_col], format="mixed").dt.date
+        else:
+            dates = pd.to_datetime(X[maybe_date_col]).dt.date
+
+        date_counts = dates.value_counts().sort_index()
+
+        date_counts_1 = date_counts[: round(len(date_counts) / 2)]
+        date_counts_2 = date_counts[round(len(date_counts) / 2) :]
+        ratio = date_counts_2.mean() / date_counts_1.mean()
+
+        return ratio >= 0.8 and ratio <= 1.2
+    except Exception:
+        return False

upgini/utils/deduplicate_utils.py

@@ -104,9 +104,9 @@ def remove_fintech_duplicates(
         sub_df = pd.merge(sub_df, nonunique_target_rows, on=personal_cols)
 
         # Convert date columns for further checks
-        sub_df = DateTimeSearchKeyConverter(date_col, date_format=date_format, logger=logger, bundle=bundle).convert(
-            sub_df
-        )
+        sub_df = DateTimeSearchKeyConverter(
+            date_col, date_format=date_format, logger=logger, bundle=bundle, generate_cyclical_features=False
+        ).convert(sub_df)
         grouped_by_personal_cols = sub_df.groupby(personal_cols, group_keys=False)
         rows_with_diff_target = grouped_by_personal_cols.filter(has_diff_target_within_60_days)
 

upgini/utils/email_utils.py

@@ -36,11 +36,11 @@ class EmailDomainGenerator:
         self.generated_features = []
 
     def generate(self, df: pd.DataFrame) -> pd.DataFrame:
-        # for email_col in self.email_columns:
-        #     domain_feature = email_col + self.DOMAIN_SUFFIX
-        #     if domain_feature not in df.columns:
-        #         df[domain_feature] = df[email_col].apply(self._email_to_domain).astype("string")
-        #         self.generated_features.append(domain_feature)
+        for email_col in self.email_columns:
+            domain_feature = email_col + self.DOMAIN_SUFFIX
+            if domain_feature not in df.columns:
+                df[domain_feature] = df[email_col].apply(self._email_to_domain).astype("string")
+                self.generated_features.append(domain_feature)
         return df
 
     @staticmethod

upgini/utils/sklearn_ext.py

@@ -1,4 +1,5 @@
 import functools
+import inspect
 import numbers
 import time
 import warnings
@@ -9,6 +10,7 @@ from traceback import format_exc
 
 import numpy as np
 import scipy.sparse as sp
+from category_encoders import CatBoostEncoder
 from joblib import Parallel, logger
 from scipy.sparse import issparse
 from sklearn import config_context, get_config
@@ -16,10 +18,13 @@ from sklearn.base import clone, is_classifier
 from sklearn.exceptions import FitFailedWarning, NotFittedError
 from sklearn.metrics import check_scoring
 from sklearn.metrics._scorer import _MultimetricScorer
-from sklearn.model_selection import StratifiedKFold, check_cv
+from sklearn.model_selection import StratifiedKFold, TimeSeriesSplit, check_cv
+from sklearn.preprocessing import OrdinalEncoder
 from sklearn.utils.fixes import np_version, parse_version
 from sklearn.utils.validation import indexable
 
+from upgini.utils.blocked_time_series import BlockedTimeSeriesSplit
+
 # from sklearn.model_selection import cross_validate as original_cross_validate
 
 _DEFAULT_TAGS = {
@@ -59,6 +64,7 @@ def cross_validate(
     return_train_score=False,
     return_estimator=False,
     error_score=np.nan,
+    random_state=None,
 ):
     """Evaluate metric(s) by cross-validation and also record fit/score times.
 
@@ -279,6 +285,8 @@ def cross_validate(
                 return_times=True,
                 return_estimator=return_estimator,
                 error_score=error_score,
+                is_timeseries=isinstance(cv, TimeSeriesSplit) or isinstance(cv, BlockedTimeSeriesSplit),
+                random_state=random_state,
             )
             for train, test in cv.split(x, y, groups)
         )
@@ -296,6 +304,7 @@ def cross_validate(
         ret = {}
         ret["fit_time"] = results["fit_time"]
         ret["score_time"] = results["score_time"]
+        ret["cat_encoder"] = results["cat_encoder"]
 
         if return_estimator:
             ret["estimator"] = results["estimator"]
@@ -320,16 +329,16 @@ def cross_validate(
             else:
                 shuffle = False
             if hasattr(cv, "random_state") and shuffle:
-                random_state = cv.random_state
+                cv_random_state = cv.random_state
             else:
-                random_state = None
+                cv_random_state = None
             return cross_validate(
                 estimator,
                 x,
                 y,
                 groups=groups,
                 scoring=scoring,
-                cv=StratifiedKFold(n_splits=cv.get_n_splits(), shuffle=shuffle, random_state=random_state),
+                cv=StratifiedKFold(n_splits=cv.get_n_splits(), shuffle=shuffle, random_state=cv_random_state),
                 n_jobs=n_jobs,
                 verbose=verbose,
                 fit_params=fit_params,
@@ -337,21 +346,46 @@ def cross_validate(
                 return_train_score=return_train_score,
                 return_estimator=return_estimator,
                 error_score=error_score,
+                random_state=random_state,
             )
         raise e
 
 
-def is_catboost_estimator(estimator):
+def _is_catboost_estimator(estimator):
     try:
         from catboost import CatBoostClassifier, CatBoostRegressor
+
         return isinstance(estimator, (CatBoostClassifier, CatBoostRegressor))
     except ImportError:
         return False
 
 
-def is_lightgbm_estimator(estimator):
+def _supports_cat_features(estimator) -> bool:
+    """Check if estimator's fit method accepts cat_features parameter.
+
+    Parameters
+    ----------
+    estimator : estimator object
+        The estimator to check.
+
+    Returns
+    -------
+    bool
+        True if estimator's fit method accepts cat_features parameter, False otherwise.
+    """
+    try:
+        # Get the signature of the fit method
+        fit_params = inspect.signature(estimator.fit).parameters
+        # Check if cat_features is in the parameters
+        return "cat_features" in fit_params
+    except (AttributeError, ValueError):
+        return False
+
+
+def _is_lightgbm_estimator(estimator):
     try:
         from lightgbm import LGBMClassifier, LGBMRegressor
+
         return isinstance(estimator, (LGBMClassifier, LGBMRegressor))
     except ImportError:
         return False
@@ -375,6 +409,8 @@ def _fit_and_score(
     split_progress=None,
     candidate_progress=None,
     error_score=np.nan,
+    is_timeseries=False,
+    random_state=None,
 ):
     """Fit estimator and compute scores for a given dataset split.
 
@@ -509,13 +545,24 @@ def _fit_and_score(
 
     result = {}
     try:
+        if "cat_features" in fit_params and fit_params["cat_features"]:
+            X_train, y_train, X_test, y_test, cat_features, cat_encoder = _encode_cat_features(
+                X_train, y_train, X_test, y_test, fit_params["cat_features"], estimator, is_timeseries, random_state
+            )
+            if cat_features and _supports_cat_features(estimator):
+                fit_params["cat_features"] = cat_features
+            else:
+                del fit_params["cat_features"]
+        else:
+            cat_encoder = None
+        result["cat_encoder"] = cat_encoder
         if y_train is None:
             estimator.fit(X_train, **fit_params)
         else:
-            if is_catboost_estimator(estimator):
+            if _is_catboost_estimator(estimator):
                 fit_params = fit_params.copy()
                 fit_params["eval_set"] = [(X_test, y_test)]
-            elif is_lightgbm_estimator(estimator):
+            elif _is_lightgbm_estimator(estimator):
                 fit_params = fit_params.copy()
                 fit_params["eval_set"] = [(X_test, y_test)]
             estimator.fit(X_train, y_train, **fit_params)
@@ -1245,3 +1292,60 @@ def _num_samples(x):
         return len(x)
     except TypeError as type_error:
         raise TypeError(message) from type_error
+
+
+def _encode_cat_features(X_train, y_train, X_test, y_test, cat_features, estimator, is_timeseries, random_state):
+    if _is_catboost_estimator(estimator):
+        if is_timeseries:
+            # Fit encoder on training fold
+            encoder = OrdinalEncoder(handle_unknown="use_encoded_value", unknown_value=-1)
+            encoder.fit(X_train[cat_features], y_train)
+
+            X_train[cat_features] = encoder.transform(X_train[cat_features]).astype(int)
+            X_test[cat_features] = encoder.transform(X_test[cat_features]).astype(int)
+
+            # Don't use as categorical features, so CatBoost will not encode them
+            return X_train, y_train, X_test, y_test, [], encoder
+        else:
+            return X_train, y_train, X_test, y_test, cat_features, None
+    else:
+        if is_timeseries:
+            # Fit encoder on training fold
+            encoder = OrdinalEncoder(handle_unknown="use_encoded_value", unknown_value=-1)
+            encoder.fit(X_train[cat_features], y_train)
+
+            # Progressive encoding on train (using y)
+            X_train[cat_features] = encoder.transform(X_train[cat_features], y_train).astype(int)
+
+            # Static encoding on validation (no y)
+            X_test[cat_features] = encoder.transform(X_test[cat_features]).astype(int)
+
+            return X_train, y_train, X_test, y_test, [], encoder
+        else:
+            # Shuffle train data
+            X_train_shuffled, y_train_shuffled = _shuffle_pair(
+                X_train[cat_features].astype("object"), y_train, random_state
+            )
+
+            # Fit encoder on training fold
+            encoder = CatBoostEncoder(random_state=random_state, cols=cat_features)
+            encoder.fit(X_train_shuffled, y_train_shuffled)
+
+            # Progressive encoding on train (using y)
+            X_train[cat_features] = encoder.transform(X_train[cat_features], y_train).astype("category")
+
+            # Static encoding on validation (no y)
+            X_test[cat_features] = encoder.transform(X_test[cat_features]).astype("category")
+
+            return X_train, y_train, X_test, y_test, cat_features, encoder
+
+
+def _shuffle_pair(X, y, random_state):
+    # If X doesn't have reseted index there could be a problem
+    # shuffled_idx = np.random.RandomState(random_state).permutation(len(X))
+    # return X.iloc[shuffled_idx], pd.Series(y).iloc[shuffled_idx]
+
+    Xy = X.copy()
+    Xy["target"] = y
+    Xy_shuffled = Xy.sample(frac=1, random_state=random_state)
+    return Xy_shuffled.drop(columns="target"), Xy_shuffled["target"]

{upgini-1.2.86.dev1.dist-info → upgini-1.2.87.dev3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.86.dev1
+Version: 1.2.87.dev3
 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.86.dev1.dist-info → upgini-1.2.87.dev3.dist-info}/RECORD

@@ -1,12 +1,12 @@
-upgini/__about__.py,sha256=x1iyqkRuCxNu5kTIKv8yNfzxxa0JD4GnBFMpKHM2wRM,28
+upgini/__about__.py,sha256=-MoNpjvEXC0uIle8xxIgQduzBZJlNzuW-1rPMTm_xc8,28
 upgini/__init__.py,sha256=LXSfTNU0HnlOkE69VCxkgIKDhWP-JFo_eBQ71OxTr5Y,261
 upgini/ads.py,sha256=nvuRxRx5MHDMgPr9SiU-fsqRdFaBv8p4_v1oqiysKpc,2714
 upgini/dataset.py,sha256=fRtqSkXNONLnPe6cCL967GMt349FTIpXzy_u8LUKncw,35354
 upgini/errors.py,sha256=2b_Wbo0OYhLUbrZqdLIx5jBnAsiD1Mcenh-VjR4HCTw,950
-upgini/features_enricher.py,sha256=G0qbRPdlWe9p6cwYF3khP99-0kgAO8N0A2sfQxSLgmM,213446
+upgini/features_enricher.py,sha256=n8KBoBgJApLiRv4wXeSgfS-PfbB1D5aDOJfFnL0q6v8,214487
 upgini/http.py,sha256=6Qcepv0tDC72mBBJxYHnA2xqw6QwFaKrXN8o4vju8Es,44372
 upgini/metadata.py,sha256=zt_9k0iQbWXuiRZcel4ORNPdQKt6Ou69ucZD_E1Q46o,12341
-upgini/metrics.py,sha256=3cip0_L6-OFew74KsRwzxJDU6UFq05h2v7IsyHLcMRc,43164
+upgini/metrics.py,sha256=CR_MKBcq1RlNMXeqc9S374JzHgunMl-mEmlTnZAm_VI,45236
 upgini/search_task.py,sha256=Q5HjBpLIB3OCxAD1zNv5yQ3ZNJx696WCK_-H35_y7Rs,17912
 upgini/spinner.py,sha256=4iMd-eIe_BnkqFEMIliULTbj6rNI2HkN_VJ4qYe0cUc,1118
 upgini/version_validator.py,sha256=DvbaAvuYFoJqYt0fitpsk6Xcv-H1BYDJYHUMxaKSH_Y,1509
@@ -51,10 +51,10 @@ upgini/utils/blocked_time_series.py,sha256=Uqr3vp4YqNclj2-PzEYqVy763GSXHn86sbpIl
 upgini/utils/country_utils.py,sha256=lY-eXWwFVegdVENFttbvLcgGDjFO17Sex8hd2PyJaRk,6937
 upgini/utils/custom_loss_utils.py,sha256=kieNZYBYZm5ZGBltF1F_jOSF4ea6C29rYuCyiDcqVNY,3857
 upgini/utils/cv_utils.py,sha256=w6FQb9nO8BWDx88EF83NpjPLarK4eR4ia0Wg0kLBJC4,3525
-upgini/utils/datetime_utils.py,sha256=FKeCc5PQnhMSyLiw8nuiMccmMkrUCj4zCIgpZnffpbU,13569
-upgini/utils/deduplicate_utils.py,sha256=AcMLoObMjhOTQ_fMS1LWy0GKp6WXnZ-FNux_8V3nbZU,8914
+upgini/utils/datetime_utils.py,sha256=UL1ernnawW0LV9mPDpCIc6sFy0HUhFscWVNwfH4V7rI,14366
+upgini/utils/deduplicate_utils.py,sha256=jm9ARZ0fbJFF3aJqj-xm_T6lNh-WErM0H0h6B_L1xQc,8948
 upgini/utils/display_utils.py,sha256=hAeWEcJtPDg8fAVcMNrNB-azFD2WJp1nvbPAhR7SeP4,12071
-upgini/utils/email_utils.py,sha256=TZ_2UL0T7rzXG5WNu3dLUReY15qt6PozEGY_4cyuhdM,5287
+upgini/utils/email_utils.py,sha256=pZ2vCfNxLIPUhxr0-OlABNXm12jjU44isBk8kGmqQzA,5277
 upgini/utils/fallback_progress_bar.py,sha256=PDaKb8dYpVZaWMroNcOHsTc3pSjgi9mOm0--cOFTwJ0,1074
 upgini/utils/feature_info.py,sha256=Q9HN6A-fvfVD-irFWrmOqqZG9RsUSvh5MTY_k0xu-tE,7287
 upgini/utils/features_validator.py,sha256=lEfmk4DoxZ4ooOE1HC0ZXtUb_lFKRFHIrnFULZ4_rL8,3746
@@ -64,13 +64,13 @@ upgini/utils/mstats.py,sha256=u3gQVUtDRbyrOQK6V1UJ2Rx1QbkSNYGjXa6m3Z_dPVs,6286
 upgini/utils/phone_utils.py,sha256=IrbztLuOJBiePqqxllfABWfYlfAjYevPhXKipl95wUI,10432
 upgini/utils/postal_code_utils.py,sha256=5M0sUqH2DAr33kARWCTXR-ACyzWbjDq_-0mmEml6ZcU,1716
 upgini/utils/progress_bar.py,sha256=N-Sfdah2Hg8lXP_fV9EfUTXz_PyRt4lo9fAHoUDOoLc,1550
-upgini/utils/sklearn_ext.py,sha256=HpaNQaKJisgNE7IZ71n7uswxTj7kbPglU2G3s1sORAc,45042
+upgini/utils/sklearn_ext.py,sha256=Mdxz0tc-9zT4QyNccA3B86fY4l0MnLDr94POVdYeCT4,49332
 upgini/utils/sort.py,sha256=8uuHs2nfSMVnz8GgvbOmgMB1PgEIZP1uhmeRFxcwnYw,7039
 upgini/utils/target_utils.py,sha256=LRN840dzx78-wg7ftdxAkp2c1eu8-JDvkACiRThm4HE,16832
 upgini/utils/track_info.py,sha256=G5Lu1xxakg2_TQjKZk4b5SvrHsATTXNVV3NbvWtT8k8,5663
 upgini/utils/ts_utils.py,sha256=26vhC0pN7vLXK6R09EEkMK3Lwb9IVPH7LRdqFIQ3kPs,1383
 upgini/utils/warning_counter.py,sha256=-GRY8EUggEBKODPSuXAkHn9KnEQwAORC0mmz_tim-PM,254
-upgini-1.2.86.dev1.dist-info/METADATA,sha256=WbxVPEQbJJMxYSDRTiJAdevnfltYEQ8WjxyGgVv7vaE,49167
-upgini-1.2.86.dev1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-upgini-1.2.86.dev1.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
-upgini-1.2.86.dev1.dist-info/RECORD,,
+upgini-1.2.87.dev3.dist-info/METADATA,sha256=Pm-acVK8TpDLvPsO0qluwSjmu0cb3FHmtXmqMj--2Ag,49167
+upgini-1.2.87.dev3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+upgini-1.2.87.dev3.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
+upgini-1.2.87.dev3.dist-info/RECORD,,