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

autogluon/tabular/models/realmlp/realmlp_model.py

@@ -16,8 +16,8 @@ from sklearn.impute import SimpleImputer
 
 from autogluon.common.utils.pandas_utils import get_approximate_df_mem_usage
 from autogluon.common.utils.resource_utils import ResourceManager
-from autogluon.tabular.models.abstract.abstract_torch_model import AbstractTorchModel
 from autogluon.tabular import __version__
+from autogluon.tabular.models.abstract.abstract_torch_model import AbstractTorchModel
 
 logger = logging.getLogger(__name__)
 
@@ -48,6 +48,7 @@ class RealMLPModel(AbstractTorchModel):
 
     .. versionadded:: 1.4.0
     """
+
     ag_key = "REALMLP"
     ag_name = "RealMLP"
     ag_priority = 75
@@ -71,7 +72,7 @@ class RealMLPModel(AbstractTorchModel):
         )
 
         assert default_hyperparameters in ["td", "td_s"]
-        if self.problem_type in ['binary', 'multiclass']:
+        if self.problem_type in ["binary", "multiclass"]:
             if default_hyperparameters == "td":
                 model_cls = RealMLP_TD_Classifier
             else:
@@ -172,7 +173,11 @@ class RealMLPModel(AbstractTorchModel):
         name_categories = hyp.pop("name_categories", True)
 
         n_features = len(X.columns)
-        if "predict_batch_size" in hyp and isinstance(hyp["predict_batch_size"], str) and hyp["predict_batch_size"] == "auto":
+        if (
+            "predict_batch_size" in hyp
+            and isinstance(hyp["predict_batch_size"], str)
+            and hyp["predict_batch_size"] == "auto"
+        ):
             # simple heuristic to avoid OOM during inference time
             # note: this isn't fool-proof, and ignores the actual memory availability of the machine.
             # note: this is based on an assumption of 32 GB of memory available on the instance
@@ -191,7 +196,7 @@ class RealMLPModel(AbstractTorchModel):
         # FIXME: In rare cases can cause exceptions if name_categories=False, unknown why
         extra_fit_kwargs = {}
         if name_categories:
-            cat_col_names = X.select_dtypes(include='category').columns.tolist()
+            cat_col_names = X.select_dtypes(include="category").columns.tolist()
             extra_fit_kwargs["cat_col_names"] = cat_col_names
 
         if X_val is not None:
@@ -213,7 +218,9 @@ class RealMLPModel(AbstractTorchModel):
 
     # TODO: Move missing indicator + mean fill to a generic preprocess flag available to all models
     # FIXME: bool_to_cat is a hack: Maybe move to abstract model?
-    def _preprocess(self, X: pd.DataFrame, is_train: bool = False, bool_to_cat: bool = False, impute_bool: bool = True, **kwargs) -> pd.DataFrame:
+    def _preprocess(
+        self, X: pd.DataFrame, is_train: bool = False, bool_to_cat: bool = False, impute_bool: bool = True, **kwargs
+    ) -> pd.DataFrame:
         """
         Imputes missing values via the mean and adds indicator columns for numerical features.
         Converts indicator columns to categorical features to avoid them being treated as numerical by RealMLP.
@@ -229,12 +236,18 @@ class RealMLPModel(AbstractTorchModel):
                 self._features_to_impute = self._feature_metadata.get_features(valid_raw_types=["int", "float"])
                 self._features_to_keep = self._feature_metadata.get_features(invalid_raw_types=["int", "float"])
             else:
-                self._features_to_impute = self._feature_metadata.get_features(valid_raw_types=["int", "float"], invalid_special_types=["bool"])
-                self._features_to_keep = [f for f in self._feature_metadata.get_features() if f not in self._features_to_impute]
+                self._features_to_impute = self._feature_metadata.get_features(
+                    valid_raw_types=["int", "float"], invalid_special_types=["bool"]
+                )
+                self._features_to_keep = [
+                    f for f in self._feature_metadata.get_features() if f not in self._features_to_impute
+                ]
             if self._features_to_impute:
                 self._imputer = SimpleImputer(strategy="mean", add_indicator=True)
                 self._imputer.fit(X=X[self._features_to_impute])
-                self._indicator_columns = [c for c in self._imputer.get_feature_names_out() if c not in self._features_to_impute]
+                self._indicator_columns = [
+                    c for c in self._imputer.get_feature_names_out() if c not in self._features_to_impute
+                ]
         if self._imputer is not None:
             X_impute = self._imputer.transform(X=X[self._features_to_impute])
             X_impute = pd.DataFrame(X_impute, index=X.index, columns=self._imputer.get_feature_names_out())
@@ -254,23 +267,17 @@ class RealMLPModel(AbstractTorchModel):
             use_early_stopping=False,
             early_stopping_additive_patience=40,
             early_stopping_multiplicative_patience=3,
-
             # verdict: use_ls="auto" is much better than None.
             use_ls="auto",
-
             # verdict: no impact, but makes more sense to be False.
             impute_bool=False,
-
             # verdict: name_categories=True avoids random exceptions being raised in rare cases
             name_categories=True,
-
             # verdict: bool_to_cat=True is equivalent to False in terms of quality, but can be slightly faster in training time
             #  and slightly slower in inference time
             bool_to_cat=True,
-
             # verdict: "td" is better than "td_s"
             default_hyperparameters="td",  # options ["td", "td_s"]
-
             predict_batch_size="auto",  # if auto, uses AutoGluon's heuristic to set a value between 8192 and 64.
         )
         for param, val in default_params.items():
@@ -293,7 +300,13 @@ class RealMLPModel(AbstractTorchModel):
 
     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(

autogluon/tabular/models/rf/compilers/onnx.py

@@ -83,7 +83,7 @@ class RFOnnxCompiler:
             The compiler would optimize the model to perform best with the given input type.
         """
         if input_types is None or not isinstance(input_types[0], tuple):
-            raise RuntimeError("input_types argument should contain at least one tuple" ", e.g. [((1, 14), np.float32)]")
+            raise RuntimeError("input_types argument should contain at least one tuple, e.g. [((1, 14), np.float32)]")
         if isinstance(model, RFOnnxPredictor):
             return model
 

autogluon/tabular/models/rf/rf_model.py

@@ -27,6 +27,7 @@ class RFModel(AbstractModel):
     """
     Random Forest model (scikit-learn): https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html
     """
+
     ag_key = "RF"
     ag_name = "RandomForest"
     ag_priority = 80
@@ -135,7 +136,13 @@ class RFModel(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(
@@ -154,14 +161,25 @@ class RFModel(AbstractModel):
             n_estimators = n_estimators_final
         else:  # if search space
             n_estimators = 40
-        num_trees_per_estimator = cls._get_num_trees_per_estimator_static(problem_type=problem_type, num_classes=num_classes)
+        num_trees_per_estimator = cls._get_num_trees_per_estimator_static(
+            problem_type=problem_type, num_classes=num_classes
+        )
         bytes_per_estimator = num_trees_per_estimator * len(X) / 60000 * 1e6  # Underestimates by 3x on ExtraTrees
         expected_memory_usage = int(bytes_per_estimator * n_estimators)
         return expected_memory_usage
 
-    def _validate_fit_memory_usage(self, mem_error_threshold: float = 0.5, mem_warning_threshold: float = 0.4, mem_size_threshold: int = 1e7, **kwargs):
+    def _validate_fit_memory_usage(
+        self,
+        mem_error_threshold: float = 0.5,
+        mem_warning_threshold: float = 0.4,
+        mem_size_threshold: int = 1e7,
+        **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 _expected_mem_usage(self, n_estimators_final, bytes_per_estimator):
@@ -194,7 +212,9 @@ class RFModel(AbstractModel):
                 n_estimator_increments = [n_estimators_test, n_estimators_final]
                 params["warm_start"] = True
             else:
-                if expected_memory_usage > (0.05 * max_memory_usage_ratio):  # Somewhat arbitrary, consider finding a better value, should it scale by cores?
+                if expected_memory_usage > (
+                    0.05 * max_memory_usage_ratio
+                ):  # Somewhat arbitrary, consider finding a better value, should it scale by cores?
                     # Causes ~10% training slowdown, so try to avoid if memory is not an issue
                     n_estimator_increments = [n_estimators_test, n_estimators_final]
                     params["warm_start"] = True
@@ -218,7 +238,9 @@ class RFModel(AbstractModel):
                     model = model_cls(**params)
             model = model.fit(X, y, sample_weight=sample_weight)
             if (i == 0) and (len(n_estimator_increments) > 1):
-                time_elapsed = max(time.time() - time_train_start, 0.001)  # avoid it being too small and being truncated to 0
+                time_elapsed = max(
+                    time.time() - time_train_start, 0.001
+                )  # avoid it being too small and being truncated to 0
                 model_size_bytes = 0
                 for estimator in model.estimators_:  # Uses far less memory than pickling the entire forest at once
                     model_size_bytes += sys.getsizeof(pickle.dumps(estimator))
@@ -227,19 +249,25 @@ class RFModel(AbstractModel):
                 model_memory_ratio = expected_final_model_size_bytes / available_mem
 
                 ideal_memory_ratio = 0.15 * max_memory_usage_ratio
-                n_estimators_ideal = min(n_estimators_final, math.floor(ideal_memory_ratio / model_memory_ratio * n_estimators_final))
+                n_estimators_ideal = min(
+                    n_estimators_final, math.floor(ideal_memory_ratio / model_memory_ratio * n_estimators_final)
+                )
 
                 if n_estimators_final > n_estimators_ideal:
                     if n_estimators_ideal < n_estimators_minimum:
-                        logger.warning(f"\tWarning: Model is expected to require {round(model_memory_ratio*100, 2)}% of available memory...")
+                        logger.warning(
+                            f"\tWarning: Model is expected to require {round(model_memory_ratio * 100, 2)}% of available memory..."
+                        )
                         raise NotEnoughMemoryError  # don't train full model to avoid OOM error
                     logger.warning(
-                        f"\tWarning: Reducing model 'n_estimators' from {n_estimators_final} -> {n_estimators_ideal} due to low memory. Expected memory usage reduced from {round(model_memory_ratio*100, 2)}% -> {round(ideal_memory_ratio*100, 2)}% of available memory..."
+                        f"\tWarning: Reducing model 'n_estimators' from {n_estimators_final} -> {n_estimators_ideal} due to low memory. Expected memory usage reduced from {round(model_memory_ratio * 100, 2)}% -> {round(ideal_memory_ratio * 100, 2)}% of available memory..."
                     )
 
                 if time_limit is not None:
                     time_expected = time_train_start - time_start + (time_elapsed * n_estimators_ideal / n_estimators)
-                    n_estimators_time = math.floor((time_limit - time_train_start + time_start) * n_estimators / time_elapsed)
+                    n_estimators_time = math.floor(
+                        (time_limit - time_train_start + time_start) * n_estimators / time_elapsed
+                    )
                     if n_estimators_time < n_estimators_ideal:
                         if n_estimators_time < n_estimators_minimum:
                             logger.warning(
@@ -293,9 +321,14 @@ class RFModel(AbstractModel):
     # FIXME: Unknown if this works with quantile regression
     def _predict_proba_oof(self, X, y, **kwargs):
         if not self.model.bootstrap:
-            raise ValueError("Forest models must set `bootstrap=True` to compute out-of-fold predictions via out-of-bag predictions.")
+            raise ValueError(
+                "Forest models must set `bootstrap=True` to compute out-of-fold predictions via out-of-bag predictions."
+            )
 
-        oob_is_not_set = getattr(self.model, "oob_decision_function_", None) is None and getattr(self.model, "oob_prediction_", None) is None
+        oob_is_not_set = (
+            getattr(self.model, "oob_decision_function_", None) is None
+            and getattr(self.model, "oob_prediction_", None) is None
+        )
 
         if oob_is_not_set and self._daal:
             raise AssertionError("DAAL forest backend does not support out-of-bag predictions.")

autogluon/tabular/models/rf/rf_quantile.py

@@ -85,7 +85,7 @@ def weighted_percentile(a, q, weights=None, sorter=None, is_filtered=False):
     if weights is None:
         weights = np.ones_like(a)
     if q > 100 or q < 0:
-        raise ValueError("q should be in-between 0 and 100, " "got %d" % q)
+        raise ValueError("q should be in-between 0 and 100, got %d" % q)
 
     a = np.asarray(a, dtype=np.float32)
     weights = np.asarray(weights, dtype=np.float32)
@@ -555,7 +555,9 @@ class BaseForestQuantileRegressor(ForestRegressor):
         samples_with_weighted_neighbors = get_weighted_neighbors_dataframe(
             X_leaves=X_leaves, y_train_leaves=self.y_train_leaves_, y_train=self.y_train_, y_weights=self.y_weights_
         )
-        quantile_preds = samples_with_weighted_neighbors.groupby("item_id").apply(partial(get_quantiles, quantile_levels=quantile_levels), include_groups=False)
+        quantile_preds = samples_with_weighted_neighbors.groupby("item_id").apply(
+            partial(get_quantiles, quantile_levels=quantile_levels), include_groups=False
+        )
         return np.stack(quantile_preds.values.tolist())
 
 

autogluon/tabular/models/tabdpt/tabdpt_model.py

@@ -64,11 +64,7 @@ class TabDPTModel(AbstractTorchModel):
             )
         from tabdpt import TabDPTClassifier, TabDPTRegressor
 
-        model_cls = (
-            TabDPTClassifier
-            if self.problem_type in [BINARY, MULTICLASS]
-            else TabDPTRegressor
-        )
+        model_cls = TabDPTClassifier if self.problem_type in [BINARY, MULTICLASS] else TabDPTRegressor
         fit_params, self._predict_hps = self._get_tabdpt_params(num_gpus=num_gpus)
 
         X = self.preprocess(X)
@@ -117,6 +113,9 @@ class TabDPTModel(AbstractTorchModel):
         if not torch.cuda.is_available():
             return False
 
+        if not torch.backends.cuda.is_flash_attention_available():
+            return False
+
         device = torch.device("cuda:0")
         capability = torch.cuda.get_device_capability(device)
 
@@ -147,9 +146,7 @@ class TabDPTModel(AbstractTorchModel):
 
         return num_cpus, num_gpus
 
-    def get_minimum_resources(
-        self, is_gpu_available: bool = False
-    ) -> dict[str, int | float]:
+    def get_minimum_resources(self, is_gpu_available: bool = False) -> dict[str, int | float]:
         return {
             "num_cpus": 1,
             "num_gpus": 0.5 if is_gpu_available else 0,
@@ -173,9 +170,7 @@ class TabDPTModel(AbstractTorchModel):
             self._feature_generator.fit(X=X)
         if self._feature_generator.features_in:
             X = X.copy()
-            X[self._feature_generator.features_in] = self._feature_generator.transform(
-                X=X
-            )
+            X[self._feature_generator.features_in] = self._feature_generator.transform(X=X)
         return X.to_numpy()
 
     @classmethod
@@ -232,14 +227,10 @@ class TabDPTModel(AbstractTorchModel):
         model_mem = 14489108  # Based on TabPFNv2 default
 
         n_samples, n_features = X.shape[0], min(X.shape[1], 500)
-        n_feature_groups = (
-            n_features
-        ) / features_per_group + 1  # TODO: Unsure how to calculate this
+        n_feature_groups = (n_features) / features_per_group + 1  # TODO: Unsure how to calculate this
 
         X_mem = n_samples * n_feature_groups * dtype_byte_size
-        activation_mem = (
-            n_samples * n_feature_groups * embedding_size * n_layers * dtype_byte_size
-        )
+        activation_mem = n_samples * n_feature_groups * embedding_size * n_layers * dtype_byte_size
 
         baseline_overhead_mem_est = 1e9  # 1 GB generic overhead
 

autogluon/tabular/models/tabicl/tabicl_model.py

@@ -32,6 +32,7 @@ class TabICLModel(AbstractTorchModel):
 
     .. versionadded:: 1.4.0
     """
+
     ag_key = "TABICL"
     ag_name = "TabICL"
     ag_priority = 65
@@ -133,7 +134,13 @@ class TabICLModel(AbstractTorchModel):
 
     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(

autogluon/tabular/models/tabm/_tabm_internal.py

@@ -212,10 +212,12 @@ class TabMImplementation:
         )  # Unique ordinal encoder -> replaces nan and missing values with the cardinality
         self.ord_enc_.fit(X_train[self.cat_col_names_])
         # TODO: fix transformer to be able to work with empty input data like the sklearn default
-        self.num_prep_ = Pipeline(steps=[
-            ("qt", RTDLQuantileTransformer(random_state=self.config.get("random_state", None))),
-            ("imp", SimpleImputer(add_indicator=True)),
-        ])
+        self.num_prep_ = Pipeline(
+            steps=[
+                ("qt", RTDLQuantileTransformer(random_state=self.config.get("random_state", None))),
+                ("imp", SimpleImputer(add_indicator=True)),
+            ]
+        )
         self.has_num_cols = bool(set(X_train.columns) - set(cat_col_names))
         for part, X, y in [("train", X_train, y_train), ("val", X_val, y_val)]:
             tensors = dict()