autogluon.tabular 1.3.2b20250610__py3-none-any.whl → 1.4.1b20251214__py3-none-any.whl

autogluon/tabular/configs/zeroshot/zeroshot_portfolio_2025.py

@@ -0,0 +1,310 @@
+# optimized for <=10000 samples and <=500 features, with a GPU present
+hyperparameter_portfolio_zeroshot_2025_small = {
+    "TABPFNV2": [
+        {
+            "ag_args": {'name_suffix': '_r143', 'priority': -1},
+            "average_before_softmax": False,
+            "classification_model_path": 'tabpfn-v2-classifier-od3j1g5m.ckpt',
+            "inference_config/FINGERPRINT_FEATURE": False,
+            "inference_config/OUTLIER_REMOVAL_STD": None,
+            "inference_config/POLYNOMIAL_FEATURES": 'no',
+            "inference_config/PREPROCESS_TRANSFORMS": [{'append_original': True, 'categorical_name': 'ordinal_very_common_categories_shuffled', 'global_transformer_name': None, 'name': 'safepower', 'subsample_features': -1}, {'append_original': True, 'categorical_name': 'ordinal_very_common_categories_shuffled', 'global_transformer_name': None, 'name': 'quantile_uni', 'subsample_features': -1}],
+            "inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS": [None, 'power'],
+            "inference_config/SUBSAMPLE_SAMPLES": 0.99,
+            "model_type": 'single',
+            "n_ensemble_repeats": 4,
+            "regression_model_path": 'tabpfn-v2-regressor-wyl4o83o.ckpt',
+            "softmax_temperature": 0.75,
+        },
+        {
+            "ag_args": {'name_suffix': '_r94', 'priority': -3},
+            "average_before_softmax": True,
+            "classification_model_path": 'tabpfn-v2-classifier-vutqq28w.ckpt',
+            "inference_config/FINGERPRINT_FEATURE": True,
+            "inference_config/OUTLIER_REMOVAL_STD": None,
+            "inference_config/POLYNOMIAL_FEATURES": 'no',
+            "inference_config/PREPROCESS_TRANSFORMS": [{'append_original': True, 'categorical_name': 'ordinal_very_common_categories_shuffled', 'global_transformer_name': None, 'name': 'quantile_uni', 'subsample_features': 0.99}],
+            "inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS": [None],
+            "inference_config/SUBSAMPLE_SAMPLES": None,
+            "model_type": 'single',
+            "n_ensemble_repeats": 4,
+            "regression_model_path": 'tabpfn-v2-regressor-5wof9ojf.ckpt',
+            "softmax_temperature": 0.9,
+        },
+        {
+            "ag_args": {'name_suffix': '_r181', 'priority': -4},
+            "average_before_softmax": False,
+            "classification_model_path": 'tabpfn-v2-classifier-llderlii.ckpt',
+            "inference_config/FINGERPRINT_FEATURE": False,
+            "inference_config/OUTLIER_REMOVAL_STD": 9.0,
+            "inference_config/POLYNOMIAL_FEATURES": 50,
+            "inference_config/PREPROCESS_TRANSFORMS": [{'append_original': True, 'categorical_name': 'onehot', 'global_transformer_name': 'svd', 'name': 'quantile_uni_coarse', 'subsample_features': 0.99}],
+            "inference_config/REGRESSION_Y_PREPROCESS_TRANSFORMS": ['power'],
+            "inference_config/SUBSAMPLE_SAMPLES": None,
+            "model_type": 'single',
+            "n_ensemble_repeats": 4,
+            "regression_model_path": 'tabpfn-v2-regressor.ckpt',
+            "softmax_temperature": 0.95,
+        },
+    ],
+    "GBM": [
+        {
+            "ag_args": {'name_suffix': '_r33', 'priority': -2},
+            "bagging_fraction": 0.9625293420216,
+            "bagging_freq": 1,
+            "cat_l2": 0.1236875455555,
+            "cat_smooth": 68.8584757332856,
+            "extra_trees": False,
+            "feature_fraction": 0.6189215809382,
+            "lambda_l1": 0.1641757352921,
+            "lambda_l2": 0.6937755557881,
+            "learning_rate": 0.0154031028561,
+            "max_cat_to_onehot": 17,
+            "min_data_in_leaf": 1,
+            "min_data_per_group": 30,
+            "num_leaves": 68,
+        },
+        {
+            "ag_args": {'name_suffix': '_r21', 'priority': -16},
+            "bagging_fraction": 0.7218730663234,
+            "bagging_freq": 1,
+            "cat_l2": 0.0296205152578,
+            "cat_smooth": 0.0010255271303,
+            "extra_trees": False,
+            "feature_fraction": 0.4557131604374,
+            "lambda_l1": 0.5219704038237,
+            "lambda_l2": 0.1070959487853,
+            "learning_rate": 0.0055891584996,
+            "max_cat_to_onehot": 71,
+            "min_data_in_leaf": 50,
+            "min_data_per_group": 10,
+            "num_leaves": 30,
+        },
+        {
+            "ag_args": {'name_suffix': '_r11', 'priority': -19},
+            "bagging_fraction": 0.775784726514,
+            "bagging_freq": 1,
+            "cat_l2": 0.3888471449178,
+            "cat_smooth": 0.0057144748021,
+            "extra_trees": True,
+            "feature_fraction": 0.7732354787904,
+            "lambda_l1": 0.2211002452568,
+            "lambda_l2": 1.1318405980187,
+            "learning_rate": 0.0090151778542,
+            "max_cat_to_onehot": 15,
+            "min_data_in_leaf": 4,
+            "min_data_per_group": 15,
+            "num_leaves": 2,
+        },
+    ],
+    "CAT": [
+        {
+            "ag_args": {'priority': -5},
+        },
+        {
+            "ag_args": {'name_suffix': '_r51', 'priority': -10},
+            "boosting_type": 'Plain',
+            "bootstrap_type": 'Bernoulli',
+            "colsample_bylevel": 0.8771035272558,
+            "depth": 7,
+            "grow_policy": 'SymmetricTree',
+            "l2_leaf_reg": 2.0107286863021,
+            "leaf_estimation_iterations": 2,
+            "learning_rate": 0.0058424016622,
+            "max_bin": 254,
+            "max_ctr_complexity": 4,
+            "model_size_reg": 0.1307400355809,
+            "one_hot_max_size": 23,
+            "subsample": 0.809527841437,
+        },
+        {
+            "ag_args": {'name_suffix': '_r10', 'priority': -12},
+            "boosting_type": 'Plain',
+            "bootstrap_type": 'Bernoulli',
+            "colsample_bylevel": 0.8994502668431,
+            "depth": 6,
+            "grow_policy": 'Depthwise',
+            "l2_leaf_reg": 1.8187025215896,
+            "leaf_estimation_iterations": 7,
+            "learning_rate": 0.005177304142,
+            "max_bin": 254,
+            "max_ctr_complexity": 4,
+            "model_size_reg": 0.5247386875068,
+            "one_hot_max_size": 53,
+            "subsample": 0.8705228845742,
+        },
+        {
+            "ag_args": {'name_suffix': '_r24', 'priority': -15},
+            "boosting_type": 'Plain',
+            "bootstrap_type": 'Bernoulli',
+            "colsample_bylevel": 0.8597809376276,
+            "depth": 8,
+            "grow_policy": 'Depthwise',
+            "l2_leaf_reg": 0.3628261923976,
+            "leaf_estimation_iterations": 5,
+            "learning_rate": 0.016851077771,
+            "max_bin": 254,
+            "max_ctr_complexity": 4,
+            "model_size_reg": 0.1253820547902,
+            "one_hot_max_size": 20,
+            "subsample": 0.8120271122061,
+        },
+        {
+            "ag_args": {'name_suffix': '_r91', 'priority': -17},
+            "boosting_type": 'Plain',
+            "bootstrap_type": 'Bernoulli',
+            "colsample_bylevel": 0.8959275863514,
+            "depth": 4,
+            "grow_policy": 'SymmetricTree',
+            "l2_leaf_reg": 0.0026915894253,
+            "leaf_estimation_iterations": 12,
+            "learning_rate": 0.0475233791203,
+            "max_bin": 254,
+            "max_ctr_complexity": 5,
+            "model_size_reg": 0.1633175256924,
+            "one_hot_max_size": 11,
+            "subsample": 0.798554178926,
+        },
+    ],
+    "TABM": [
+        {
+            "ag_args": {'name_suffix': '_r184', 'priority': -6},
+            "amp": False,
+            "arch_type": 'tabm-mini',
+            "batch_size": 'auto',
+            "d_block": 864,
+            "d_embedding": 24,
+            "dropout": 0.0,
+            "gradient_clipping_norm": 1.0,
+            "lr": 0.0019256819924656217,
+            "n_blocks": 3,
+            "num_emb_n_bins": 3,
+            "num_emb_type": 'pwl',
+            "patience": 16,
+            "share_training_batches": False,
+            "tabm_k": 32,
+            "weight_decay": 0.0,
+        },
+        {
+            "ag_args": {'name_suffix': '_r69', 'priority': -7},
+            "amp": False,
+            "arch_type": 'tabm-mini',
+            "batch_size": 'auto',
+            "d_block": 848,
+            "d_embedding": 28,
+            "dropout": 0.40215621636031007,
+            "gradient_clipping_norm": 1.0,
+            "lr": 0.0010413640454559532,
+            "n_blocks": 3,
+            "num_emb_n_bins": 18,
+            "num_emb_type": 'pwl',
+            "patience": 16,
+            "share_training_batches": False,
+            "tabm_k": 32,
+            "weight_decay": 0.0,
+        },
+        {
+            "ag_args": {'name_suffix': '_r52', 'priority': -11},
+            "amp": False,
+            "arch_type": 'tabm-mini',
+            "batch_size": 'auto',
+            "d_block": 1024,
+            "d_embedding": 32,
+            "dropout": 0.0,
+            "gradient_clipping_norm": 1.0,
+            "lr": 0.0006297851297842611,
+            "n_blocks": 4,
+            "num_emb_n_bins": 22,
+            "num_emb_type": 'pwl',
+            "patience": 16,
+            "share_training_batches": False,
+            "tabm_k": 32,
+            "weight_decay": 0.06900108498839816,
+        },
+        {
+            "ag_args": {'priority': -13},
+        },
+        {
+            "ag_args": {'name_suffix': '_r191', 'priority': -14},
+            "amp": False,
+            "arch_type": 'tabm-mini',
+            "batch_size": 'auto',
+            "d_block": 864,
+            "d_embedding": 8,
+            "dropout": 0.45321529282058803,
+            "gradient_clipping_norm": 1.0,
+            "lr": 0.0003781238075322413,
+            "n_blocks": 4,
+            "num_emb_n_bins": 27,
+            "num_emb_type": 'pwl',
+            "patience": 16,
+            "share_training_batches": False,
+            "tabm_k": 32,
+            "weight_decay": 0.01766851962579851,
+        },
+        {
+            "ag_args": {'name_suffix': '_r49', 'priority': -20},
+            "amp": False,
+            "arch_type": 'tabm-mini',
+            "batch_size": 'auto',
+            "d_block": 640,
+            "d_embedding": 28,
+            "dropout": 0.15296207419190627,
+            "gradient_clipping_norm": 1.0,
+            "lr": 0.002277678490593717,
+            "n_blocks": 3,
+            "num_emb_n_bins": 48,
+            "num_emb_type": 'pwl',
+            "patience": 16,
+            "share_training_batches": False,
+            "tabm_k": 32,
+            "weight_decay": 0.0578159148243893,
+        },
+    ],
+    "TABICL": [
+        {
+            "ag_args": {'priority': -8},
+        },
+    ],
+    "XGB": [
+        {
+            "ag_args": {'name_suffix': '_r171', 'priority': -9},
+            "colsample_bylevel": 0.9213705632288,
+            "colsample_bynode": 0.6443385965381,
+            "enable_categorical": True,
+            "grow_policy": 'lossguide',
+            "learning_rate": 0.0068171645251,
+            "max_cat_to_onehot": 8,
+            "max_depth": 6,
+            "max_leaves": 10,
+            "min_child_weight": 0.0507304250576,
+            "reg_alpha": 4.2446346389037,
+            "reg_lambda": 1.4800570021253,
+            "subsample": 0.9656290596647,
+        },
+        {
+            "ag_args": {'name_suffix': '_r40', 'priority': -18},
+            "colsample_bylevel": 0.6377491713202,
+            "colsample_bynode": 0.9237625621103,
+            "enable_categorical": True,
+            "grow_policy": 'lossguide',
+            "learning_rate": 0.0112462621131,
+            "max_cat_to_onehot": 33,
+            "max_depth": 10,
+            "max_leaves": 35,
+            "min_child_weight": 0.1403464856034,
+            "reg_alpha": 3.4960653958503,
+            "reg_lambda": 1.3062320805235,
+            "subsample": 0.6948898835178,
+        },
+    ],
+    "MITRA": [
+        {
+            "n_estimators": 1,
+            "fine_tune": True,
+            "fine_tune_steps": 50,
+            "ag.num_gpus": 1,
+            "ag_args": {'priority': -21},
+        },
+    ],
+}

autogluon/tabular/models/__init__.py

@@ -3,6 +3,7 @@ from autogluon.core.models.abstract.abstract_model import AbstractModel
 from .automm.automm_model import MultiModalPredictorModel
 from .automm.ft_transformer import FTTransformerModel
 from .catboost.catboost_model import CatBoostModel
+from .ebm.ebm_model import EBMModel
 from .fastainn.tabular_nn_fastai import NNFastAiTabularModel
 from .fasttext.fasttext_model import FastTextModel
 from .image_prediction.image_predictor import ImagePredictorModel
@@ -17,9 +18,13 @@ from .imodels.imodels_models import (
 from .knn.knn_model import KNNModel
 from .lgb.lgb_model import LGBModel
 from .lr.lr_model import LinearModel
+from .realmlp.realmlp_model import RealMLPModel
 from .rf.rf_model import RFModel
-from .tabpfn.tabpfn_model import TabPFNModel
+from .tabicl.tabicl_model import TabICLModel
+from .tabm.tabm_model import TabMModel
+from .tabpfnv2.tabpfnv2_model import TabPFNV2Model
 from .tabpfnmix.tabpfnmix_model import TabPFNMixModel
+from .mitra.mitra_model import MitraModel
 from .tabular_nn.torch.tabular_nn_torch import TabularNeuralNetTorchModel
 from .text_prediction.text_prediction_v1_model import TextPredictorModel
 from .xgboost.xgboost_model import XGBoostModel

autogluon/tabular/models/_utils/rapids_utils.py

@@ -10,7 +10,7 @@ class RapidsModelMixin:
     @classmethod
     def _get_default_ag_args_ensemble(cls, **kwargs) -> dict:
         default_ag_args_ensemble = super()._get_default_ag_args_ensemble(**kwargs)
-        extra_ag_args_ensemble = {"use_child_oof": False}
+        extra_ag_args_ensemble = {"use_child_oof": False, "fold_fitting_strategy": "sequential_local"}
         default_ag_args_ensemble.update(extra_ag_args_ensemble)
         return default_ag_args_ensemble
 

autogluon/tabular/models/automm/automm_model.py

@@ -65,6 +65,8 @@ class MultiModalPredictorModel(AbstractModel):
             Names of the features.
         feature_metadata
             The feature metadata.
+
+        .. versionadded:: 0.3.0
         """
         super().__init__(**kwargs)
         self._label_column_name = None

autogluon/tabular/models/automm/ft_transformer.py

@@ -17,7 +17,8 @@ class FTTransformerModel(MultiModalPredictorModel):
     ag_name = "FTTransformer"
 
     def __init__(self, **kwargs):
-        """Wrapper of autogluon.multimodal.MultiModalPredictor.
+        """
+        FT-Transformer model.
 
         The features can be a mix of
         - categorical column
@@ -48,6 +49,8 @@ class FTTransformerModel(MultiModalPredictorModel):
             Names of the features.
         feature_metadata
             The feature metadata.
+
+        .. versionadded:: 0.6.0
         """
         super().__init__(**kwargs)
 

autogluon/tabular/models/catboost/callbacks.py

@@ -170,14 +170,15 @@ class EarlyStoppingCallback:
 
         self.eval_metric_name = eval_metric_name
         self.is_max_optimal = is_max_optimal
-        self.is_quantile = self.eval_metric_name.startswith(CATBOOST_QUANTILE_PREFIX)
+        self.is_quantile = CATBOOST_QUANTILE_PREFIX in self.eval_metric_name
 
     def after_iteration(self, info):
         is_best_iter = False
         if self.is_quantile:
             # FIXME: CatBoost adds extra ',' in the metric name if quantile levels are not balanced
             # e.g., 'MultiQuantile:alpha=0.1,0.25,0.5,0.95' becomes 'MultiQuantile:alpha=0.1,,0.25,0.5,0.95'
-            eval_metric_name = [k for k in info.metrics[self.compare_key] if k.startswith(CATBOOST_QUANTILE_PREFIX)][0]
+            # `'Quantile:' in k` catches both multiquantile (MultiQuantile:) and single-quantile mode (Quantile:)
+            eval_metric_name = [k for k in info.metrics[self.compare_key] if CATBOOST_QUANTILE_PREFIX in k][0]
         else:
             eval_metric_name = self.eval_metric_name
         cur_score = info.metrics[self.compare_key][eval_metric_name][-1]

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, QUANTILE, SOFTCLASS
+from autogluon.core.constants import MULTICLASS, PROBLEM_TYPES_CLASSIFICATION, REGRESSION, QUANTILE, 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
+from .catboost_utils import get_catboost_metric_from_ag_metric, CATBOOST_EVAL_METRIC_TO_LOSS_FUNCTION
 from .hyperparameters.parameters import get_param_baseline
 from .hyperparameters.searchspaces import get_default_searchspace
 
@@ -39,6 +39,7 @@ class CatBoostModel(AbstractModel):
     ag_priority_by_problem_type = MappingProxyType({
         SOFTCLASS: 60
     })
+    seed_name = "random_seed"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -48,7 +49,6 @@ class CatBoostModel(AbstractModel):
         default_params = get_param_baseline(problem_type=self.problem_type)
         for param, val in default_params.items():
             self._set_default_param_value(param, val)
-        self._set_default_param_value("random_seed", 0)  # Remove randomness for reproducibility
         # 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
         if self.problem_type != SOFTCLASS:  # TODO: remove this after catboost 0.24
@@ -126,16 +126,20 @@ class CatBoostModel(AbstractModel):
 
         ag_params = self._get_ag_params()
         params = self._get_model_params()
+
         params["thread_count"] = num_cpus
         if self.problem_type == SOFTCLASS:
             # FIXME: This is extremely slow due to unoptimized metric / objective sent to CatBoost
             from .catboost_softclass_utils import SoftclassCustomMetric, SoftclassObjective
 
-            params["loss_function"] = SoftclassObjective.SoftLogLossObjective()
+            params.setdefault("loss_function",  SoftclassObjective.SoftLogLossObjective())
             params["eval_metric"] = SoftclassCustomMetric.SoftLogLossMetric()
-        elif self.problem_type == QUANTILE:
-            # FIXME: Unless specified, CatBoost defaults to loss_function='MultiQuantile' and raises an exception
-            params["loss_function"] = params["eval_metric"]
+        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"])
+            )
 
         model_type = CatBoostClassifier if self.problem_type in PROBLEM_TYPES_CLASSIFICATION else CatBoostRegressor
         num_rows_train = len(X)
@@ -307,6 +311,8 @@ class CatBoostModel(AbstractModel):
         max_memory_iters = math.floor(available_mem * max_memory_proportion / mem_usage_per_iter)
 
         final_iters = min(default_iters, min(max_memory_iters, estimated_iters_in_time))
+        if final_iters < 1:
+            raise TimeLimitExceeded
         return final_iters
 
     def _predict_proba(self, X, **kwargs):
@@ -350,8 +356,8 @@ class CatBoostModel(AbstractModel):
         return minimum_resources
 
     def _get_default_resources(self):
-        # logical=False is faster in training
-        num_cpus = ResourceManager.get_cpu_count_psutil(logical=False)
+        # only_physical_cores=True is faster in training
+        num_cpus = ResourceManager.get_cpu_count(only_physical_cores=True)
         num_gpus = 0
         return num_cpus, num_gpus
 

autogluon/tabular/models/catboost/catboost_utils.py

@@ -5,7 +5,14 @@ from autogluon.core.constants import BINARY, MULTICLASS, QUANTILE, REGRESSION, S
 logger = logging.getLogger(__name__)
 
 
-CATBOOST_QUANTILE_PREFIX = "MultiQuantile:"
+CATBOOST_QUANTILE_PREFIX = "Quantile:"
+# Mapping from non-optimizable eval_metric to optimizable loss_function.
+# See https://catboost.ai/docs/en/concepts/loss-functions-regression#usage-information
+CATBOOST_EVAL_METRIC_TO_LOSS_FUNCTION = {
+    "MedianAbsoluteError": "MAE",
+    "SMAPE": "MAPE",
+    "R2": "RMSE",
+}
 
 
 # TODO: Add weight support?
@@ -65,7 +72,10 @@ def get_catboost_metric_from_ag_metric(metric, problem_type, quantile_levels=Non
             mean_squared_error="RMSE",
             root_mean_squared_error="RMSE",
             mean_absolute_error="MAE",
+            mean_absolute_percentage_error="MAPE",
+            # Non-optimizable metrics, see CATBOOST_EVAL_METRIC_TO_LOSS_FUNCTION
             median_absolute_error="MedianAbsoluteError",
+            symmetric_mean_absolute_percentage_error="SMAPE",
             r2="R2",
         )
         metric_class = metric_map.get(metric.name, "RMSE")
@@ -74,8 +84,12 @@ def get_catboost_metric_from_ag_metric(metric, problem_type, quantile_levels=Non
             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}")
-        quantile_string = ",".join(str(q) for q in quantile_levels)
-        metric_class = f"{CATBOOST_QUANTILE_PREFIX}alpha={quantile_string}"
+        # 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]}"
+        else:
+            quantile_string = ",".join(str(q) for q in quantile_levels)
+            metric_class = f"Multi{CATBOOST_QUANTILE_PREFIX}alpha={quantile_string}"
     else:
         raise AssertionError(f"CatBoost does not support {problem_type} problem type.")