upgini 1.2.31a2__tar.gz → 1.2.32__tar.gz

{upgini-1.2.31a2 → upgini-1.2.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.31a2
+Version: 1.2.32
 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.32/src/upgini/__about__.py

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

{upgini-1.2.31a2 → upgini-1.2.32}/src/upgini/dataset.py

@@ -36,15 +36,13 @@ from upgini.metadata import (
 from upgini.resource_bundle import ResourceBundle, get_custom_bundle
 from upgini.search_task import SearchTask
 from upgini.utils.email_utils import EmailSearchKeyConverter
-from upgini.utils.target_utils import balance_undersample
+from upgini.utils.target_utils import balance_undersample, balance_undersample_forced
 
 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.warning_counter import WarningCounter
-
 
 class Dataset:  # (pd.DataFrame):
     MIN_ROWS_COUNT = 100
@@ -64,6 +62,7 @@ class Dataset:  # (pd.DataFrame):
     MAX_FEATURES_COUNT = 3500
     MAX_UPLOADING_FILE_SIZE = 268435456  # 256 Mb
     MAX_STRING_FEATURE_LENGTH = 24573
+    FORCE_SAMPLE_SIZE = 7_000
 
     def __init__(
         self,
@@ -78,8 +77,8 @@ class Dataset:  # (pd.DataFrame):
         random_state: Optional[int] = None,
         rest_client: Optional[_RestClient] = None,
         logger: Optional[logging.Logger] = None,
-        warning_counter: Optional[WarningCounter] = None,
         bundle: Optional[ResourceBundle] = None,
+        warning_callback: Optional[Callable] = None,
         **kwargs,
     ):
         self.bundle = bundle or get_custom_bundle()
@@ -122,7 +121,7 @@ class Dataset:  # (pd.DataFrame):
         else:
             self.logger = logging.getLogger()
             self.logger.setLevel("FATAL")
-        self.warning_counter = warning_counter or WarningCounter()
+        self.warning_callback = warning_callback
 
     def __len__(self):
         return len(self.data) if self.data is not None else None
@@ -217,9 +216,23 @@ class Dataset:  # (pd.DataFrame):
                     self.logger.exception("Failed to cast target to float for timeseries task type")
                     raise ValidationError(self.bundle.get("dataset_invalid_timeseries_target").format(target.dtype))
 
-    def __resample(self):
+    def __resample(self, force_downsampling=False):
         # self.logger.info("Resampling etalon")
         # Resample imbalanced target. Only train segment (without eval_set)
+        if force_downsampling:
+            target_column = self.etalon_def_checked.get(FileColumnMeaningType.TARGET.value, TARGET)
+            self.data = balance_undersample_forced(
+                df=self.data,
+                target_column=target_column,
+                task_type=self.task_type,
+                random_state=self.random_state,
+                sample_size=self.FORCE_SAMPLE_SIZE,
+                logger=self.logger,
+                bundle=self.bundle,
+                warning_callback=self.warning_callback,
+            )
+            return
+
         if EVAL_SET_INDEX in self.data.columns:
             train_segment = self.data[self.data[EVAL_SET_INDEX] == 0]
         else:
@@ -268,7 +281,7 @@ class Dataset:  # (pd.DataFrame):
                     multiclass_bootstrap_loops=self.MULTICLASS_BOOTSTRAP_LOOPS,
                     logger=self.logger,
                     bundle=self.bundle,
-                    warning_counter=self.warning_counter,
+                    warning_callback=self.warning_callback,
                 )
 
         # Resample over fit threshold
@@ -418,13 +431,13 @@ class Dataset:  # (pd.DataFrame):
         if len(self.data) == 0:
             raise ValidationError(self.bundle.get("all_search_keys_invalid"))
 
-    def validate(self, validate_target: bool = True, silent_mode: bool = False):
+    def validate(self, validate_target: bool = True, silent_mode: bool = False, force_downsampling: bool = False):
         self.__validate_dataset(validate_target, silent_mode)
 
         if validate_target:
             self.__validate_target()
 
-            self.__resample()
+            self.__resample(force_downsampling)
 
             self.__validate_min_rows_count()
 
@@ -573,9 +586,10 @@ class Dataset:  # (pd.DataFrame):
         max_features: Optional[int] = None,  # deprecated
         filter_features: Optional[dict] = None,  # deprecated
         runtime_parameters: Optional[RuntimeParameters] = None,
+        force_downsampling: bool = False,
     ) -> SearchTask:
         if self.etalon_def is None:
-            self.validate()
+            self.validate(force_downsampling=force_downsampling)
         file_metrics = FileMetrics()
 
         runtime_parameters = self._rename_generate_features(runtime_parameters)

{upgini-1.2.31a2 → upgini-1.2.32}/src/upgini/features_enricher.py

@@ -231,6 +231,7 @@ class FeaturesEnricher(TransformerMixin):
         custom_bundle_config: Optional[str] = None,
         add_date_if_missing: bool = True,
         select_features: bool = False,
+        disable_force_downsampling: bool = False,
         **kwargs,
     ):
         self.bundle = get_custom_bundle(custom_bundle_config)
@@ -288,6 +289,7 @@ class FeaturesEnricher(TransformerMixin):
         self.feature_importances_ = []
         self.search_id = search_id
         self.select_features = select_features
+        self.disable_force_downsampling = disable_force_downsampling
 
         if search_id:
             search_task = SearchTask(search_id, rest_client=self.rest_client, logger=self.logger)
@@ -2251,6 +2253,8 @@ class FeaturesEnricher(TransformerMixin):
                 date_format=self.date_format,
                 rest_client=self.rest_client,
                 logger=self.logger,
+                bundle=self.bundle,
+                warning_callback=self.__log_warning,
             )
             dataset.columns_renaming = columns_renaming
 
@@ -2696,6 +2700,18 @@ class FeaturesEnricher(TransformerMixin):
 
         combined_search_keys = combine_search_keys(self.fit_search_keys.keys())
 
+        runtime_parameters = self._get_copy_of_runtime_parameters()
+
+        # Force downsampling to 7000 for API features generation
+        force_downsampling = (
+            not self.disable_force_downsampling
+            and self.generate_features is not None
+            and phone_column is not None
+            and self.fit_columns_renaming[phone_column] in self.generate_features
+        )
+        if force_downsampling and len(df) > Dataset.FORCE_SAMPLE_SIZE:
+            runtime_parameters.properties["fast_fit"] = True
+
         dataset = Dataset(
             "tds_" + str(uuid.uuid4()),
             df=df,
@@ -2707,6 +2723,8 @@ class FeaturesEnricher(TransformerMixin):
             random_state=self.random_state,
             rest_client=self.rest_client,
             logger=self.logger,
+            bundle=self.bundle,
+            warning_callback=self.__log_warning,
         )
         dataset.columns_renaming = self.fit_columns_renaming
 
@@ -2720,8 +2738,9 @@ class FeaturesEnricher(TransformerMixin):
             start_time=start_time,
             progress_callback=progress_callback,
             extract_features=True,
-            runtime_parameters=self._get_copy_of_runtime_parameters(),
+            runtime_parameters=runtime_parameters,
             exclude_features_sources=exclude_features_sources,
+            force_downsampling=force_downsampling,
         )
 
         if search_id_callback is not None:
@@ -3521,7 +3540,7 @@ class FeaturesEnricher(TransformerMixin):
         return result_train, result_eval_sets
 
     def __prepare_feature_importances(
-            self, trace_id: str, x_columns: List[str], updated_shaps: Optional[Dict[str, float]] = None, silent=False
+        self, trace_id: str, x_columns: List[str], updated_shaps: Optional[Dict[str, float]] = None, silent=False
     ):
         if self._search_task is None:
             raise NotFittedError(self.bundle.get("transform_unfitted_enricher"))

{upgini-1.2.31a2 → upgini-1.2.32}/src/upgini/resource_bundle/strings.properties

@@ -215,6 +215,7 @@ imbalance_multiclass=Class {0} is on 25% quantile of classes distribution ({1} r
 imbalanced_target=\nTarget is imbalanced and will be undersampled. Frequency of the rarest class `{}` is {}
 loss_selection_info=Using loss `{}` for feature selection
 loss_calc_metrics_info=Using loss `{}` for metrics calculation with default estimator
+forced_balance_undersample=For quick data retrieval, your dataset has been sampled. To use data search without data sampling please contact support (sales@upgini.com)
 
 # Validation table
 validation_column_name_header=Column name

{upgini-1.2.31a2 → upgini-1.2.32}/src/upgini/utils/target_utils.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional, Union
+from typing import Callable, Optional, Union
 
 import numpy as np
 import pandas as pd
@@ -9,7 +9,6 @@ from upgini.errors import ValidationError
 from upgini.metadata import SYSTEM_RECORD_ID, ModelTaskType
 from upgini.resource_bundle import ResourceBundle, bundle, get_custom_bundle
 from upgini.sampler.random_under_sampler import RandomUnderSampler
-from upgini.utils.warning_counter import WarningCounter
 
 
 def correct_string_target(y: Union[pd.Series, np.ndarray]) -> Union[pd.Series, np.ndarray]:
@@ -121,7 +120,7 @@ def balance_undersample(
     multiclass_bootstrap_loops: int = 2,
     logger: Optional[logging.Logger] = None,
     bundle: Optional[ResourceBundle] = None,
-    warning_counter: Optional[WarningCounter] = None,
+    warning_callback: Optional[Callable] = None,
 ) -> pd.DataFrame:
     if logger is None:
         logger = logging.getLogger("muted_logger")
@@ -130,9 +129,7 @@ def balance_undersample(
     if SYSTEM_RECORD_ID not in df.columns:
         raise Exception("System record id must be presented for undersampling")
 
-    # count = len(df)
     target = df[target_column].copy()
-    # target_classes_count = target.nunique()
 
     vc = target.value_counts()
     max_class_value = vc.index[0]
@@ -141,9 +138,6 @@ def balance_undersample(
     min_class_count = vc[min_class_value]
     num_classes = len(vc)
 
-    # min_class_percent = imbalance_threshold / target_classes_count
-    # min_class_threshold = int(min_class_percent * count)
-
     resampled_data = df
     df = df.copy().sort_values(by=SYSTEM_RECORD_ID)
     if task_type == ModelTaskType.MULTICLASS:
@@ -151,12 +145,10 @@ def balance_undersample(
             min_class_count * multiclass_bootstrap_loops
         ):
 
-            # msg = bundle.get("imbalance_multiclass").format(min_class_value, min_class_count)
             msg = bundle.get("imbalanced_target").format(min_class_value, min_class_count)
             logger.warning(msg)
-            print(msg)
-            if warning_counter:
-                warning_counter.increment()
+            if warning_callback is not None:
+                warning_callback(msg)
 
             sample_strategy = dict()
             for class_value in vc.index:
@@ -180,19 +172,14 @@ def balance_undersample(
 
             resampled_data = df[df[SYSTEM_RECORD_ID].isin(new_x[SYSTEM_RECORD_ID])]
     elif len(df) > binary_min_sample_threshold:
-        # msg = bundle.get("dataset_rarest_class_less_threshold").format(
-        #     min_class_value, min_class_count, min_class_threshold, min_class_percent * 100
-        # )
         msg = bundle.get("imbalanced_target").format(min_class_value, min_class_count)
         logger.warning(msg)
-        print(msg)
-        if warning_counter:
-            warning_counter.increment()
+        if warning_callback is not None:
+            warning_callback(msg)
 
         # fill up to min_sample_threshold by majority class
         minority_class = df[df[target_column] == min_class_value]
         majority_class = df[df[target_column] != min_class_value]
-        # sample_size = min(len(majority_class), min_sample_threshold - min_class_count)
         sample_size = min(
             max_class_count,
             binary_bootstrap_loops * (min_class_count + max(binary_min_sample_threshold - 2 * min_class_count, 0)),
@@ -207,25 +194,73 @@ def balance_undersample(
             | (df[SYSTEM_RECORD_ID].isin(sampled_majority_class[SYSTEM_RECORD_ID]))
         ]
 
-    # elif max_class_count > min_class_count * binary_bootstrap_loops:
-    #     msg = bundle.get("dataset_rarest_class_less_threshold").format(
-    #         min_class_value, min_class_count, min_class_threshold, min_class_percent * 100
-    #     )
-    #     logger.warning(msg)
-    #     print(msg)
-    #     if warning_counter:
-    #         warning_counter.increment()
+    logger.info(f"Shape after rebalance resampling: {resampled_data}")
+    return resampled_data
 
-    #     sampler = RandomUnderSampler(
-    #         sampling_strategy={max_class_value: binary_bootstrap_loops * min_class_count}, random_state=random_state
-    #     )
-    #     X = df[SYSTEM_RECORD_ID]
-    #     X = X.to_frame(SYSTEM_RECORD_ID)
-    #     new_x, _ = sampler.fit_resample(X, target)  # type: ignore
 
-    #     resampled_data = df[df[SYSTEM_RECORD_ID].isin(new_x[SYSTEM_RECORD_ID])]
+def balance_undersample_forced(
+    df: pd.DataFrame,
+    target_column: str,
+    task_type: ModelTaskType,
+    random_state: int,
+    sample_size: int = 7000,
+    logger: Optional[logging.Logger] = None,
+    bundle: Optional[ResourceBundle] = None,
+    warning_callback: Optional[Callable] = None,
+):
+    if len(df) <= sample_size:
+        return df
 
-    logger.info(f"Shape after rebalance resampling: {resampled_data}")
+    if logger is None:
+        logger = logging.getLogger("muted_logger")
+        logger.setLevel("FATAL")
+    bundle = bundle or get_custom_bundle()
+    if SYSTEM_RECORD_ID not in df.columns:
+        raise Exception("System record id must be presented for undersampling")
+
+    msg = bundle.get("forced_balance_undersample")
+    logger.info(msg)
+    if warning_callback is not None:
+        warning_callback(msg)
+
+    target = df[target_column].copy()
+
+    vc = target.value_counts()
+    max_class_value = vc.index[0]
+    min_class_value = vc.index[len(vc) - 1]
+    max_class_count = vc[max_class_value]
+    min_class_count = vc[min_class_value]
+
+    resampled_data = df
+    df = df.copy().sort_values(by=SYSTEM_RECORD_ID)
+    if task_type in [ModelTaskType.MULTICLASS, ModelTaskType.REGRESSION, ModelTaskType.TIMESERIES]:
+        logger.warning(f"Sampling dataset from {len(df)} to {sample_size}")
+        resampled_data = df.sample(n=sample_size, random_state=random_state)
+    else:
+        msg = bundle.get("imbalanced_target").format(min_class_value, min_class_count)
+        logger.warning(msg)
+
+        # fill up to min_sample_threshold by majority class
+        minority_class = df[df[target_column] == min_class_value]
+        majority_class = df[df[target_column] != min_class_value]
+        logger.info(
+            f"Min class count: {min_class_count}. Max class count: {max_class_count}."
+            f" Rebalance sample size: {sample_size}"
+        )
+        if len(minority_class) > (sample_size / 2):
+            sampled_minority_class = minority_class.sample(n=int(sample_size / 2), random_state=random_state)
+        else:
+            sampled_minority_class = minority_class
+
+        if len(majority_class) > (sample_size) / 2:
+            sampled_majority_class = majority_class.sample(n=int(sample_size / 2), random_state=random_state)
+
+        resampled_data = df[
+            (df[SYSTEM_RECORD_ID].isin(sampled_minority_class[SYSTEM_RECORD_ID]))
+            | (df[SYSTEM_RECORD_ID].isin(sampled_majority_class[SYSTEM_RECORD_ID]))
+        ]
+
+    logger.info(f"Shape after forced rebalance resampling: {resampled_data}")
     return resampled_data
 
 

upgini-1.2.31a2/src/upgini/__about__.py

@@ -1 +0,0 @@
-__version__ = "1.2.31a2"