upgini 1.2.60__tar.gz → 1.2.60a3792.dev2__tar.gz

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.60
+Version: 1.2.60a3792.dev2
 Summary: Intelligent data search & enrichment for Machine Learning
 Project-URL: Bug Reports, https://github.com/upgini/upgini/issues
 Project-URL: Homepage, https://upgini.com/
@@ -30,7 +30,6 @@ Requires-Dist: jarowinkler>=2.0.0
 Requires-Dist: levenshtein>=0.25.1
 Requires-Dist: numpy<=1.26.4,>=1.19.0
 Requires-Dist: pandas<3.0.0,>=1.1.0
-Requires-Dist: psutil>=6.0.0
 Requires-Dist: pydantic<3.0.0,>1.0.0
 Requires-Dist: pyjwt>=2.8.0
 Requires-Dist: python-bidi==0.4.2

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/pyproject.toml

@@ -50,7 +50,6 @@ dependencies = [
     "xhtml2pdf>=0.2.11,<0.3.0",
     "jarowinkler>=2.0.0",
     "levenshtein>=0.25.1",
-    "psutil>=6.0.0",
 ]
 
 [project.urls]

upgini-1.2.60a3792.dev2/src/upgini/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.2.60a3792.dev2"

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/src/upgini/autofe/date.py

@@ -1,6 +1,6 @@
 import abc
 import json
-from typing import Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 import numpy as np
 import pandas as pd

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/src/upgini/dataset.py

@@ -40,7 +40,7 @@ from upgini.utils.email_utils import EmailSearchKeyConverter
 from upgini.utils.target_utils import (
     balance_undersample,
     balance_undersample_forced,
-    balance_undersample_time_series,
+    balance_undersample_time_series_trunc,
 )
 
 try:
@@ -58,6 +58,8 @@ class Dataset:  # (pd.DataFrame):
     FIT_SAMPLE_THRESHOLD = 200_000
     FIT_SAMPLE_WITH_EVAL_SET_ROWS = 200_000
     FIT_SAMPLE_WITH_EVAL_SET_THRESHOLD = 200_000
+    FIT_SAMPLE_THRESHOLD_TS = 54_000
+    FIT_SAMPLE_ROWS_TS = 54_000
     BINARY_MIN_SAMPLE_THRESHOLD = 5_000
     MULTICLASS_MIN_SAMPLE_THRESHOLD = 25_000
     IMBALANCE_THESHOLD = 0.6
@@ -301,7 +303,10 @@ class Dataset:  # (pd.DataFrame):
                 )
 
         # Resample over fit threshold
-        if not self.imbalanced and EVAL_SET_INDEX in self.data.columns:
+        if self.cv_type is not None and self.cv_type.is_time_series():
+            sample_threshold = self.FIT_SAMPLE_THRESHOLD_TS
+            sample_rows = self.FIT_SAMPLE_ROWS_TS
+        elif not self.imbalanced and EVAL_SET_INDEX in self.data.columns:
             sample_threshold = self.FIT_SAMPLE_WITH_EVAL_SET_THRESHOLD
             sample_rows = self.FIT_SAMPLE_WITH_EVAL_SET_ROWS
         else:
@@ -314,7 +319,7 @@ class Dataset:  # (pd.DataFrame):
                 f"and will be downsampled to {sample_rows}"
             )
             if self.cv_type is not None and self.cv_type.is_time_series():
-                resampled_data = balance_undersample_time_series(
+                resampled_data = balance_undersample_time_series_trunc(
                     df=self.data,
                     id_columns=self.id_columns,
                     date_column=next(
@@ -584,10 +589,7 @@ class Dataset:  # (pd.DataFrame):
         return search_customization
 
     def _rename_generate_features(self, runtime_parameters: Optional[RuntimeParameters]) -> Optional[RuntimeParameters]:
-        if (
-            runtime_parameters is not None
-            and runtime_parameters.properties is not None
-        ):
+        if runtime_parameters is not None and runtime_parameters.properties is not None:
             if "generate_features" in runtime_parameters.properties:
                 generate_features = runtime_parameters.properties["generate_features"].split(",")
                 renamed_generate_features = []
@@ -607,6 +609,13 @@ class Dataset:  # (pd.DataFrame):
 
         return runtime_parameters
 
+    def _set_sample_size(self, runtime_parameters: Optional[RuntimeParameters]) -> Optional[RuntimeParameters]:
+        if runtime_parameters is not None and runtime_parameters.properties is not None:
+            if self.cv_type is not None and self.cv_type.is_time_series():
+                runtime_parameters.properties["sample_size"] = self.FIT_SAMPLE_ROWS_TS
+                runtime_parameters.properties["iter0_sample_size"] = self.FIT_SAMPLE_ROWS_TS
+        return runtime_parameters
+
     def _clean_generate_features(self, runtime_parameters: Optional[RuntimeParameters]) -> Optional[RuntimeParameters]:
         if (
             runtime_parameters is not None
@@ -638,6 +647,7 @@ class Dataset:  # (pd.DataFrame):
         file_metrics = FileMetrics()
 
         runtime_parameters = self._rename_generate_features(runtime_parameters)
+        runtime_parameters = self._set_sample_size(runtime_parameters)
 
         file_metadata = self.__construct_metadata(exclude_features_sources)
         search_customization = self.__construct_search_customization(

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/src/upgini/features_enricher.py

@@ -112,7 +112,6 @@ try:
 except Exception:
     from upgini.utils.fallback_progress_bar import CustomFallbackProgressBar as ProgressBar
 
-from upgini.utils.sort import sort_columns
 from upgini.utils.target_utils import (
     balance_undersample_forced,
     calculate_psi,
@@ -1262,7 +1261,7 @@ class FeaturesEnricher(TransformerMixin):
             for feature, shap in new_shaps.items()
             if feature in self.feature_names_ or renaming.get(feature, feature) in self.feature_names_
         }
-        self.__prepare_feature_importances(trace_id, x_columns, new_shaps)
+        self.__prepare_feature_importances(trace_id, x_columns, new_shaps, silent=True)
 
         if self.features_info_display_handle is not None:
             try:
@@ -1569,23 +1568,9 @@ class FeaturesEnricher(TransformerMixin):
 
         fitting_eval_set_dict = {}
         fitting_x_columns = fitting_X.columns.to_list()
-        # Idempotently sort columns
-        fitting_x_columns = sort_columns(
-            fitting_X, y_sorted, search_keys, self.model_task_type, sort_all_columns=True, logger=self.logger
-        )
-        fitting_X = fitting_X[fitting_x_columns]
-        self.logger.info(f"Final sorted list of fitting X columns: {fitting_x_columns}")
+        self.logger.info(f"Final list of fitting X columns: {fitting_x_columns}")
         fitting_enriched_x_columns = fitting_enriched_X.columns.to_list()
-        fitting_enriched_x_columns = sort_columns(
-            fitting_enriched_X,
-            enriched_y_sorted,
-            search_keys,
-            self.model_task_type,
-            sort_all_columns=True,
-            logger=self.logger,
-        )
-        fitting_enriched_X = fitting_enriched_X[fitting_enriched_x_columns]
-        self.logger.info(f"Final sorted list of fitting enriched X columns: {fitting_enriched_x_columns}")
+        self.logger.info(f"Final list of fitting enriched X columns: {fitting_enriched_x_columns}")
         for idx, eval_tuple in eval_set_sampled_dict.items():
             eval_X_sampled, enriched_eval_X, eval_y_sampled = eval_tuple
             eval_X_sorted, eval_y_sorted = self._sort_by_system_record_id(eval_X_sampled, eval_y_sampled, self.cv)
@@ -1749,15 +1734,11 @@ class FeaturesEnricher(TransformerMixin):
             if eval_set is not None
             else (Dataset.FIT_SAMPLE_THRESHOLD, Dataset.FIT_SAMPLE_ROWS)
         )
-
-        df = self.__add_fit_system_record_id(df, search_keys, SYSTEM_RECORD_ID, TARGET, columns_renaming, silent=True)
-        # Sample after sorting by system_record_id for idempotency
-        df.sort_values(by=SYSTEM_RECORD_ID, inplace=True)
-
         if num_samples > sample_threshold:
             self.logger.info(f"Downsampling from {num_samples} to {sample_rows}")
             df = df.sample(n=sample_rows, random_state=self.random_state)
 
+        df = self.__add_fit_system_record_id(df, search_keys, SYSTEM_RECORD_ID)
         if DateTimeSearchKeyConverter.DATETIME_COL in df.columns:
             df = df.drop(columns=DateTimeSearchKeyConverter.DATETIME_COL)
 
@@ -1901,7 +1882,6 @@ class FeaturesEnricher(TransformerMixin):
                 and self.columns_for_online_api is not None
                 and num_samples > Dataset.FORCE_SAMPLE_SIZE
             )
-            # TODO: check that system_record_id was added before this step
             if force_downsampling:
                 self.logger.info(f"Force downsampling from {num_samples} to {Dataset.FORCE_SAMPLE_SIZE}")
                 df = balance_undersample_forced(
@@ -1935,7 +1915,6 @@ class FeaturesEnricher(TransformerMixin):
                 progress_bar=progress_bar,
                 progress_callback=progress_callback,
                 add_fit_system_record_id=True,
-                target_name=tmp_target_name,
             )
             if enriched_df is None:
                 return None
@@ -1974,7 +1953,6 @@ class FeaturesEnricher(TransformerMixin):
                 and self.columns_for_online_api is not None
                 and num_samples > Dataset.FORCE_SAMPLE_SIZE
             )
-
             if force_downsampling:
                 self.logger.info(f"Force downsampling from {num_samples} to {Dataset.FORCE_SAMPLE_SIZE}")
                 df = balance_undersample_forced(
@@ -2006,7 +1984,6 @@ class FeaturesEnricher(TransformerMixin):
                 progress_bar=progress_bar,
                 progress_callback=progress_callback,
                 add_fit_system_record_id=True,
-                target_name=tmp_target_name,
             )
             if enriched_Xy is None:
                 return None
@@ -2168,7 +2145,6 @@ if response.status_code == 200:
         progress_bar: Optional[ProgressBar] = None,
         progress_callback: Optional[Callable[[SearchProgress], Any]] = None,
         add_fit_system_record_id: bool = False,
-        target_name: Optional[str] = None,
     ) -> Tuple[pd.DataFrame, Dict[str, str], List[str]]:
         if self._search_task is None:
             raise NotFittedError(self.bundle.get("transform_unfitted_enricher"))
@@ -2353,16 +2329,8 @@ if response.status_code == 200:
                 and c not in [ENTITY_SYSTEM_RECORD_ID, SEARCH_KEY_UNNEST]
             ]
 
-            if add_fit_system_record_id and target_name is not None:
-                reversed_columns_renaming = {v: k for k, v in columns_renaming.items()}
-                df = self.__add_fit_system_record_id(
-                    df,
-                    search_keys,
-                    SYSTEM_RECORD_ID,
-                    reversed_columns_renaming.get(target_name, target_name),
-                    columns_renaming,
-                    silent=True,
-                )
+            if add_fit_system_record_id:
+                df = self.__add_fit_system_record_id(df, search_keys, SYSTEM_RECORD_ID)
                 df = df.rename(columns={SYSTEM_RECORD_ID: SORT_ID})
                 features_not_to_pass.append(SORT_ID)
 
@@ -2807,9 +2775,7 @@ if response.status_code == 200:
             self.__log_warning(full_duplicates_warning)
 
         # Explode multiple search keys
-        df = self.__add_fit_system_record_id(
-            df, self.fit_search_keys, ENTITY_SYSTEM_RECORD_ID, TARGET, self.fit_columns_renaming
-        )
+        df = self.__add_fit_system_record_id(df, self.fit_search_keys, ENTITY_SYSTEM_RECORD_ID)
 
         # TODO check that this is correct for enrichment
         self.df_with_original_index = df.copy()
@@ -2891,9 +2857,7 @@ if response.status_code == 200:
         if eval_set is not None and len(eval_set) > 0:
             meaning_types[EVAL_SET_INDEX] = FileColumnMeaningType.EVAL_SET_INDEX
 
-        df = self.__add_fit_system_record_id(
-            df, self.fit_search_keys, SYSTEM_RECORD_ID, TARGET, self.fit_columns_renaming, silent=True
-        )
+        df = self.__add_fit_system_record_id(df, self.fit_search_keys, SYSTEM_RECORD_ID)
 
         if DateTimeSearchKeyConverter.DATETIME_COL in df.columns:
             df = df.drop(columns=DateTimeSearchKeyConverter.DATETIME_COL)
@@ -3580,82 +3544,56 @@ if response.status_code == 200:
     def __add_fit_system_record_id(
         self,
         df: pd.DataFrame,
+        # meaning_types: Dict[str, FileColumnMeaningType],
         search_keys: Dict[str, SearchKey],
         id_name: str,
-        target_name: str,
-        columns_renaming: Dict[str, str],
-        silent: bool = False,
     ) -> pd.DataFrame:
+        # save original order or rows
         original_index_name = df.index.name
         index_name = df.index.name or DEFAULT_INDEX
         original_order_name = "original_order"
-        # Save original index
         df = df.reset_index().rename(columns={index_name: ORIGINAL_INDEX})
-        # Save original order
         df = df.reset_index().rename(columns={DEFAULT_INDEX: original_order_name})
 
-        # order by date and idempotent order by other keys and features
+        # order by date and idempotent order by other keys
+        if self.cv not in [CVType.time_series, CVType.blocked_time_series]:
+            sort_exclude_columns = [
+                original_order_name,
+                ORIGINAL_INDEX,
+                EVAL_SET_INDEX,
+                TARGET,
+                "__target",
+                ENTITY_SYSTEM_RECORD_ID,
+            ]
+            if DateTimeSearchKeyConverter.DATETIME_COL in df.columns:
+                date_column = DateTimeSearchKeyConverter.DATETIME_COL
+                sort_exclude_columns.append(self._get_date_column(search_keys))
+            else:
+                date_column = self._get_date_column(search_keys)
+            sort_columns = [date_column] if date_column is not None else []
 
-        sort_exclude_columns = [
-            original_order_name,
-            ORIGINAL_INDEX,
-            EVAL_SET_INDEX,
-            TARGET,
-            "__target",
-            ENTITY_SYSTEM_RECORD_ID,
-        ]
-        if DateTimeSearchKeyConverter.DATETIME_COL in df.columns:
-            date_column = DateTimeSearchKeyConverter.DATETIME_COL
-            sort_exclude_columns.append(FeaturesEnricher._get_date_column(search_keys))
-        else:
-            date_column = FeaturesEnricher._get_date_column(search_keys)
-        sort_exclude_columns.append(date_column)
-        columns_to_sort = [date_column] if date_column is not None else []
-
-        do_sorting = True
-        if self.id_columns and self.cv in [CVType.time_series, CVType.blocked_time_series]:
-            # Check duplicates by date and id_columns
-            reversed_columns_renaming = {v: k for k, v in columns_renaming.items()}
-            renamed_id_columns = [reversed_columns_renaming.get(c, c) for c in self.id_columns]
-            duplicate_check_columns = [c for c in renamed_id_columns if c in df.columns]
-            if date_column is not None:
-                duplicate_check_columns.append(date_column)
+            sorted_other_keys = sorted(search_keys, key=lambda x: str(search_keys.get(x)))
+            sorted_other_keys = [k for k in sorted_other_keys if k not in sort_exclude_columns]
 
-            duplicates = df.duplicated(subset=duplicate_check_columns, keep=False)
-            if duplicates.any():
-                if not silent:
-                    self.__log_warning(self.bundle.get("date_and_id_columns_duplicates").format(duplicates.sum()))
-                else:
-                    self.logger.warning(
-                        f"Found {duplicates.sum()} duplicate rows by date and ID columns: {duplicate_check_columns}."
-                        " Will not sort dataset"
-                    )
-                do_sorting = False
-            else:
-                columns_to_hash = list(search_keys.keys()) + renamed_id_columns + [target_name]
-                columns_to_hash = sort_columns(
-                    df[columns_to_hash],
-                    target_name,
-                    search_keys,
-                    self.model_task_type,
-                    sort_exclude_columns,
-                    logger=self.logger,
-                )
-        else:
-            columns_to_hash = sort_columns(
-                df, target_name, search_keys, self.model_task_type, sort_exclude_columns, logger=self.logger
+            other_columns = sorted(
+                [
+                    c
+                    for c in df.columns
+                    if c not in sort_columns
+                    and c not in sorted_other_keys
+                    and c not in sort_exclude_columns
+                    and df[c].nunique() > 1
+                ]
             )
-        if do_sorting:
+
+            all_other_columns = sorted_other_keys + other_columns
+
             search_keys_hash = "search_keys_hash"
-            if len(columns_to_hash) > 0:
-                factorized_df = df.copy()
-                for col in columns_to_hash:
-                    if col not in search_keys and not is_numeric_dtype(factorized_df[col]):
-                        factorized_df[col] = factorized_df[col].factorize(sort=True)[0]
-                df[search_keys_hash] = pd.util.hash_pandas_object(factorized_df[columns_to_hash], index=False)
-                columns_to_sort.append(search_keys_hash)
-
-            df = df.sort_values(by=columns_to_sort)
+            if len(all_other_columns) > 0:
+                sort_columns.append(search_keys_hash)
+                df[search_keys_hash] = pd.util.hash_pandas_object(df[all_other_columns], index=False)
+
+            df = df.sort_values(by=sort_columns)
 
             if search_keys_hash in df.columns:
                 df.drop(columns=search_keys_hash, inplace=True)

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/src/upgini/metrics.py

@@ -30,8 +30,8 @@ except ImportError:
 from sklearn.metrics._regression import (
     _check_reg_targets,
     check_consistent_length,
+    mean_squared_error,
 )
-from sklearn.metrics import mean_squared_error
 from sklearn.model_selection import BaseCrossValidator
 
 from upgini.errors import ValidationError
@@ -289,6 +289,9 @@ class EstimatorWrapper:
         else:
             x, y = self._remove_empty_target_rows(x, y)
 
+        # Make order of columns idempotent
+        x = x[sorted(x.columns)]
+
         self.logger.info(f"After preparing data columns: {x.columns.to_list()}")
         return x, y, groups
 
@@ -566,7 +569,7 @@ class CatBoostWrapper(EstimatorWrapper):
             if all([isinstance(c, int) for c in estimator_cat_features]):
                 cat_features_idx = {x.columns.get_loc(c) for c in self.cat_features}
                 cat_features_idx.update(estimator_cat_features)
-                self.cat_features = [x.columns[idx] for idx in cat_features_idx]
+                self.cat_features = [x.columns[idx] for idx in sorted(cat_features_idx)]
             elif all([isinstance(c, str) for c in estimator_cat_features]):
                 self.cat_features = list(set(self.cat_features + estimator_cat_features))
             else:
@@ -937,13 +940,13 @@ def _ext_mean_squared_log_error(y_true, y_pred, *, sample_weight=None, multioutp
     if (y_true < 0).any():
         raise ValidationError(bundle.get("metrics_msle_negative_target"))
 
-    mse = mean_squared_error(
+    return mean_squared_error(
         log1p(y_true),
         log1p(y_pred.clip(0)),
         sample_weight=sample_weight,
         multioutput=multioutput,
+        squared=squared,
     )
-    return mse if squared else np.sqrt(mse)
 
 
 def fill_na_cat_features(df: pd.DataFrame, cat_features: List[str]) -> pd.DataFrame:

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/src/upgini/resource_bundle/strings.properties

@@ -35,7 +35,6 @@ trial_quota_limit_riched=You have reached the quota limit of trial data usage. P
 loss_selection_warn=Loss `{0}` is not supported for feature selection with {1}
 loss_calc_metrics_warn=Loss `{0}` is not supported for metrics calculation with {1}
 multivariate_timeseries_detected=Multivariate TimeSeries detected. Blocked time series cross-validation split selected.\nMore details: https://github.com/upgini/upgini#-time-series-prediction-support
-date_and_id_columns_duplicates=Found {} duplicate rows by date and id_columns
 group_k_fold_in_classification=Using group K-fold cross-validation split for classification task.
 current_date_added=No date/datetime column was detected in X to be used as a search key. The current date will be used to match the latest version of data sources
 # Errors

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/src/upgini/utils/datetime_utils.py

@@ -166,8 +166,6 @@ class DateTimeSearchKeyConverter:
 
             # 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:

{upgini-1.2.60 → upgini-1.2.60a3792.dev2}/src/upgini/utils/target_utils.py

@@ -1,3 +1,4 @@
+import itertools
 import logging
 from typing import Callable, List, Optional, Union
 
@@ -9,6 +10,7 @@ from upgini.errors import ValidationError
 from upgini.metadata import SYSTEM_RECORD_ID, CVType, ModelTaskType
 from upgini.resource_bundle import ResourceBundle, bundle, get_custom_bundle
 from upgini.sampler.random_under_sampler import RandomUnderSampler
+from upgini.utils.ts_utils import get_most_frequent_time_unit, trunc_datetime
 
 TS_MIN_DIFFERENT_IDS_RATIO = 0.2
 
@@ -206,7 +208,7 @@ def balance_undersample_forced(
     id_columns: List[str],
     date_column: str,
     task_type: ModelTaskType,
-    cv_type: Optional[CVType],
+    cv_type: CVType | None,
     random_state: int,
     sample_size: int = 7000,
     logger: Optional[logging.Logger] = None,
@@ -240,7 +242,7 @@ def balance_undersample_forced(
     df = df.copy().sort_values(by=SYSTEM_RECORD_ID)
     if cv_type is not None and cv_type.is_time_series():
         logger.warning(f"Sampling time series dataset from {len(df)} to {sample_size}")
-        resampled_data = balance_undersample_time_series(
+        resampled_data = balance_undersample_time_series_trunc(
             df,
             id_columns=id_columns,
             date_column=date_column,
@@ -279,6 +281,58 @@ def balance_undersample_forced(
     return resampled_data
 
 
+DEFAULT_HIGH_FREQ_TRUNC_LENGTHS = [pd.DateOffset(years=2, months=6), pd.DateOffset(years=2, days=7)]
+DEFAULT_LOW_FREQ_TRUNC_LENGTHS = [pd.DateOffset(years=7), pd.DateOffset(years=5)]
+DEFAULT_TIME_UNIT_THRESHOLD = pd.Timedelta(weeks=4)
+
+
+def balance_undersample_time_series_trunc(
+    df: pd.DataFrame,
+    id_columns: List[str],
+    date_column: str,
+    sample_size: int,
+    random_state: int = 42,
+    logger: Optional[logging.Logger] = None,
+    highfreq_trunc_lengths: List[pd.DateOffset] = DEFAULT_HIGH_FREQ_TRUNC_LENGTHS,
+    lowfreq_trunc_lengths: List[pd.DateOffset] = DEFAULT_LOW_FREQ_TRUNC_LENGTHS,
+    time_unit_threshold: pd.Timedelta = DEFAULT_TIME_UNIT_THRESHOLD,
+    **kwargs,
+):
+    # Convert date column to datetime
+    dates_df = df[id_columns + [date_column]].copy()
+    dates_df[date_column] = pd.to_datetime(dates_df[date_column], unit="ms")
+
+    time_unit = get_most_frequent_time_unit(dates_df, id_columns, date_column)
+    if logger is not None:
+        logger.info(f"Time unit: {time_unit}")
+
+    if time_unit is None:
+        if logger is not None:
+            logger.info("Cannot detect time unit, returning original dataset")
+        return df
+
+    if time_unit < time_unit_threshold:
+        for trunc_length in highfreq_trunc_lengths:
+            sampled_df = trunc_datetime(dates_df, id_columns, date_column, trunc_length, logger=logger)
+            if len(sampled_df) <= sample_size:
+                break
+        if len(sampled_df) > sample_size:
+            sampled_df = balance_undersample_time_series(
+                sampled_df, id_columns, date_column, sample_size, random_state, logger=logger, **kwargs
+            )
+    else:
+        for trunc_length in lowfreq_trunc_lengths:
+            sampled_df = trunc_datetime(dates_df, id_columns, date_column, trunc_length, logger=logger)
+            if len(sampled_df) <= sample_size:
+                break
+        if len(sampled_df) > sample_size:
+            sampled_df = balance_undersample_time_series(
+                sampled_df, id_columns, date_column, sample_size, random_state, logger=logger, **kwargs
+            )
+
+    return df.loc[sampled_df.index]
+
+
 def balance_undersample_time_series(
     df: pd.DataFrame,
     id_columns: List[str],
@@ -318,8 +372,7 @@ def balance_undersample_time_series(
     if len(id_counts) < min_different_ids:
         if logger is not None:
             logger.info(
-                f"Different ids count {len(id_counts)} for sample size {sample_size}"
-                f" is less than min different ids {min_different_ids}, sampling time window"
+                f"Different ids count {len(id_counts)} for sample size {sample_size} is less than min different ids {min_different_ids}, sampling time window"
             )
         date_counts = df.groupby(id_columns)[date_column].nunique().sort_values(ascending=False)
         ids_to_sample = date_counts.index[:min_different_ids] if len(id_counts) > 0 else date_counts.index

upgini-1.2.60a3792.dev2/src/upgini/utils/ts_utils.py

@@ -0,0 +1,47 @@
+import logging
+from typing import List, Optional
+import pandas as pd
+
+
+def get_most_frequent_time_unit(df: pd.DataFrame, id_columns: List[str], date_column: str) -> Optional[pd.DateOffset]:
+
+    def closest_unit(diff):
+        return pd.tseries.frequencies.to_offset(pd.Timedelta(diff, unit="s"))
+
+    # Calculate differences for each ID group
+    all_diffs = []
+    groups = df.groupby(id_columns) if id_columns else [(None, df)]
+    for _, group in groups:
+        # Get sorted dates for this group
+        group_dates = group[date_column].sort_values().unique()
+        if len(group_dates) > 1:
+            # Calculate time differences between consecutive dates
+            diff_series = pd.Series(group_dates[1:] - group_dates[:-1])
+            # Convert to nanoseconds
+            diff_ns = diff_series.dt.total_seconds()
+            all_diffs.extend(diff_ns)
+
+    # Convert to series for easier processing
+    all_diffs = pd.Series(all_diffs)
+
+    # Get most common time unit across all groups
+    most_frequent_unit = all_diffs.apply(closest_unit).mode().min()
+
+    return most_frequent_unit if isinstance(most_frequent_unit, pd.DateOffset) else None
+
+
+def trunc_datetime(
+    df: pd.DataFrame,
+    id_columns: List[str],
+    date_column: str,
+    length: pd.DateOffset,
+    logger: Optional[logging.Logger] = None,
+) -> pd.DataFrame:
+    if logger is not None:
+        logger.info(f"Truncating time series dataset to {length}")
+
+    if id_columns:
+        min_datetime = df.groupby(id_columns)[date_column].transform(lambda group: group.max() - length)
+    else:
+        min_datetime = df[date_column].max() - length
+    return df[df[date_column] > min_datetime]

upgini-1.2.60/src/upgini/__about__.py

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

upgini-1.2.60/src/upgini/utils/mstats.py

@@ -1,177 +0,0 @@
-import warnings
-from collections import namedtuple
-
-import numpy as np
-import numpy.ma as ma
-import scipy
-from joblib import Parallel, delayed
-from numpy import ndarray
-from psutil import cpu_count
-
-np.seterr(divide="ignore")
-
-
-warnings.simplefilter(action="ignore", category=RuntimeWarning)
-
-
-def _find_repeats(arr):
-    # This function assumes it may clobber its input.
-    if len(arr) == 0:
-        return np.array(0, np.float64), np.array(0, np.intp)
-
-    # XXX This cast was previously needed for the Fortran implementation,
-    # should we ditch it?
-    arr = np.asarray(arr, np.float64).ravel()
-    arr.sort()
-
-    # Taken from NumPy 1.9's np.unique.
-    change = np.concatenate(([True], arr[1:] != arr[:-1]))
-    unique = arr[change]
-    change_idx = np.concatenate(np.nonzero(change) + ([arr.size],))
-    freq = np.diff(change_idx)
-    atleast2 = freq > 1
-    return unique[atleast2], freq[atleast2]
-
-
-def find_repeats(arr):
-    # Make sure we get a copy. ma.compressed promises a "new array", but can
-    # actually return a reference.
-    compr = np.asarray(ma.compressed(arr), dtype=np.float64)
-    try:
-        need_copy = np.may_share_memory(compr, arr)
-    except AttributeError:
-        # numpy < 1.8.2 bug: np.may_share_memory([], []) raises,
-        # while in numpy 1.8.2 and above it just (correctly) returns False.
-        need_copy = False
-    if need_copy:
-        compr = compr.copy()
-    return _find_repeats(compr)
-
-
-def rankdata(data, axis=None, use_missing=False):
-    def _rank1d(data, use_missing=False):
-        n = data.count()
-        rk = np.empty(data.size, dtype=float)
-        idx = data.argsort()
-        rk[idx[:n]] = np.arange(1, n + 1)
-
-        if use_missing:
-            rk[idx[n:]] = (n + 1) / 2.0
-        else:
-            rk[idx[n:]] = 0
-
-        repeats = find_repeats(data.copy())
-        for r in repeats[0]:
-            condition = (data == r).filled(False)
-            rk[condition] = rk[condition].mean()
-        return rk
-
-    data = ma.array(data, copy=False)
-    if axis is None:
-        if data.ndim > 1:
-            return _rank1d(data.ravel(), use_missing).reshape(data.shape)
-        else:
-            return _rank1d(data, use_missing)
-    else:
-        return ma.apply_along_axis(_rank1d, axis, data, use_missing).view(ndarray)
-
-
-def _chk_asarray(a, axis):
-    # Always returns a masked array, raveled for axis=None
-    a = ma.asanyarray(a)
-    if axis is None:
-        a = ma.ravel(a)
-        outaxis = 0
-    else:
-        outaxis = axis
-    return a, outaxis
-
-
-SpearmanrResult = namedtuple("SpearmanrResult", ("correlation", "pvalue"))
-
-
-# Taken from scipy.mstats with following tweaks:
-# 1. parallel pairwise computation
-# 2. custom masking
-def spearmanr(
-    x, y=None, use_ties=True, axis=None, nan_policy="propagate", alternative="two-sided", mask_fn=ma.masked_invalid
-):
-    if not use_ties:
-        raise ValueError("`use_ties=False` is not supported in SciPy >= 1.2.0")
-
-    # Always returns a masked array, raveled if axis=None
-    x, axisout = _chk_asarray(x, axis)
-    if y is not None:
-        # Deal only with 2-D `x` case.
-        y, _ = _chk_asarray(y, axis)
-        if axisout == 0:
-            x = ma.column_stack((x, y))
-        else:
-            x = ma.row_stack((x, y))
-
-    if axisout == 1:
-        # To simplify the code that follow (always use `n_obs, n_vars` shape)
-        x = x.T
-
-    if nan_policy == "omit":
-        x = mask_fn(x)
-
-    def _spearmanr_2cols(x):
-        # Mask the same observations for all variables, and then drop those
-        # observations (can't leave them masked, rankdata is weird).
-        x = ma.mask_rowcols(x, axis=0)
-        x = x[~x.mask.any(axis=1), :]
-
-        # If either column is entirely NaN or Inf
-        if not np.any(x.data):
-            return SpearmanrResult(np.nan, np.nan)
-
-        m = ma.getmask(x)
-        n_obs = x.shape[0]
-        dof = n_obs - 2 - int(m.sum(axis=0)[0])
-        if dof < 0:
-            return SpearmanrResult(np.nan, np.nan)
-
-        # Gets the ranks and rank differences
-        x_ranked = rankdata(x, axis=0)
-        rs = ma.corrcoef(x_ranked, rowvar=False).data
-
-        # rs can have elements equal to 1, so avoid zero division warnings
-        with np.errstate(divide="ignore"):
-            # clip the small negative values possibly caused by rounding
-            # errors before taking the square root
-            t = rs * np.sqrt((dof / ((rs + 1.0) * (1.0 - rs))).clip(0))
-
-        t, prob = scipy.stats._mstats_basic._ttest_finish(dof, t, alternative)
-
-        # For backwards compatibility, return scalars when comparing 2 columns
-        if rs.shape == (2, 2):
-            return SpearmanrResult(rs[1, 0], prob[1, 0])
-        else:
-            return SpearmanrResult(rs, prob)
-
-    # Need to do this per pair of variables, otherwise the dropped observations
-    # in a third column mess up the result for a pair.
-    n_vars = x.shape[1]
-    if n_vars == 2:
-        return _spearmanr_2cols(x)
-    else:
-        max_cpu_cores = cpu_count(logical=False)
-        with np.errstate(divide="ignore"):
-            results = Parallel(n_jobs=max_cpu_cores)(
-                delayed(_spearmanr_2cols)(x[:, [var1, var2]])
-                for var1 in range(n_vars - 1)
-                for var2 in range(var1 + 1, n_vars)
-            )
-
-        rs = np.ones((n_vars, n_vars), dtype=float)
-        prob = np.zeros((n_vars, n_vars), dtype=float)
-        for var1 in range(n_vars - 1):
-            for var2 in range(var1 + 1, n_vars):
-                result = results.pop(0)
-                rs[var1, var2] = result.correlation
-                rs[var2, var1] = result.correlation
-                prob[var1, var2] = result.pvalue
-                prob[var2, var1] = result.pvalue
-
-        return SpearmanrResult(rs, prob)

upgini-1.2.60/src/upgini/utils/sort.py

@@ -1,172 +0,0 @@
-import hashlib
-import logging
-from typing import Any, Dict, List, Optional, Union
-
-import numpy as np
-import pandas as pd
-from joblib import Parallel, delayed
-from pandas.api.types import is_datetime64_any_dtype, is_numeric_dtype
-from psutil import cpu_count
-from scipy.stats import skew, spearmanr
-
-from upgini.metadata import ModelTaskType, SearchKey
-from upgini.utils import mstats
-
-
-def sort_columns(
-    df: pd.DataFrame,
-    target_column: Union[str, pd.Series],
-    search_keys: Dict[str, SearchKey],
-    model_task_type: ModelTaskType,
-    exclude_columns: Optional[List[str]] = None,
-    sort_all_columns: bool = False,
-    logger: Optional[logging.Logger] = None,
-) -> List[str]:
-    if exclude_columns is None:
-        exclude_columns = []
-    if logger is None:
-        logger = logging.getLogger(__name__)
-        logger.setLevel(logging.FATAL)
-    df = df.copy()  # avoid side effects
-
-    # Check multiple search keys
-    search_key_values = list(search_keys.values())
-    has_duplicate_search_keys = len(search_key_values) != len(set(search_key_values))
-    if has_duplicate_search_keys:
-        logging.warning(f"WARNING: Found duplicate SearchKey values in search_keys: {search_keys}")
-
-    sorted_keys = sorted(search_keys.keys(), key=lambda x: str(search_keys.get(x)))
-    sorted_keys = [k for k in sorted_keys if k in df.columns and k not in exclude_columns]
-
-    other_columns = sorted(
-        [
-            c
-            for c in df.columns
-            if c not in sorted_keys and c not in exclude_columns and (df[c].nunique() > 1 or sort_all_columns)
-        ]
-    )
-    target = target_column if isinstance(target_column, pd.Series) else df[target_column]
-    target = prepare_target(target, model_task_type)
-    sort_dict = get_sort_columns_dict(
-        df[sorted_keys + other_columns], target, sorted_keys, omit_nan=True, sort_all_columns=sort_all_columns
-    )
-    other_columns = [c for c in other_columns if c in sort_dict]
-    columns_for_sort = sorted_keys + sorted(other_columns, key=lambda e: sort_dict[e], reverse=True)
-    return columns_for_sort
-
-
-def get_sort_columns_dict(
-    df: pd.DataFrame,
-    target: pd.Series,
-    sorted_keys: List[str],
-    omit_nan: bool,
-    n_jobs: Optional[int] = None,
-    sort_all_columns: bool = False,
-) -> Dict[str, Any]:
-    string_features = [c for c in df.select_dtypes(exclude=[np.number]).columns if c not in sorted_keys]
-    columns_for_sort = [c for c in df.columns if c not in sorted_keys + string_features]
-    if len(string_features) > 0:
-        if len(df) > len(df.drop(columns=string_features).drop_duplicates()) or sort_all_columns:
-            # factorize string features
-            for c in string_features:
-                df.loc[:, c] = pd.Series(df[c].factorize(sort=True)[0], index=df.index, dtype="int")
-            columns_for_sort.extend(string_features)
-
-    if len(columns_for_sort) == 0:
-        return {}
-
-    df = df[columns_for_sort]
-    hashes = [hash_series(df[col]) for col in columns_for_sort]
-    df = np.asarray(df, dtype=np.float32)
-    correlations = get_sort_columns_correlations(df, target, omit_nan, n_jobs)
-
-    sort_dict = {col: (corr, h) for col, corr, h in zip(columns_for_sort, correlations, hashes)}
-    return sort_dict
-
-
-def get_sort_columns_correlations(df: np.ndarray, target: pd.Series, omit_nan: bool, n_jobs: Optional[int] = None):
-    target_correlations = get_target_correlations(df, target, omit_nan, n_jobs, precision=7)
-
-    return np.max(target_correlations, axis=0)
-
-
-def get_target_correlations(
-    df: np.ndarray, target: pd.Series, omit_nan: bool, n_jobs: Optional[int] = None, precision: int = 15
-):
-    df = np.asarray(df, dtype=np.float32)
-    target_correlations = np.zeros((2, df.shape[1]))
-    target_correlations[0, :] = np.nan_to_num(
-        calculate_spearman_corr_with_target(df, target, omit_nan, n_jobs), copy=False
-    )
-    target_correlations[1, :] = np.nan_to_num(np.abs(np.corrcoef(df.T, target.T, rowvar=True)[-1, :-1]))
-
-    target_correlations = np.trunc(target_correlations * 10**precision) / (10**precision)
-
-    return target_correlations
-
-
-def calculate_spearman_corr_with_target(
-    X: Union[pd.DataFrame, np.ndarray], y: pd.Series, omit_nan: bool = False, n_jobs: Optional[int] = None
-) -> np.ndarray:
-    if isinstance(X, pd.DataFrame):
-        X = np.asarray(X, dtype=np.float32)
-
-    if X.size == 0:
-        return np.ndarray(shape=(0,))
-
-    all_correlations = np.zeros(X.shape[1])
-    all_correlations.fill(np.nan)
-    cols2calc = np.where([c.size > 0 and not (c == c[0]).all() for c in X.T])[0]
-
-    if omit_nan:
-        results = Parallel(n_jobs=n_jobs or cpu_count(logical=False))(
-            delayed(mstats.spearmanr)(
-                X[:, i],
-                y,
-                nan_policy="omit",
-                axis=0,
-            )
-            for i in cols2calc
-        )
-        target_correlations = np.array([abs(res.correlation) for res in results])
-    else:
-        cols2calc = cols2calc[np.where(~np.isnan(X[:, cols2calc]).any(axis=0))[0]]
-        target_correlations = calculate_spearman(X[:, cols2calc], y, nan_policy="raise")
-        if isinstance(target_correlations, float):
-            target_correlations = np.abs([target_correlations])
-        else:
-            target_correlations = np.abs(target_correlations)[-1, :-1]
-
-    all_correlations[cols2calc] = target_correlations
-
-    return all_correlations
-
-
-def calculate_spearman(X: np.ndarray, y: Optional[pd.Series], nan_policy: str):
-    features_num = X.shape[1]
-    if y is not None:
-        features_num += 1
-
-    if features_num < 2:
-        return 1.0
-    else:
-        return spearmanr(X, y, nan_policy=nan_policy).correlation
-
-
-def hash_series(series: pd.Series) -> int:
-    return int(hashlib.sha256(pd.util.hash_pandas_object(series, index=True).values).hexdigest(), 16)
-
-
-def prepare_target(target: pd.Series, model_task_type: ModelTaskType) -> pd.Series:
-    target_name = target.name
-    if model_task_type != ModelTaskType.REGRESSION or (
-        not is_numeric_dtype(target) and not is_datetime64_any_dtype(target)
-    ):
-        target = target.astype(str).astype("category").cat.codes
-
-    elif model_task_type == ModelTaskType.REGRESSION:
-        skewness = round(abs(skew(target)), 2)
-        if (target.min() >= 0) and (skewness >= 0.9):
-            target = np.log1p(target)
-
-    return pd.Series(target, name=target_name)