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

autogluon/tabular/models/automm/automm_model.py

@@ -1,4 +1,5 @@
 """Wrapper of the MultiModalPredictor."""
+
 from __future__ import annotations
 
 import logging
@@ -162,7 +163,9 @@ class MultiModalPredictorModel(AbstractModel):
 
         X, y, X_val, y_val = self.preprocess_fit(X=X, y=y, X_val=X_val, y_val=y_val)
         params = self._get_model_params()
-        max_features = params.pop("_max_features", None)  # FIXME: `_max_features` is a hack. Instead use ag_args_fit and make generic
+        max_features = params.pop(
+            "_max_features", None
+        )  # FIXME: `_max_features` is a hack. Instead use ag_args_fit and make generic
         num_features = len(X.columns)
         if max_features is not None and num_features > max_features:
             raise AssertionError(
@@ -180,7 +183,11 @@ class MultiModalPredictorModel(AbstractModel):
             enable_progress_bar = True
         num_gpus = kwargs.get("num_gpus", None)
         if sample_weight is not None:  # TODO: support
-            logger.log(15, "sample_weight not yet supported for MultiModalPredictorModel, " "this model will ignore them in training.")
+            logger.log(
+                15,
+                "sample_weight not yet supported for MultiModalPredictorModel, "
+                "this model will ignore them in training.",
+            )
 
         # Need to deep copy to avoid altering outer context
         X = X.copy()
@@ -273,7 +280,9 @@ class MultiModalPredictorModel(AbstractModel):
 
     def _get_default_resources(self):
         num_cpus = ResourceManager.get_cpu_count()
-        num_gpus = min(ResourceManager.get_gpu_count_torch(), 1)  # Use single gpu training by default. Consider to revise it later.
+        num_gpus = min(
+            ResourceManager.get_gpu_count_torch(), 1
+        )  # Use single gpu training by default. Consider to revise it later.
         return num_cpus, num_gpus
 
     def get_minimum_resources(self, is_gpu_available=False) -> Dict[str, int]:

autogluon/tabular/models/automm/ft_transformer.py

@@ -1,4 +1,5 @@
 """Wrapper of the MultiModalPredictor."""
+
 from __future__ import annotations
 
 import logging
@@ -57,7 +58,10 @@ class FTTransformerModel(MultiModalPredictorModel):
     def _fit(self, X, num_gpus="auto", **kwargs):
         if not isinstance(num_gpus, str):
             if num_gpus == 0:
-                logger.log(30, f"WARNING: Training {self.name} on CPU (no GPU specified). This could take a long time. Use GPU to speed up training.")
+                logger.log(
+                    30,
+                    f"WARNING: Training {self.name} on CPU (no GPU specified). This could take a long time. Use GPU to speed up training.",
+                )
         super()._fit(X, num_gpus=num_gpus, **kwargs)
 
     def _get_default_auxiliary_params(self) -> dict:

autogluon/tabular/models/catboost/callbacks.py

@@ -60,8 +60,8 @@ class MemoryCheckCallback:
             self.init_mem_rss = cur_rss
 
         # Convert memory values to MB
-        estimated_model_size_mb = (cur_rss - self.init_mem_rss) / (1024 ** 2)
-        available_mb = available_bytes / (1024 ** 2)
+        estimated_model_size_mb = (cur_rss - self.init_mem_rss) / (1024**2)
+        available_mb = available_bytes / (1024**2)
 
         model_size_memory_ratio = estimated_model_size_mb / available_mb
         early_stop = False

autogluon/tabular/models/catboost/catboost_model.py

@@ -13,13 +13,13 @@ from autogluon.common.features.types import R_BOOL, R_CATEGORY, R_FLOAT, R_INT
 from autogluon.common.utils.pandas_utils import get_approximate_df_mem_usage
 from autogluon.common.utils.resource_utils import ResourceManager
 from autogluon.common.utils.try_import import try_import_catboost
-from autogluon.core.constants import MULTICLASS, PROBLEM_TYPES_CLASSIFICATION, REGRESSION, QUANTILE, SOFTCLASS
+from autogluon.core.constants import MULTICLASS, PROBLEM_TYPES_CLASSIFICATION, QUANTILE, REGRESSION, SOFTCLASS
 from autogluon.core.models import AbstractModel
 from autogluon.core.models._utils import get_early_stopping_rounds
 from autogluon.core.utils.exceptions import TimeLimitExceeded
 
 from .callbacks import EarlyStoppingCallback, MemoryCheckCallback, TimeCheckCallback
-from .catboost_utils import get_catboost_metric_from_ag_metric, CATBOOST_EVAL_METRIC_TO_LOSS_FUNCTION
+from .catboost_utils import CATBOOST_EVAL_METRIC_TO_LOSS_FUNCTION, get_catboost_metric_from_ag_metric
 from .hyperparameters.parameters import get_param_baseline
 from .hyperparameters.searchspaces import get_default_searchspace
 
@@ -33,12 +33,11 @@ class CatBoostModel(AbstractModel):
 
     Hyperparameter options: https://catboost.ai/en/docs/references/training-parameters
     """
+
     ag_key = "CAT"
     ag_name = "CatBoost"
     ag_priority = 70
-    ag_priority_by_problem_type = MappingProxyType({
-        SOFTCLASS: 60
-    })
+    ag_priority_by_problem_type = MappingProxyType({SOFTCLASS: 60})
     seed_name = "random_seed"
 
     def __init__(self, **kwargs):
@@ -50,16 +49,24 @@ class CatBoostModel(AbstractModel):
         for param, val in default_params.items():
             self._set_default_param_value(param, val)
         # Set 'allow_writing_files' to True in order to keep log files created by catboost during training (these will be saved in the directory where AutoGluon stores this model)
-        self._set_default_param_value("allow_writing_files", False)  # Disables creation of catboost logging files during training by default
+        self._set_default_param_value(
+            "allow_writing_files", False
+        )  # Disables creation of catboost logging files during training by default
         if self.problem_type != SOFTCLASS:  # TODO: remove this after catboost 0.24
-            default_eval_metric = get_catboost_metric_from_ag_metric(self.stopping_metric, self.problem_type, self.quantile_levels)
+            default_eval_metric = get_catboost_metric_from_ag_metric(
+                self.stopping_metric, self.problem_type, self.quantile_levels
+            )
             self._set_default_param_value("eval_metric", default_eval_metric)
 
     def _get_default_searchspace(self):
         return get_default_searchspace(self.problem_type, num_classes=self.num_classes)
 
-    def _preprocess_nonadaptive(self, X, **kwargs):
-        X = super()._preprocess_nonadaptive(X, **kwargs)
+    def _preprocess(self, X, **kwargs):
+        # Note: while this is nonadaptive preprocessing, we made it stateful because it
+        # contains the logic for nan handling and nans can be created after
+        # nonadaptive preprocessing by model-specific preprocessing.
+        # Moreover, now CatBoost handles nan like most other models in `_preprocess`.
+        X = super()._preprocess(X, **kwargs)
         if self._category_features is None:
             self._category_features = list(X.select_dtypes(include="category").columns)
         if self._category_features:
@@ -74,7 +81,13 @@ class CatBoostModel(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(
@@ -97,16 +110,20 @@ class CatBoostModel(AbstractModel):
         """
         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 * 5 + data_mem_usage / 4 * num_classes  # TODO: Extremely crude approximation, can be vastly improved
+        data_mem_usage_bytes = (
+            data_mem_usage * 5 + data_mem_usage / 4 * num_classes
+        )  # TODO: Extremely crude approximation, can be vastly improved
 
         border_count = hyperparameters.get("border_count", 254)
         depth = hyperparameters.get("depth", 6)
 
         # if depth < 7, treat it as 1 step larger for histogram size estimate
         #  this fixes cases where otherwise histogram size appears to be off by around a factor of 2 for depth=6
-        histogram_effective_depth = max(min(depth+1, 7), depth)
+        histogram_effective_depth = max(min(depth + 1, 7), depth)
 
         # Formula based on manual testing, aligns with LightGBM histogram sizes
         histogram_mem_usage_bytes = 24 * math.pow(2, histogram_effective_depth) * len(X.columns) * border_count
@@ -119,7 +136,19 @@ class CatBoostModel(AbstractModel):
 
     # TODO: Use Pool in preprocess, optimize bagging to do Pool.split() to avoid re-computing pool for each fold! Requires stateful + y
     #  Pool is much more memory efficient, avoids copying data twice in memory
-    def _fit(self, X, y, X_val=None, y_val=None, time_limit=None, num_gpus=0, num_cpus=-1, sample_weight=None, sample_weight_val=None, **kwargs):
+    def _fit(
+        self,
+        X,
+        y,
+        X_val=None,
+        y_val=None,
+        time_limit=None,
+        num_gpus=0,
+        num_cpus=-1,
+        sample_weight=None,
+        sample_weight_val=None,
+        **kwargs,
+    ):
         time_start = time.time()
         try_import_catboost()
         from catboost import CatBoostClassifier, CatBoostRegressor, Pool
@@ -132,19 +161,21 @@ class CatBoostModel(AbstractModel):
             # FIXME: This is extremely slow due to unoptimized metric / objective sent to CatBoost
             from .catboost_softclass_utils import SoftclassCustomMetric, SoftclassObjective
 
-            params.setdefault("loss_function",  SoftclassObjective.SoftLogLossObjective())
+            params.setdefault("loss_function", SoftclassObjective.SoftLogLossObjective())
             params["eval_metric"] = SoftclassCustomMetric.SoftLogLossMetric()
         elif self.problem_type in [REGRESSION, QUANTILE]:
             # Choose appropriate loss_function that is as close as possible to the eval_metric
             params.setdefault(
                 "loss_function",
-                CATBOOST_EVAL_METRIC_TO_LOSS_FUNCTION.get(params["eval_metric"], params["eval_metric"])
+                CATBOOST_EVAL_METRIC_TO_LOSS_FUNCTION.get(params["eval_metric"], params["eval_metric"]),
             )
 
         model_type = CatBoostClassifier if self.problem_type in PROBLEM_TYPES_CLASSIFICATION else CatBoostRegressor
         num_rows_train = len(X)
         num_cols_train = len(X.columns)
-        num_classes = self.num_classes if self.num_classes else 1  # self.num_classes could be None after initialization if it's a regression problem
+        num_classes = (
+            self.num_classes if self.num_classes else 1
+        )  # self.num_classes could be None after initialization if it's a regression problem
 
         X = self.preprocess(X, y=y, is_train=True)
         cat_features = list(X.select_dtypes(include="category").columns)
@@ -159,7 +190,9 @@ class CatBoostModel(AbstractModel):
             eval_set = X_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 params.get("allow_writing_files", False):
             if "train_dir" not in params:
@@ -187,7 +220,10 @@ class CatBoostModel(AbstractModel):
         if num_gpus != 0:
             if "task_type" not in params:
                 params["task_type"] = "GPU"
-                logger.log(20, f"\tTraining {self.name} with GPU, note that this may negatively impact model quality compared to CPU training.")
+                logger.log(
+                    20,
+                    f"\tTraining {self.name} with GPU, note that this may negatively impact model quality compared to CPU training.",
+                )
                 # TODO: Confirm if GPU is used in HPO (Probably not)
                 # TODO: Adjust max_bins to 254?
 
@@ -199,15 +235,23 @@ class CatBoostModel(AbstractModel):
                 params.pop("rsm")
                 logger.log(30, f"\t'rsm' is not supported on GPU, using default value (Default = 1).")
 
-        if self.problem_type == MULTICLASS and "rsm" not in params and "colsample_bylevel" not in params and num_features > 1000:
+        if (
+            self.problem_type == MULTICLASS
+            and "rsm" not in params
+            and "colsample_bylevel" not in params
+            and num_features > 1000
+        ):
             # Subsample columns to speed up training
             if params.get("task_type", None) != "GPU":  # RSM does not work on GPU
                 params["colsample_bylevel"] = max(min(1.0, 1000 / num_features), 0.05)
                 logger.log(
                     30,
-                    f'\tMany features detected ({num_features}), dynamically setting \'colsample_bylevel\' to {params["colsample_bylevel"]} to speed up training (Default = 1).',
+                    f"\tMany features detected ({num_features}), dynamically setting 'colsample_bylevel' to {params['colsample_bylevel']} to speed up training (Default = 1).",
+                )
+                logger.log(
+                    30,
+                    f"\tTo disable this functionality, explicitly specify 'colsample_bylevel' in the model hyperparameters.",
                 )
-                logger.log(30, f"\tTo disable this functionality, explicitly specify 'colsample_bylevel' in the model hyperparameters.")
             else:
                 params["colsample_bylevel"] = 1.0
                 logger.log(30, f"\t'colsample_bylevel' is not supported on GPU, using default value (Default = 1).")
@@ -218,7 +262,9 @@ class CatBoostModel(AbstractModel):
         if params.get("task_type", None) != "GPU":
             callbacks = []
             if early_stopping_rounds is not None:
-                callbacks.append(EarlyStoppingCallback(stopping_rounds=early_stopping_rounds, eval_metric=params["eval_metric"]))
+                callbacks.append(
+                    EarlyStoppingCallback(stopping_rounds=early_stopping_rounds, eval_metric=params["eval_metric"])
+                )
 
             if num_rows_train * num_cols_train * num_classes > 5_000_000:
                 # The data is large enough to potentially cause memory issues during training, so monitor memory usage via callback.
@@ -226,12 +272,17 @@ class CatBoostModel(AbstractModel):
             if time_limit is not None:
                 time_cur = time.time()
                 time_left = time_limit - (time_cur - time_start)
-                if time_left <= time_limit * 0.4:  # if 60% of time was spent preprocessing, likely not enough time to train model
+                if (
+                    time_left <= time_limit * 0.4
+                ):  # if 60% of time was spent preprocessing, likely not enough time to train model
                     raise TimeLimitExceeded
                 callbacks.append(TimeCheckCallback(time_start=time_cur, time_limit=time_left))
             extra_fit_kwargs["callbacks"] = callbacks
         else:
-            logger.log(30, f"\tWarning: CatBoost on GPU is experimental. If you encounter issues, use CPU for training CatBoost instead.")
+            logger.log(
+                30,
+                f"\tWarning: CatBoost on GPU is experimental. If you encounter issues, use CPU for training CatBoost instead.",
+            )
             if time_limit is not None:
                 params["iterations"] = self._estimate_iter_in_time_gpu(
                     X=X,
@@ -272,7 +323,9 @@ class CatBoostModel(AbstractModel):
     #  This method will train a model on a toy number of iterations to estimate memory and training time.
     #  It will return an updated iterations to train on that will avoid running OOM and running over time limit.
     #  Remove this logic once CatBoost fixes GPU support for callbacks and custom metrics.
-    def _estimate_iter_in_time_gpu(self, *, X, eval_set, time_limit, verbose, params, num_rows_train, time_start, model_type):
+    def _estimate_iter_in_time_gpu(
+        self, *, X, eval_set, time_limit, verbose, params, num_rows_train, time_start, model_type
+    ):
         import math
         import pickle
         import sys
@@ -280,7 +333,9 @@ class CatBoostModel(AbstractModel):
         modifier = min(1.0, 10000 / num_rows_train)
         num_sample_iter_max = max(round(modifier * 50), 2)
         time_left_start = time_limit - (time.time() - time_start)
-        if time_left_start <= time_limit * 0.4:  # if 60% of time was spent preprocessing, likely not enough time to train model
+        if (
+            time_left_start <= time_limit * 0.4
+        ):  # if 60% of time was spent preprocessing, likely not enough time to train model
             raise TimeLimitExceeded
         default_iters = params["iterations"]
         params_init = params.copy()
@@ -341,9 +396,18 @@ class CatBoostModel(AbstractModel):
     def _ag_params(self) -> set:
         return {"early_stop"}
 
-    def _validate_fit_memory_usage(self, mem_error_threshold: float = 1, mem_warning_threshold: float = 0.75, mem_size_threshold: int = 1e9, **kwargs):
+    def _validate_fit_memory_usage(
+        self,
+        mem_error_threshold: float = 1,
+        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/catboost/catboost_softclass_utils.py

@@ -72,5 +72,8 @@ class SoftclassObjective(object):
                 exp_sum += x
             exp_approx = [val / exp_sum for val in exp_approx]
             grad = [(targets[j] - exp_approx[j]) * weight for j in range(len(targets))]
-            hess = [[(exp_approx[j] * exp_approx[j2] - (j == j2) * exp_approx[j]) * weight for j in range(len(targets))] for j2 in range(len(targets))]
+            hess = [
+                [(exp_approx[j] * exp_approx[j2] - (j == j2) * exp_approx[j]) * weight for j in range(len(targets))]
+                for j2 in range(len(targets))
+            ]
             return (grad, hess)

autogluon/tabular/models/catboost/catboost_utils.py

@@ -83,7 +83,9 @@ def get_catboost_metric_from_ag_metric(metric, problem_type, quantile_levels=Non
         if quantile_levels is None:
             raise AssertionError(f"quantile_levels must be provided for problem_type = {problem_type}")
         if not all(0 < q < 1 for q in quantile_levels):
-            raise AssertionError(f"quantile_levels must fulfill 0 < q < 1, provided quantile_levels: {quantile_levels}")
+            raise AssertionError(
+                f"quantile_levels must fulfill 0 < q < 1, provided quantile_levels: {quantile_levels}"
+            )
         # Loss function MultiQuantile: can only be used if len(quantile_levels) >= 2, otherwise we must use Quantile:
         if len(quantile_levels) == 1:
             metric_class = f"{CATBOOST_QUANTILE_PREFIX}alpha={quantile_levels[0]}"

autogluon/tabular/models/ebm/ebm_model.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
+
 from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION
 from autogluon.core.models import AbstractModel
 
@@ -38,14 +39,14 @@ class EBMModel(AbstractModel):
     black-box models on a wide range of tabular datasets.
 
     Requires the 'interpret' or 'interpret-core' package. Install via:
-    
+
     pip install interpret
 
 
     Paper: InterpretML: A Unified Framework for Machine Learning Interpretability
-    
+
     Authors: H. Nori, S. Jenkins, P. Koch, and R. Caruana 2019
-    
+
     Codebase: https://github.com/interpretml/interpret
 
     License: MIT
@@ -57,7 +58,7 @@ class EBMModel(AbstractModel):
     ag_name = "EBM"
     ag_priority = 35
     seed_name = "random_state"
-    
+
     def _fit(
         self,
         X: pd.DataFrame,
@@ -175,15 +176,11 @@ class EBMModel(AbstractModel):
         baseline_memory_bytes = 400_000_000  # 400 MB baseline memory
 
         # assuming we call pd.concat([X, X_val], ignore_index=True), then X size will be doubled
-        return baseline_memory_bytes + model_cls(**params).estimate_mem(
-            X, y, data_multiplier=2.0
-        )
+        return baseline_memory_bytes + model_cls(**params).estimate_mem(X, y, data_multiplier=2.0)
 
     def _validate_fit_memory_usage(self, mem_error_threshold: float = 1, **kwargs):
         # Given the good mem estimates with overhead, we set the threshold to 1.
-        return super()._validate_fit_memory_usage(
-            mem_error_threshold=mem_error_threshold, **kwargs
-        )
+        return super()._validate_fit_memory_usage(mem_error_threshold=mem_error_threshold, **kwargs)
 
 
 def construct_ebm_params(
@@ -223,9 +220,7 @@ def construct_ebm_params(
         "feature_types": feature_types,
     }
     if stopping_metric is not None:
-        params["objective"] = get_metric_from_ag_metric(
-            metric=stopping_metric, problem_type=problem_type
-        )
+        params["objective"] = get_metric_from_ag_metric(metric=stopping_metric, problem_type=problem_type)
     if time_limit is not None:
         params["callback"] = EbmCallback(time_limit)
 

autogluon/tabular/models/ebm/hyperparameters/parameters.py

@@ -1,5 +1,6 @@
 from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION, SOFTCLASS
 
+
 def get_param_baseline(problem_type, num_classes=None):
     if problem_type == BINARY:
         return get_param_binary_baseline()

autogluon/tabular/models/ebm/hyperparameters/searchspaces.py

@@ -3,6 +3,7 @@
 from autogluon.common import space
 from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION
 
+
 def get_default_searchspace(problem_type, num_classes=None):
     if problem_type == BINARY:
         return get_searchspace_binary_baseline()

autogluon/tabular/models/fastainn/callbacks.py

@@ -34,7 +34,16 @@ class BatchTimeTracker(Callback):
 
 
 class EarlyStoppingCallbackWithTimeLimit(TrackerCallback):
-    def __init__(self, monitor="valid_loss", comp=None, min_delta=0.0, patience=1, reset_on_fit=True, time_limit=None, best_epoch_stop=None):
+    def __init__(
+        self,
+        monitor="valid_loss",
+        comp=None,
+        min_delta=0.0,
+        patience=1,
+        reset_on_fit=True,
+        time_limit=None,
+        best_epoch_stop=None,
+    ):
         super().__init__(monitor=monitor, comp=comp, min_delta=min_delta, reset_on_fit=reset_on_fit)
         self.patience = patience
         self.time_limit = time_limit
@@ -84,7 +93,15 @@ class AgSaveModelCallback(TrackerCallback):
     _only_train_loop = True
 
     def __init__(
-        self, monitor="valid_loss", comp=None, min_delta=0.0, fname="model", every_epoch=False, with_opt=False, reset_on_fit=True, best_epoch_stop=None
+        self,
+        monitor="valid_loss",
+        comp=None,
+        min_delta=0.0,
+        fname="model",
+        every_epoch=False,
+        with_opt=False,
+        reset_on_fit=True,
+        best_epoch_stop=None,
     ):
         super().__init__(monitor=monitor, comp=comp, min_delta=min_delta, reset_on_fit=reset_on_fit)
         # keep track of file path for loggers
@@ -113,4 +130,4 @@ class AgSaveModelCallback(TrackerCallback):
 
     def after_fit(self, **kwargs):
         if not self.every_epoch:
-            self.learn.load(f"{self.fname}", with_opt=self.with_opt, weights_only=False)   # nosec B614
+            self.learn.load(f"{self.fname}", with_opt=self.with_opt, weights_only=False)  # nosec B614

autogluon/tabular/models/fastainn/hyperparameters/searchspaces.py

@@ -19,7 +19,17 @@ def get_searchspace_binary():
     spaces = {
         # See docs: https://docs.fast.ai/tabular.learner.html
         "layers": space.Categorical(
-            None, [200, 100], [200], [500], [1000], [500, 200], [50, 25], [1000, 500], [200, 100, 50], [500, 200, 100], [1000, 500, 200]
+            None,
+            [200, 100],
+            [200],
+            [500],
+            [1000],
+            [500, 200],
+            [50, 25],
+            [1000, 500],
+            [200, 100, 50],
+            [500, 200, 100],
+            [1000, 500, 200],
         ),
         "emb_drop": space.Real(0.0, 0.5, default=0.1),
         "ps": space.Real(0.0, 0.5, default=0.1),

autogluon/tabular/models/fastainn/quantile_helpers.py

@@ -37,9 +37,17 @@ class HuberPinballLoss(nn.Module):
         if self.alpha == 0.0:
             loss_data = torch.max(self.quantile_levels * error_data, (self.quantile_levels - 1) * error_data)
         else:
-            loss_data = torch.where(torch.abs(error_data) < self.alpha, 0.5 * error_data * error_data, self.alpha * (torch.abs(error_data) - 0.5 * self.alpha))
+            loss_data = torch.where(
+                torch.abs(error_data) < self.alpha,
+                0.5 * error_data * error_data,
+                self.alpha * (torch.abs(error_data) - 0.5 * self.alpha),
+            )
             loss_data = loss_data / self.alpha
 
-            scale = torch.where(error_data >= 0, torch.ones_like(error_data) * self.quantile_levels, torch.ones_like(error_data) * (1 - self.quantile_levels))
+            scale = torch.where(
+                error_data >= 0,
+                torch.ones_like(error_data) * self.quantile_levels,
+                torch.ones_like(error_data) * (1 - self.quantile_levels),
+            )
             loss_data *= scale
         return loss_data.mean()