upgini 1.2.29a2__tar.gz → 1.2.29a4__tar.gz

{upgini-1.2.29a2 → upgini-1.2.29a4}/PKG-INFO

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

@@ -0,0 +1 @@
+__version__ = "1.2.29a4"

{upgini-1.2.29a2 → upgini-1.2.29a4}/src/upgini/features_enricher.py

@@ -999,9 +999,10 @@ class FeaturesEnricher(TransformerMixin):
                             text_features=self.generate_features,
                             has_date=has_date,
                         )
-                        etalon_metric, _ = baseline_estimator.cross_val_predict(
+                        etalon_cv_result = baseline_estimator.cross_val_predict(
                             fitting_X, y_sorted, self.baseline_score_column
                         )
+                        etalon_metric = etalon_cv_result.get_display_metric()
                         if etalon_metric is None:
                             self.logger.info(
                                 f"Baseline {metric} on train client features is None (maybe all features was removed)"
@@ -1033,9 +1034,9 @@ class FeaturesEnricher(TransformerMixin):
                             text_features=self.generate_features,
                             has_date=has_date,
                         )
-                        enriched_metric, enriched_shaps = enriched_estimator.cross_val_predict(
-                            fitting_enriched_X, enriched_y_sorted
-                        )
+                        enriched_cv_result = enriched_estimator.cross_val_predict(fitting_enriched_X, enriched_y_sorted)
+                        enriched_metric = enriched_cv_result.get_display_metric()
+                        enriched_shaps = enriched_cv_result.shap_values
 
                         if enriched_shaps is not None:
                             self._update_shap_values(enriched_shaps)
@@ -1048,7 +1049,7 @@ class FeaturesEnricher(TransformerMixin):
                         else:
                             self.logger.info(f"Enriched {metric} on train combined features: {enriched_metric}")
                         if etalon_metric is not None and enriched_metric is not None:
-                            uplift = (enriched_metric - etalon_metric) * multiplier
+                            uplift = (enriched_cv_result.metric - etalon_cv_result.metric) * multiplier
 
                     train_metrics = {
                         self.bundle.get("quality_metrics_segment_header"): self.bundle.get(
@@ -1091,9 +1092,10 @@ class FeaturesEnricher(TransformerMixin):
                                     f"Calculate baseline {metric} on eval set {idx + 1} "
                                     f"on client features: {eval_X_sorted.columns.to_list()}"
                                 )
-                                etalon_eval_metric = baseline_estimator.calculate_metric(
+                                etalon_eval_results = baseline_estimator.calculate_metric(
                                     eval_X_sorted, eval_y_sorted, self.baseline_score_column
                                 )
+                                etalon_eval_metric = etalon_eval_results.get_display_metric()
                                 self.logger.info(
                                     f"Baseline {metric} on eval set {idx + 1} client features: {etalon_eval_metric}"
                                 )
@@ -1105,9 +1107,10 @@ class FeaturesEnricher(TransformerMixin):
                                     f"Calculate enriched {metric} on eval set {idx + 1} "
                                     f"on combined features: {enriched_eval_X_sorted.columns.to_list()}"
                                 )
-                                enriched_eval_metric = enriched_estimator.calculate_metric(
+                                enriched_eval_results = enriched_estimator.calculate_metric(
                                     enriched_eval_X_sorted, enriched_eval_y_sorted
                                 )
+                                enriched_eval_metric = enriched_eval_results.get_display_metric()
                                 self.logger.info(
                                     f"Enriched {metric} on eval set {idx + 1} combined features: {enriched_eval_metric}"
                                 )
@@ -1115,7 +1118,7 @@ class FeaturesEnricher(TransformerMixin):
                                 enriched_eval_metric = None
 
                             if etalon_eval_metric is not None and enriched_eval_metric is not None:
-                                eval_uplift = (enriched_eval_metric - etalon_eval_metric) * multiplier
+                                eval_uplift = (enriched_eval_results.metric - etalon_eval_results.metric) * multiplier
                             else:
                                 eval_uplift = None
 

{upgini-1.2.29a2 → upgini-1.2.29a4}/src/upgini/metrics.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from dataclasses import dataclass
 import inspect
 import logging
 import re
@@ -210,6 +211,21 @@ SUPPORTED_CATBOOST_METRICS = {
 }
 
 
+@dataclass
+class _CrossValResults:
+    metric: Optional[float]
+    metric_std: Optional[float]
+    shap_values: Optional[Dict[str, float]]
+
+    def get_display_metric(self) -> Optional[str]:
+        if self.metric is None:
+            return None
+        elif self.metric_std is None:
+            return f"{self.metric:.3f}"
+        else:
+            return f"{self.metric:.3f} ± {self.metric_std:.3f}"
+
+
 class EstimatorWrapper:
     def __init__(
         self,
@@ -297,11 +313,11 @@ class EstimatorWrapper:
 
     def cross_val_predict(
         self, x: pd.DataFrame, y: np.ndarray, baseline_score_column: Optional[Any] = None
-    ) -> Tuple[Optional[float], Optional[Dict[str, float]]]:
+    ) -> _CrossValResults:
         x, y, groups, fit_params = self._prepare_to_fit(x, y)
 
         if x.shape[1] == 0:
-            return None
+            return _CrossValResults(metric=None, metric_std=None, shap_values=None)
 
         scorer = check_scoring(self.estimator, scoring=self.scorer)
 
@@ -326,7 +342,7 @@ class EstimatorWrapper:
 
             self.check_fold_metrics(metrics_by_fold)
 
-            metric = np.mean(metrics_by_fold) * self.multiplier
+            metric, metric_std = self._calculate_metric_from_folds(metrics_by_fold)
 
             splits = self.cv.split(x, y, groups)
 
@@ -351,7 +367,7 @@ class EstimatorWrapper:
         else:
             average_shap_values = None
 
-        return self.post_process_metric(metric), average_shap_values
+        return _CrossValResults(metric=metric, metric_std=metric_std, shap_values=average_shap_values)
 
     def process_shap_values(self, shap_values: Dict[str, float]) -> Dict[str, float]:
         return shap_values
@@ -367,17 +383,25 @@ class EstimatorWrapper:
             metric = 2 * metric - 1
         return metric
 
-    def calculate_metric(self, x: pd.DataFrame, y: np.ndarray, baseline_score_column: Optional[Any] = None) -> float:
+    def calculate_metric(
+        self, x: pd.DataFrame, y: np.ndarray, baseline_score_column: Optional[Any] = None
+    ) -> _CrossValResults:
         x, y, _ = self._prepare_to_calculate(x, y)
         if baseline_score_column is not None and self.metric_name == "GINI":
-            metric = roc_auc_score(y, x[baseline_score_column])
+            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))
 
-            metric = np.mean(metrics) * self.multiplier
-        return self.post_process_metric(metric)
+            metric, metric_std = self._calculate_metric_from_folds(metrics)
+        return _CrossValResults(metric=metric, metric_std=metric_std, shap_values=None)
+
+    def _calculate_metric_from_folds(self, metrics_by_fold: List[float]) -> Tuple[float, float]:
+        metrics_by_fold = [self.post_process_metric(m) for m in metrics_by_fold]
+        metric = np.mean(metrics_by_fold) * self.multiplier
+        metric_std = np.std(metrics_by_fold) * np.abs(self.multiplier)
+        return metric, metric_std
 
     @staticmethod
     def create(
@@ -591,7 +615,7 @@ class CatBoostWrapper(EstimatorWrapper):
 
     def cross_val_predict(
         self, x: pd.DataFrame, y: np.ndarray, baseline_score_column: Optional[Any] = None
-    ) -> Tuple[Optional[float], Optional[Dict[str, float]]]:
+    ) -> _CrossValResults:
         try:
             return super().cross_val_predict(x, y, baseline_score_column)
         except Exception as e:

{upgini-1.2.29a2 → upgini-1.2.29a4}/src/upgini/utils/datetime_utils.py

@@ -111,7 +111,7 @@ class DateTimeSearchKeyConverter:
 
         # Define function to apply sine and cosine transformations
         def add_cyclical_features(df, column, period):
-            period_suffix = f"_{period}" if column != 'day_in_quarter' else ""
+            period_suffix = f"_{period}" if column != "day_in_quarter" else ""
             sin_feature = f"datetime_{column}_sin{period_suffix}"
             cos_feature = f"datetime_{column}_cos{period_suffix}"
             df[sin_feature] = np.sin(2 * np.pi * df[column] / period)
@@ -122,10 +122,10 @@ class DateTimeSearchKeyConverter:
         df["quarter"] = df[self.date_column].dt.quarter
 
         # Calculate the start date of the quarter for each timestamp
-        df["quarter_start"] = df["timestamp"].dt.to_period("Q").dt.start_time
+        df["quarter_start"] = df[self.date_column].dt.to_period("Q").dt.start_time
 
         # Calculate the day in the quarter
-        df["day_in_quarter"] = (df["timestamp"] - df["quarter_start"]).dt.days + 1
+        df["day_in_quarter"] = (df[self.date_column] - df["quarter_start"]).dt.days + 1
 
         # Vectorized calculation of days_in_quarter
         quarter = df["quarter"]
@@ -138,7 +138,7 @@ class DateTimeSearchKeyConverter:
 
         end = pd.to_datetime({"year": quarter_end_year, "month": quarter_end_month, "day": 1})
 
-        df["days_in_quarter"] = (end - start).dt.days
+        df["days_in_quarter"] = (end.reset_index(drop=True) - start.reset_index(drop=True)).dt.days
 
         add_cyclical_features(df, "day_in_quarter", df["days_in_quarter"])  # Days in the quarter
 

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

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