upgini 1.2.14a4__py3-none-any.whl → 1.2.14a3616.dev2__py3-none-any.whl

upgini/__about__.py

@@ -1 +1 @@
-__version__ = "1.2.14a4"
+__version__ = "1.2.14a3616.dev2"

upgini/dataset.py

@@ -53,8 +53,7 @@ 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
-    BINARY_MIN_SAMPLE_THRESHOLD = 5_000
-    MULTICLASS_MIN_SAMPLE_THRESHOLD = 25_000
+    MIN_SAMPLE_THRESHOLD = 5_000
     IMBALANCE_THESHOLD = 0.6
     BINARY_BOOTSTRAP_LOOPS = 5
     MULTICLASS_BOOTSTRAP_LOOPS = 2
@@ -226,7 +225,7 @@ class Dataset:  # (pd.DataFrame):
             train_segment = self.data
 
         if self.task_type == ModelTaskType.MULTICLASS or (
-            self.task_type == ModelTaskType.BINARY and len(train_segment) > self.BINARY_MIN_SAMPLE_THRESHOLD
+            self.task_type == ModelTaskType.BINARY and len(train_segment) > self.MIN_SAMPLE_THRESHOLD
         ):
             count = len(train_segment)
             target_column = self.etalon_def_checked.get(FileColumnMeaningType.TARGET.value, TARGET)
@@ -254,7 +253,6 @@ class Dataset:  # (pd.DataFrame):
             min_class_percent = self.IMBALANCE_THESHOLD / target_classes_count
             min_class_threshold = min_class_percent * count
 
-            # If min class count less than 30% for binary or (60 / classes_count)% for multiclass
             if min_class_count < min_class_threshold:
                 self.imbalanced = True
                 self.data = balance_undersample(
@@ -262,8 +260,7 @@ class Dataset:  # (pd.DataFrame):
                     target_column=target_column,
                     task_type=self.task_type,
                     random_state=self.random_state,
-                    binary_min_sample_threshold=self.BINARY_MIN_SAMPLE_THRESHOLD,
-                    multiclass_min_sample_threshold=self.MULTICLASS_MIN_SAMPLE_THRESHOLD,
+                    imbalance_threshold=self.IMBALANCE_THESHOLD,
                     binary_bootstrap_loops=self.BINARY_BOOTSTRAP_LOOPS,
                     multiclass_bootstrap_loops=self.MULTICLASS_BOOTSTRAP_LOOPS,
                     logger=self.logger,

upgini/features_enricher.py

@@ -2721,13 +2721,12 @@ class FeaturesEnricher(TransformerMixin):
         ):
             msg = self.bundle.get("multivariate_timeseries_detected")
             self.__override_cv(CVType.blocked_time_series, msg, print_warning=False)
-        elif (
-            self.cv is None
-            and model_task_type != ModelTaskType.REGRESSION
-            and self._get_group_columns(df, self.fit_search_keys)
-        ):
+        elif self.cv is None and model_task_type != ModelTaskType.REGRESSION:
             msg = self.bundle.get("group_k_fold_in_classification")
             self.__override_cv(CVType.group_k_fold, msg, print_warning=self.cv is not None)
+            group_columns = self._get_group_columns(df, self.fit_search_keys)
+            self.runtime_parameters.properties["cv_params.group_columns"] = ",".join(group_columns)
+            self.runtime_parameters.properties["cv_params.shuffle_kfold"] = "True"
 
     def __override_cv(self, cv: CVType, msg: str, print_warning: bool = True):
         if print_warning:

upgini/resource_bundle/strings.properties

@@ -203,12 +203,11 @@ email_detected=Emails detected in column `{}`. It will be used as a search key\n
 email_detected_not_registered=Emails detected in column `{}`. It can be used only with api_key from profile.upgini.com\nSee docs to turn off the automatic detection: https://github.com/upgini/upgini/blob/main/README.md#turn-off-autodetection-for-search-key-columns
 phone_detected=Phone numbers detected in column `{}`. It can be used only with api_key from profile.upgini.com\nSee docs to turn off the automatic detection: https://github.com/upgini/upgini/blob/main/README.md#turn-off-autodetection-for-search-key-columns
 phone_detected_not_registered=\nWARNING: Phone numbers detected in column `{}`. It can be used only with api_key from profile.upgini.com\nSee docs to turn off the automatic detection: https://github.com/upgini/upgini/blob/main/README.md#turn-off-autodetection-for-search-key-columns
-target_type_detected=\nDetected task type: {}. Reason: {}\nYou can set task type manually with argument `model_task_type` of FeaturesEnricher constructor if task type detected incorrectly\n
+target_type_detected=\nDetected task type: {}\n
 # all_ok_community_invite=Chat with us in Slack community:
 all_ok_community_invite=❓ Support request 
 too_small_for_metrics=Your train dataset or one of eval datasets contains less than 500 rows. For such dataset Upgini will not calculate accuracy metrics. Please increase the number of rows in the training dataset to calculate accuracy metrics
 imbalance_multiclass=Class {0} is on 25% quantile of classes distribution ({1} records in train dataset). \nDownsample classes with records more than {1}.
-imbalanced_target=\nWARNING: Target 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
 

upgini/utils/target_utils.py

@@ -24,87 +24,49 @@ def define_task(
 ) -> ModelTaskType:
     if logger is None:
         logger = logging.getLogger()
-
-    # Replace inf and -inf with NaN to handle extreme values correctly
-    y = y.replace([np.inf, -np.inf], np.nan, inplace=False)
-
-    # Drop NaN values from the target
     target = y.dropna()
-
-    # Check if target is numeric and finite
     if is_numeric_dtype(target):
         target = target.loc[np.isfinite(target)]
     else:
-        # If not numeric, drop empty strings as well
         target = target.loc[target != ""]
-
-    # Raise error if there are no valid values left in the target
     if len(target) == 0:
         raise ValidationError(bundle.get("empty_target"))
-
-    # Count unique values in the target
     target_items = target.nunique()
-
-    # Raise error if all target values are the same
     if target_items == 1:
         raise ValidationError(bundle.get("dataset_constant_target"))
-
-    reason = ""  # Will store the reason for selecting the task type
-
-    # Binary classification case: exactly two unique values
     if target_items == 2:
         task = ModelTaskType.BINARY
-        reason = "only two unique label-values observed"
     else:
-        # Attempt to convert target to numeric
         try:
             target = pd.to_numeric(target)
             is_numeric = True
         except Exception:
             is_numeric = False
 
-        # If target cannot be converted to numeric, assume multiclass classification
+        # If any value is non numeric - multiclass
         if not is_numeric:
             task = ModelTaskType.MULTICLASS
-            reason = "non-numeric label values observed"
         else:
-            # Calculate the ratio of unique values to total number of values
-            unique_ratio = target.nunique() / float(len(target))
-
-            # Multiclass classification: few unique values and integer encoding
             if target.nunique() <= 50 and is_int_encoding(target.unique()):
                 task = ModelTaskType.MULTICLASS
-                reason = "few unique label-values observed and can be considered as categorical"
-            # Regression case: if there are date features, assume regression
             elif has_date:
                 task = ModelTaskType.REGRESSION
-                reason = "date features are present, treating as regression"
             else:
-                # Remove zero values and recalculate unique ratio
                 non_zero_target = target[target != 0]
                 target_items = non_zero_target.nunique()
                 target_ratio = target_items / len(non_zero_target)
-
-                # Use unique_ratio to determine whether to classify as regression or multiclass
                 if (
-                    unique_ratio > 0.1  # Use threshold to differentiate between regression and classification
-                    or (target.dtype.kind == "f" and np.any(target != target.astype(int)))  # Non-integer float values
+                    (target.dtype.kind == "f" and np.any(target != target.astype(int)))  # any non integer
                     or target_items > 50
-                    or target_ratio > 0.2  # If non-zero values have high ratio of uniqueness
+                    or target_ratio > 0.2
                 ):
                     task = ModelTaskType.REGRESSION
-                    reason = "many unique label-values or non-integer floating point values observed"
                 else:
                     task = ModelTaskType.MULTICLASS
-                    reason = "integer-like values with limited unique values observed"
-
-    # Log or print the reason for the selected task type
-    logger.info(f"Detected task type: {task} (Reason: {reason})")
 
-    # Print task type and reason if silent mode is off
+    logger.info(f"Detected task type: {task}")
     if not silent:
-        print(bundle.get("target_type_detected").format(task, reason))
-
+        print(bundle.get("target_type_detected").format(task))
     return task
 
 
@@ -119,8 +81,8 @@ def balance_undersample(
     target_column: str,
     task_type: ModelTaskType,
     random_state: int,
-    binary_min_sample_threshold: int = 5000,
-    multiclass_min_sample_threshold: int = 25000,
+    imbalance_threshold: int = 0.2,
+    min_sample_threshold: int = 5000,
     binary_bootstrap_loops: int = 5,
     multiclass_bootstrap_loops: int = 2,
     logger: Optional[logging.Logger] = None,
@@ -134,60 +96,52 @@ def balance_undersample(
     if SYSTEM_RECORD_ID not in df.columns:
         raise Exception("System record id must be presented for undersampling")
 
-    # count = len(df)
+    count = len(df)
     target = df[target_column].copy()
-    # target_classes_count = target.nunique()
+    target_classes_count = target.nunique()
 
     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]
-    num_classes = len(vc)
 
-    # min_class_percent = imbalance_threshold / target_classes_count
-    # min_class_threshold = int(min_class_percent * count)
+    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:
-        if len(df) > multiclass_min_sample_threshold and max_class_count > (
-            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)
+        # Sort classes by rows count and find 25% quantile class
+        classes = vc.index
+        quantile25_idx = int(0.75 * len(classes)) - 1
+        quantile25_class = classes[quantile25_idx]
+        quantile25_class_cnt = vc[quantile25_class]
+
+        if max_class_count > (quantile25_class_cnt * multiclass_bootstrap_loops):
+            msg = bundle.get("imbalance_multiclass").format(quantile25_class, quantile25_class_cnt)
             logger.warning(msg)
             print(msg)
             if warning_counter:
                 warning_counter.increment()
 
+            # 25% and lower classes will stay as is. Higher classes will be downsampled
             sample_strategy = dict()
-            for class_value in vc.index:
-                if class_value == min_class_value:
-                    continue
+            for class_idx in range(quantile25_idx):
+                # compare class count with count_of_quantile25_class * 2
+                class_value = classes[class_idx]
                 class_count = vc[class_value]
-                sample_size = min(
-                    class_count,
-                    multiclass_bootstrap_loops
-                    * (
-                        min_class_count
-                        + max((multiclass_min_sample_threshold - num_classes * min_class_count) / (num_classes - 1), 0)
-                    ),
-                )
-                sample_strategy[class_value] = int(sample_size)
-            logger.info(f"Rebalance sample strategy: {sample_strategy}. Min class count: {min_class_count}")
+                sample_strategy[class_value] = min(class_count, quantile25_class_cnt * multiclass_bootstrap_loops)
             sampler = RandomUnderSampler(sampling_strategy=sample_strategy, 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])]
-    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)
+    elif len(df) > min_sample_threshold and min_class_count < min_sample_threshold / 2:
+        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:
@@ -196,38 +150,30 @@ def balance_undersample(
         # 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)),
-        )
-        logger.info(
-            f"Min class count: {min_class_count}. Max class count: {max_class_count}."
-            f" Rebalance sample size: {sample_size}"
-        )
+        sample_size = min(len(majority_class), min_sample_threshold - min_class_count)
         sampled_majority_class = majority_class.sample(n=sample_size, random_state=random_state)
         resampled_data = df[
             (df[SYSTEM_RECORD_ID].isin(minority_class[SYSTEM_RECORD_ID]))
             | (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()
-
-    #     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])]
+    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()
+
+        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])]
 
     logger.info(f"Shape after rebalance resampling: {resampled_data}")
     return resampled_data

{upgini-1.2.14a4.dist-info → upgini-1.2.14a3616.dev2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.14a4
+Version: 1.2.14a3616.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/

{upgini-1.2.14a4.dist-info → upgini-1.2.14a3616.dev2.dist-info}/RECORD

@@ -1,9 +1,9 @@
-upgini/__about__.py,sha256=tfhdEEoOzTUSKNF9hQy8PZO57ri0xEeduAwFCwtVLCg,25
+upgini/__about__.py,sha256=11a3ZzwaEFhVx7oIELanEC_YCKKOT0lyRpXdoTeUml4,33
 upgini/__init__.py,sha256=M64LwQTBa-5Jz24Zm2h8rWwlKQQ1J8nP7gGgIciS0WU,589
 upgini/ads.py,sha256=nvuRxRx5MHDMgPr9SiU-fsqRdFaBv8p4_v1oqiysKpc,2714
-upgini/dataset.py,sha256=iPFiMJtk4HF1ytw9wCQr8H9RfoOKj_TIo8XYZKWgcMc,31331
+upgini/dataset.py,sha256=olZ-OHSfBNoBSCo7R5t7uCLukI2nO7afpx_A-HCiJLk,31067
 upgini/errors.py,sha256=2b_Wbo0OYhLUbrZqdLIx5jBnAsiD1Mcenh-VjR4HCTw,950
-upgini/features_enricher.py,sha256=HJJZbZScVrl6ugDBQE71m7om5-ahvMyEnAqZNw-OEJ0,188058
+upgini/features_enricher.py,sha256=7hibmMuykV1FwXm9yOPBrRy3c730Q_EtHwhgb-ajQlc,188217
 upgini/http.py,sha256=21asexflvavydzCOONJDGQBtQanCElrbnqLXakJ9Cu8,42880
 upgini/lazy_import.py,sha256=74gQ8JuA48BGRLxAo7lNHNKY2D2emMxrUxKGdxVGhuY,1012
 upgini/metadata.py,sha256=osmzdNESeh7yP3BZday6N9Q3eaIHfzhhRM1d6NSgcf0,11223
@@ -30,7 +30,7 @@ upgini/normalizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 upgini/normalizer/normalize_utils.py,sha256=bHRPWCNrUvt2R9qMX6dZFCJ0i8ENVCQ2Rw3dHH9IJEg,7447
 upgini/resource_bundle/__init__.py,sha256=S5F2G47pnJd2LDpmFsjDqEwiKkP8Hm-hcseDbMka6Ko,8345
 upgini/resource_bundle/exceptions.py,sha256=5fRvx0_vWdE1-7HcSgF0tckB4A9AKyf5RiinZkInTsI,621
-upgini/resource_bundle/strings.properties,sha256=uo9CIQMg8VFeHlL_mY2dwOumQnr0TenJNPNOfXPWlPI,26715
+upgini/resource_bundle/strings.properties,sha256=9kvmcUrsSFUCrzOiN0Ozf-lQ2H8Igz5gATUPoHMOaU4,26456
 upgini/resource_bundle/strings_widget.properties,sha256=gOdqvZWntP2LCza_tyVk1_yRYcG4c04K9sQOAVhF_gw,1577
 upgini/sampler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 upgini/sampler/base.py,sha256=7GpjYqjOp58vYcJLiX__1R5wjUlyQbxvHJ2klFnup_M,6389
@@ -54,10 +54,10 @@ upgini/utils/phone_utils.py,sha256=IrbztLuOJBiePqqxllfABWfYlfAjYevPhXKipl95wUI,1
 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=13jQS_k7v0aUtudXV6nGUEWjttPQzAW9AFYL5wgEz9k,44511
-upgini/utils/target_utils.py,sha256=3itoOxwEycnIdWeTL3KjuS_NdJleL6nMRqblQLmy6Kk,10413
+upgini/utils/target_utils.py,sha256=BVtDmrmFMKerSUWaNOIEdzsYHIFiODdpnWbE50QDPDc,7864
 upgini/utils/track_info.py,sha256=G5Lu1xxakg2_TQjKZk4b5SvrHsATTXNVV3NbvWtT8k8,5663
 upgini/utils/warning_counter.py,sha256=dIWBB4dI5XRRJZudvIlqlIYKEiwLLPcXarsZuYRt338,227
-upgini-1.2.14a4.dist-info/METADATA,sha256=iwhYx9Mru7TEEylcJbeOaZlnKVBcpMrnYXzNEU2M4fg,48579
-upgini-1.2.14a4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-upgini-1.2.14a4.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
-upgini-1.2.14a4.dist-info/RECORD,,
+upgini-1.2.14a3616.dev2.dist-info/METADATA,sha256=C5wROJCdIAYVObZ_bslXFYwQyVRUppBI_WI7NGtVM20,48587
+upgini-1.2.14a3616.dev2.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+upgini-1.2.14a3616.dev2.dist-info/licenses/LICENSE,sha256=5RRzgvdJUu3BUDfv4bzVU6FqKgwHlIay63pPCSmSgzw,1514
+upgini-1.2.14a3616.dev2.dist-info/RECORD,,

{upgini-1.2.14a4.dist-info → upgini-1.2.14a3616.dev2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.24.2
 Root-Is-Purelib: true
 Tag: py3-none-any