autogluon.tabular 1.5.1b20260105__py3-none-any.whl → 1.5.1b20260116__py3-none-any.whl

autogluon/tabular/models/tabular_nn/utils/data_preprocessor.py

@@ -15,16 +15,28 @@ from .categorical_encoders import OneHotMergeRaresHandleUnknownEncoder, OrdinalM
 
 
 def create_preprocessor(
-    impute_strategy, max_category_levels, unique_category_str, continuous_features, skewed_features, onehot_features, embed_features, bool_features
+    impute_strategy,
+    max_category_levels,
+    unique_category_str,
+    continuous_features,
+    skewed_features,
+    onehot_features,
+    embed_features,
+    bool_features,
 ):
     """Creates sklearn ColumnTransformer that can be fit to training data to preprocess it for tabular neural network."""
     transformers = []  # order of various column transformers in this list is important!
     if continuous_features:
-        continuous_transformer = Pipeline(steps=[("imputer", SimpleImputer(strategy=impute_strategy)), ("scaler", StandardScaler())])
+        continuous_transformer = Pipeline(
+            steps=[("imputer", SimpleImputer(strategy=impute_strategy)), ("scaler", StandardScaler())]
+        )
         transformers.append(("continuous", continuous_transformer, continuous_features))
     if skewed_features:
         power_transformer = Pipeline(
-            steps=[("imputer", SimpleImputer(strategy=impute_strategy)), ("quantile", QuantileTransformer(output_distribution="normal"))]
+            steps=[
+                ("imputer", SimpleImputer(strategy=impute_strategy)),
+                ("quantile", QuantileTransformer(output_distribution="normal")),
+            ]
         )  # Or output_distribution = 'uniform'
         transformers.append(("skewed", power_transformer, skewed_features))
     if onehot_features:
@@ -39,24 +51,30 @@ def create_preprocessor(
         transformers.append(("ordinal", ordinal_transformer, embed_features))
     try:
         out = ColumnTransformer(
-            transformers=transformers, remainder="passthrough", force_int_remainder_cols=False,
+            transformers=transformers,
+            remainder="passthrough",
+            force_int_remainder_cols=False,
         )  # numeric features are processed in the same order as in numeric_features vector, so feature-names remain the same.
     except:
         # TODO: Avoid try/except once scikit-learn 1.5 is minimum
         # Needed for scikit-learn 1.4 and 1.9+, force_int_remainder_cols is deprecated in 1.7 and introduced in 1.5
         # ref: https://github.com/autogluon/autogluon/issues/5289
         out = ColumnTransformer(
-            transformers=transformers, remainder="passthrough",
+            transformers=transformers,
+            remainder="passthrough",
         )  # numeric features are processed in the same order as in numeric_features vector, so feature-names remain the same.
     return out
 
+
 def convert_df_dtype_to_str(df):
     return df.astype(str)
 
 
 def get_feature_arraycol_map(processor, max_category_levels):
     """Returns OrderedDict of feature-name -> list of column-indices in processed data array corresponding to this feature"""
-    feature_preserving_transforms = set(["continuous", "skewed", "ordinal", "bool", "remainder"])  # these transforms do not alter dimensionality of feature
+    feature_preserving_transforms = set(
+        ["continuous", "skewed", "ordinal", "bool", "remainder"]
+    )  # these transforms do not alter dimensionality of feature
     feature_arraycol_map = {}  # unordered version
     current_colindex = 0
     for transformer in processor.transformers_:
@@ -85,8 +103,15 @@ def get_feature_arraycol_map(processor, max_category_levels):
 def get_feature_type_map(feature_arraycol_map, types_of_features):
     """Returns OrderedDict of feature-name -> feature_type string (options: 'vector', 'embed')."""
     if feature_arraycol_map is None:
-        raise ValueError("Must first call get_feature_arraycol_map() to set feature_arraycol_map before calling get_feature_type_map()")
-    vector_features = types_of_features["continuous"] + types_of_features["skewed"] + types_of_features["onehot"] + types_of_features["bool"]
+        raise ValueError(
+            "Must first call get_feature_arraycol_map() to set feature_arraycol_map before calling get_feature_type_map()"
+        )
+    vector_features = (
+        types_of_features["continuous"]
+        + types_of_features["skewed"]
+        + types_of_features["onehot"]
+        + types_of_features["bool"]
+    )
     feature_type_map = OrderedDict()
     for feature_name in feature_arraycol_map:
         if feature_name in vector_features:

autogluon/tabular/models/tabular_nn/utils/nn_architecture_utils.py

@@ -14,7 +14,8 @@ def get_embed_sizes(train_dataset, params, num_categs_per_feature):
     embed_exponent = params["embed_exponent"]
     size_factor = params["embedding_size_factor"]
     embed_dims = [
-        int(size_factor * max(2, min(max_embedding_dim, 1.6 * num_categs_per_feature[i] ** embed_exponent))) for i in range(len(num_categs_per_feature))
+        int(size_factor * max(2, min(max_embedding_dim, 1.6 * num_categs_per_feature[i] ** embed_exponent)))
+        for i in range(len(num_categs_per_feature))
     ]
     return embed_dims
 
@@ -39,11 +40,16 @@ def infer_y_range(y_vals, y_range_extend):
 def get_default_layers(problem_type, num_net_outputs, max_layer_width):
     """Default sizes for NN layers."""
     if problem_type == REGRESSION:
-        default_layer_sizes = [256, 128]  # overall network will have 4 layers. Input layer, 256-unit hidden layer, 128-unit hidden layer, output layer.
+        default_layer_sizes = [
+            256,
+            128,
+        ]  # overall network will have 4 layers. Input layer, 256-unit hidden layer, 128-unit hidden layer, output layer.
     else:
         default_sizes = [256, 128]  # will be scaled adaptively
         # base_size = max(1, min(num_net_outputs, 20)/2.0) # scale layer width based on number of classes
-        base_size = max(1, min(num_net_outputs, 100) / 50)  # TODO: Updated because it improved model quality and made training far faster
+        base_size = max(
+            1, min(num_net_outputs, 100) / 50
+        )  # TODO: Updated because it improved model quality and made training far faster
         default_layer_sizes = [defaultsize * base_size for defaultsize in default_sizes]
     layer_expansion_factor = 1  # TODO: consider scaling based on num_rows, eg: layer_expansion_factor = 2-np.exp(-max(0,train_dataset.num_examples-10000))
     return [int(min(max_layer_width, layer_expansion_factor * defaultsize)) for defaultsize in default_layer_sizes]
@@ -51,8 +57,17 @@ def get_default_layers(problem_type, num_net_outputs, max_layer_width):
 
 def default_numeric_embed_dim(train_dataset, max_layer_width, first_layer_width):
     """Default embedding dimensionality for numeric features."""
-    vector_dim = train_dataset.dataset._data[train_dataset.vectordata_index].shape[1]  # total dimensionality of vector features
-    prop_vector_features = train_dataset.num_vector_features() / float(train_dataset.num_features)  # Fraction of features that are numeric
+    vector_dim = train_dataset.dataset._data[train_dataset.vectordata_index].shape[
+        1
+    ]  # total dimensionality of vector features
+    prop_vector_features = train_dataset.num_vector_features() / float(
+        train_dataset.num_features
+    )  # Fraction of features that are numeric
     min_numeric_embed_dim = 32
     max_numeric_embed_dim = max_layer_width
-    return int(min(max_numeric_embed_dim, max(min_numeric_embed_dim, first_layer_width * prop_vector_features * np.log10(vector_dim + 10))))
+    return int(
+        min(
+            max_numeric_embed_dim,
+            max(min_numeric_embed_dim, first_layer_width * prop_vector_features * np.log10(vector_dim + 10)),
+        )
+    )

autogluon/tabular/models/xgboost/callbacks.py

@@ -51,8 +51,12 @@ class CustomMetricCallback(TrainingCallback):
     """
 
     def __init__(self, scorers, eval_sets, problem_type, use_error=True):
-        self.metrics = [learning_curve_func_generator(scorer, problem_type=problem_type, use_error=use_error) for scorer in scorers]
-        self.eval_sets = [(name, DMatrix(eval_set[0], label=eval_set[1]), eval_set[1]) for name, eval_set in eval_sets.items()]
+        self.metrics = [
+            learning_curve_func_generator(scorer, problem_type=problem_type, use_error=use_error) for scorer in scorers
+        ]
+        self.eval_sets = [
+            (name, DMatrix(eval_set[0], label=eval_set[1]), eval_set[1]) for name, eval_set in eval_sets.items()
+        ]
 
     def after_iteration(self, model, epoch, evals_log):
         y_preds = [model.predict(eval_set[1]) for eval_set in self.eval_sets]
@@ -155,7 +159,9 @@ class EarlyStoppingCustom(EarlyStopping):
                 logger.warning(
                     f"Warning: Early stopped XGB model prior to optimal result to avoid OOM error. Please increase available memory to avoid subpar model quality.\n"
                 )
-                logger.warning(f"Early stopping. Best iteration is: \t[{model.attr('best_iteration')}]\t{model.attr('best_score')}")
+                logger.warning(
+                    f"Early stopping. Best iteration is: \t[{model.attr('best_iteration')}]\t{model.attr('best_score')}"
+                )
             return True
         elif self.verbose and (model_size_memory_ratio > 0.25):
             logger.log(15, f"Available Memory: {available_mb} MB")

autogluon/tabular/models/xgboost/xgboost_model.py

@@ -29,6 +29,7 @@ class XGBoostModel(AbstractModel):
 
     Hyperparameter options: https://xgboost.readthedocs.io/en/latest/parameter.html
     """
+
     ag_key = "XGB"
     ag_name = "XGBoost"
     ag_priority = 40
@@ -58,7 +59,9 @@ class XGBoostModel(AbstractModel):
 
     # Use specialized XGBoost metric if available (fast), otherwise use custom func generator
     def get_eval_metric(self):
-        eval_metric = xgboost_utils.convert_ag_metric_to_xgbm(ag_metric_name=self.stopping_metric.name, problem_type=self.problem_type)
+        eval_metric = xgboost_utils.convert_ag_metric_to_xgbm(
+            ag_metric_name=self.stopping_metric.name, problem_type=self.problem_type
+        )
         if eval_metric is None:
             eval_metric = xgboost_utils.func_generator(metric=self.stopping_metric, problem_type=self.problem_type)
         return eval_metric
@@ -76,7 +79,20 @@ class XGBoostModel(AbstractModel):
 
         return X
 
-    def _fit(self, X, y, X_val=None, y_val=None, time_limit=None, num_gpus=0, num_cpus=None, sample_weight=None, sample_weight_val=None, verbosity=2, **kwargs):
+    def _fit(
+        self,
+        X,
+        y,
+        X_val=None,
+        y_val=None,
+        time_limit=None,
+        num_gpus=0,
+        num_cpus=None,
+        sample_weight=None,
+        sample_weight_val=None,
+        verbosity=2,
+        **kwargs,
+    ):
         # TODO: utilize sample_weight_val in early-stopping if provided
         start_time = time.time()
         ag_params = self._get_ag_params()
@@ -123,7 +139,9 @@ class XGBoostModel(AbstractModel):
                 params["eval_metric"] = eval_metric
                 eval_metric_name = eval_metric.__name__ if not isinstance(eval_metric, str) else eval_metric
         else:
-            eval_metric_name = params["eval_metric"].__name__ if not isinstance(params["eval_metric"], str) else params["eval_metric"]
+            eval_metric_name = (
+                params["eval_metric"].__name__ if not isinstance(params["eval_metric"], str) else params["eval_metric"]
+            )
 
         if X_val is None:
             early_stopping_rounds = None
@@ -133,7 +151,9 @@ class XGBoostModel(AbstractModel):
             eval_set["val"] = (X_val, y_val)
             early_stopping_rounds = ag_params.get("early_stop", "adaptive")
             if isinstance(early_stopping_rounds, (str, tuple, list)):
-                early_stopping_rounds = self._get_early_stopping_rounds(num_rows_train=num_rows_train, strategy=early_stopping_rounds)
+                early_stopping_rounds = self._get_early_stopping_rounds(
+                    num_rows_train=num_rows_train, strategy=early_stopping_rounds
+                )
 
         if generate_curves and eval_set is not None:
             scorers = ag_params.get("curve_metrics", [self.eval_metric])
@@ -161,7 +181,14 @@ class XGBoostModel(AbstractModel):
         if eval_set is not None and "callbacks" not in params:
             callbacks = []
             if generate_curves:
-                callbacks.append(CustomMetricCallback(scorers=scorers, eval_sets=eval_set, problem_type=self.problem_type, use_error=use_curve_metric_error))
+                callbacks.append(
+                    CustomMetricCallback(
+                        scorers=scorers,
+                        eval_sets=eval_set,
+                        problem_type=self.problem_type,
+                        use_error=use_curve_metric_error,
+                    )
+                )
             if log_period is not None:
                 callbacks.append(EvaluationMonitor(period=log_period))
 
@@ -254,7 +281,13 @@ class XGBoostModel(AbstractModel):
 
     def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:
         hyperparameters = self._get_model_params()
-        return self.estimate_memory_usage_static(X=X, problem_type=self.problem_type, num_classes=self.num_classes, hyperparameters=hyperparameters, **kwargs)
+        return self.estimate_memory_usage_static(
+            X=X,
+            problem_type=self.problem_type,
+            num_classes=self.num_classes,
+            hyperparameters=hyperparameters,
+            **kwargs,
+        )
 
     @classmethod
     def _estimate_memory_usage_static(
@@ -267,9 +300,13 @@ class XGBoostModel(AbstractModel):
     ) -> int:
         if hyperparameters is None:
             hyperparameters = {}
-        num_classes = num_classes if num_classes else 1  # self.num_classes could be None after initialization if it's a regression problem
+        num_classes = (
+            num_classes if num_classes else 1
+        )  # self.num_classes could be None after initialization if it's a regression problem
         data_mem_usage = get_approximate_df_mem_usage(X).sum()
-        data_mem_usage_bytes = data_mem_usage * 7 + data_mem_usage / 4 * num_classes  # TODO: Extremely crude approximation, can be vastly improved
+        data_mem_usage_bytes = (
+            data_mem_usage * 7 + data_mem_usage / 4 * num_classes
+        )  # TODO: Extremely crude approximation, can be vastly improved
 
         max_bin = hyperparameters.get("max_bin", 256)
         max_depth = hyperparameters.get("max_depth", 6)
@@ -299,14 +336,25 @@ class XGBoostModel(AbstractModel):
         mem_size_per_estimator = num_classes * max_depth * 500  # very rough estimate
         n_estimators = hyperparameters.get("n_estimators", 10000)
         n_estimators_min = min(n_estimators, 1000)
-        mem_size_estimators = n_estimators_min * mem_size_per_estimator  # memory estimate after fitting up to 1000 estimators
+        mem_size_estimators = (
+            n_estimators_min * mem_size_per_estimator
+        )  # memory estimate after fitting up to 1000 estimators
 
         approx_mem_size_req = data_mem_usage_bytes + histogram_mem_usage_bytes + mem_size_estimators
         return approx_mem_size_req
 
-    def _validate_fit_memory_usage(self, mem_error_threshold: float = 1.0, mem_warning_threshold: float = 0.75, mem_size_threshold: int = 1e9, **kwargs):
+    def _validate_fit_memory_usage(
+        self,
+        mem_error_threshold: float = 1.0,
+        mem_warning_threshold: float = 0.75,
+        mem_size_threshold: int = 1e9,
+        **kwargs,
+    ):
         return super()._validate_fit_memory_usage(
-            mem_error_threshold=mem_error_threshold, mem_warning_threshold=mem_warning_threshold, mem_size_threshold=mem_size_threshold, **kwargs
+            mem_error_threshold=mem_error_threshold,
+            mem_warning_threshold=mem_warning_threshold,
+            mem_size_threshold=mem_size_threshold,
+            **kwargs,
         )
 
     def get_minimum_resources(self, is_gpu_available=False):

autogluon/tabular/models/xt/xt_model.py

@@ -9,6 +9,7 @@ class XTModel(RFModel):
     """
     Extra Trees model (scikit-learn): https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.ExtraTreesClassifier.html#sklearn.ensemble.ExtraTreesClassifier
     """
+
     ag_key = "XT"
     ag_name = "ExtraTrees"
     ag_priority = 60

autogluon/tabular/predictor/interpretable_predictor.py

@@ -135,5 +135,7 @@ class InterpretableTabularPredictor(TabularPredictor):
         labels = data[self.label]
         data_transformed = self.transform_features(data=data, model=model)
         labels_transformed = self.transform_labels(labels=labels)
-        cls, columns = imodels.explain_classification_errors(data_transformed, predictions, labels_transformed, print_rules=print_rules)
+        cls, columns = imodels.explain_classification_errors(
+            data_transformed, predictions, labels_transformed, print_rules=print_rules
+        )
         return cls