autogluon.tabular 1.3.2b20250723__py3-none-any.whl → 1.4.0__py3-none-any.whl

autogluon/tabular/models/mitra/sklearn_interface.py

@@ -1,3 +1,6 @@
+from __future__ import annotations
+
+import os
 import time
 from pathlib import Path
 import contextlib
@@ -76,6 +79,7 @@ class MitraBase(BaseEstimator):
             random_mirror_regression=RANDOM_MIRROR_REGRESSION,
             random_mirror_x=RANDOM_MIRROR_X,
             seed=SEED,
+            verbose=True,
         ):
         """
         Initialize the base Mitra model.
@@ -114,8 +118,11 @@ class MitraBase(BaseEstimator):
         self.trainers = []
         self.train_time = 0
         self.seed = seed
+        self.verbose = verbose
 
-        set_seed(self.seed)
+        # FIXME: set_seed was removed in v1.4 as quality and speed reduction was observed when setting seed.
+        #  This should be investigated and fixed for v1.5
+        # set_seed(self.seed)
 
     def _create_config(self, task, dim_output, time_limit=None):
         cfg = ConfigRun(
@@ -183,6 +190,7 @@ class MitraBase(BaseEstimator):
         """Train the ensemble of models."""
 
         cfg, Tab2D = self._create_config(task, dim_output, time_limit)
+        rng = np.random.RandomState(cfg.seed)
 
         success = False
         while not (success and cfg.hyperparams["max_samples_support"] > 0 and cfg.hyperparams["max_samples_query"] > 0):
@@ -217,7 +225,7 @@ class MitraBase(BaseEstimator):
                             path_to_weights=Path(self.state_dict),
                             device=self.device,
                         )
-                    trainer = TrainerFinetune(cfg, model, n_classes=n_classes, device=self.device)
+                    trainer = TrainerFinetune(cfg, model, n_classes=n_classes, device=self.device, rng=rng, verbose=self.verbose)
 
                     start_time = time.time()
                     trainer.train(X_train, y_train, X_valid, y_valid)
@@ -275,6 +283,7 @@ class MitraClassifier(MitraBase, ClassifierMixin):
             random_mirror_regression=RANDOM_MIRROR_REGRESSION,
             random_mirror_x=RANDOM_MIRROR_X,
             seed=SEED,
+            verbose=True,
         ):
         """Initialize the classifier."""
         super().__init__(
@@ -294,6 +303,7 @@ class MitraClassifier(MitraBase, ClassifierMixin):
             random_mirror_regression=random_mirror_regression,
             random_mirror_x=random_mirror_x,
             seed=seed,
+            verbose=verbose,
         )
         self.task = 'classification'
 
@@ -403,6 +413,7 @@ class MitraRegressor(MitraBase, RegressorMixin):
             random_mirror_regression=RANDOM_MIRROR_REGRESSION,
             random_mirror_x=RANDOM_MIRROR_X,
             seed=SEED,
+            verbose=True,
         ):
         """Initialize the regressor."""
         super().__init__(
@@ -422,6 +433,7 @@ class MitraRegressor(MitraBase, RegressorMixin):
             random_mirror_regression=random_mirror_regression,
             random_mirror_x=random_mirror_x,
             seed=seed,
+            verbose=verbose,
         )
         self.task = 'regression'
 
@@ -492,14 +504,4 @@ class MitraRegressor(MitraBase, RegressorMixin):
 @contextlib.contextmanager
 def mitra_deterministic_context():
     """Context manager to set deterministic settings only for Mitra operations."""
-    
-    original_deterministic_algorithms_set = False
-
-    try:
-        torch.use_deterministic_algorithms(True)
-        original_deterministic_algorithms_set = True
-        yield
-        
-    finally:
-        if original_deterministic_algorithms_set:
-            torch.use_deterministic_algorithms(False)
+    yield

autogluon/tabular/models/realmlp/realmlp_model.py

@@ -1,11 +1,5 @@
 """
 Code Adapted from TabArena: https://github.com/autogluon/tabrepo/blob/main/tabrepo/benchmark/models/ag/realmlp/realmlp_model.py
-
-Model: RealMLP
-Paper: Better by Default: Strong Pre-Tuned MLPs and Boosted Trees on Tabular Data
-Authors: David Holzmüller, Léo Grinsztajn, Ingo Steinwart
-Codebase: https://github.com/dholzmueller/pytabkit
-License: Apache-2.0
 """
 
 from __future__ import annotations
@@ -41,6 +35,19 @@ def set_logger_level(logger_name: str, level: int):
 
 # pip install pytabkit
 class RealMLPModel(AbstractModel):
+    """
+    RealMLP is an improved multilayer perception (MLP) model
+    through a bag of tricks and better default hyperparameters.
+
+    RealMLP is the top performing method overall on TabArena-v0.1: https://tabarena.ai
+
+    Paper: Better by Default: Strong Pre-Tuned MLPs and Boosted Trees on Tabular Data
+    Authors: David Holzmüller, Léo Grinsztajn, Ingo Steinwart
+    Codebase: https://github.com/dholzmueller/pytabkit
+    License: Apache-2.0
+
+    .. versionadded:: 1.4.0
+    """
     ag_key = "REALMLP"
     ag_name = "RealMLP"
     ag_priority = 75

autogluon/tabular/models/tabicl/tabicl_model.py

@@ -1,10 +1,5 @@
 """
 Code Adapted from TabArena: https://github.com/autogluon/tabrepo/blob/main/tabrepo/benchmark/models/ag/tabicl/tabicl_model.py
-Model: TabICL
-Paper: TabICL: A Tabular Foundation Model for In-Context Learning on Large Data
-Authors: Jingang Qu, David Holzmüller, Gaël Varoquaux, Marine Le Morvan
-Codebase: https://github.com/soda-inria/tabicl
-License: BSD-3-Clause
 """
 
 from __future__ import annotations
@@ -23,6 +18,20 @@ logger = logging.getLogger(__name__)
 
 # TODO: Verify if crashes when weights are not yet downloaded and fit in parallel
 class TabICLModel(AbstractModel):
+    """
+    TabICL is a foundation model for tabular data using in-context learning
+    that is scalable to larger datasets than TabPFNv2. It is pretrained purely on synthetic data.
+    TabICL currently only supports classification tasks.
+
+    TabICL is one of the top performing methods overall on TabArena-v0.1: https://tabarena.ai
+
+    Paper: TabICL: A Tabular Foundation Model for In-Context Learning on Large Data
+    Authors: Jingang Qu, David Holzmüller, Gaël Varoquaux, Marine Le Morvan
+    Codebase: https://github.com/soda-inria/tabicl
+    License: BSD-3-Clause
+
+    .. versionadded:: 1.4.0
+    """
     ag_key = "TABICL"
     ag_name = "TabICL"
     ag_priority = 65
@@ -98,8 +107,8 @@ class TabICLModel(AbstractModel):
         default_auxiliary_params = super()._get_default_auxiliary_params()
         default_auxiliary_params.update(
             {
-                "max_rows": 100000,
-                "max_features": 500,
+                "max_rows": 30000,
+                "max_features": 2000,
             }
         )
         return default_auxiliary_params
@@ -147,7 +156,7 @@ class TabICLModel(AbstractModel):
         model_mem_estimate *= 1.3  # add 30% buffer
 
         # TODO: Observed memory spikes above expected values on large datasets, increasing mem estimate to compensate
-        model_mem_estimate *= 1.5
+        model_mem_estimate *= 2.0  # Note: 1.5 is not large enough, still gets OOM
 
         mem_estimate = model_mem_estimate + dataset_size_mem_est + baseline_overhead_mem_est
 

autogluon/tabular/models/tabm/rtdl_num_embeddings.py

@@ -1,6 +1,8 @@
 # taken from https://github.com/yandex-research/rtdl-num-embeddings/blob/main/package/rtdl_num_embeddings.py
 """On Embeddings for Numerical Features in Tabular Deep Learning."""
 
+from __future__ import annotations
+
 __version__ = '0.0.12'
 
 __all__ = [
@@ -12,6 +14,7 @@ __all__ = [
     'compute_bins',
 ]
 
+
 import math
 import warnings
 from typing import Any, Literal, Optional, Union

autogluon/tabular/models/tabm/tabm_model.py

@@ -4,12 +4,6 @@ Note: This is a custom implementation of TabM based on TabArena. Because the Aut
 the same time as TabM became available on PyPi, we chose to use TabArena's implementation
 for the AutoGluon 1.4 release as it has already been benchmarked.
 
-Model: TabM
-Paper: TabM: Advancing Tabular Deep Learning with Parameter-Efficient Ensembling
-Authors: Yury Gorishniy, Akim Kotelnikov, Artem Babenko
-Codebase: https://github.com/yandex-research/tabm
-License: Apache-2.0
-
 Partially adapted from pytabkit's TabM implementation.
 """
 
@@ -28,6 +22,20 @@ logger = logging.getLogger(__name__)
 
 
 class TabMModel(AbstractModel):
+    """
+    TabM is an efficient ensemble of MLPs that is trained simultaneously with mostly shared parameters.
+
+    TabM is one of the top performing methods overall on TabArena-v0.1: https://tabarena.ai
+
+    Paper: TabM: Advancing Tabular Deep Learning with Parameter-Efficient Ensembling
+    Authors: Yury Gorishniy, Akim Kotelnikov, Artem Babenko
+    Codebase: https://github.com/yandex-research/tabm
+    License: Apache-2.0
+
+    Partially adapted from pytabkit's TabM implementation.
+
+    .. versionadded:: 1.4.0
+    """
     ag_key = "TABM"
     ag_name = "TabM"
     ag_priority = 85

autogluon/tabular/models/tabm/tabm_reference.py

@@ -3,6 +3,8 @@
 # NOTE
 # The minimum required versions of the dependencies are specified in README.md.
 
+from __future__ import annotations
+
 import itertools
 from typing import Any, Literal, Union
 

autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py

@@ -26,6 +26,8 @@ class TabPFNMixModel(AbstractModel):
 
     TabPFNMix is based off of the TabPFN and TabForestPFN models.
 
+    We recommend using Mitra instead, as it is an improved version of TabPFNMix.
+
     It is a tabular transformer model pre-trained on purely synthetic data.
 
     It currently has several limitations:
@@ -34,6 +36,8 @@ class TabPFNMixModel(AbstractModel):
     3. Does not support GPU
 
     For more information, refer to the `./_internals/README.md` file.
+
+    .. versionadded:: 1.2.0
     """
     ag_key = "TABPFNMIX"
     ag_name = "TabPFNMix"

autogluon/tabular/models/tabpfnv2/tabpfnv2_model.py

@@ -1,11 +1,5 @@
 """
 Code Adapted from TabArena: https://github.com/autogluon/tabrepo/blob/main/tabrepo/benchmark/models/ag/tabpfnv2/tabpfnv2_model.py
-
-Model: TabPFNv2
-Paper: Accurate predictions on small data with a tabular foundation model
-Authors: Noah Hollmann, Samuel Müller, Lennart Purucker, Arjun Krishnakumar, Max Körfer, Shi Bin Hoo, Robin Tibor Schirrmeister & Frank Hutter
-Codebase: https://github.com/PriorLabs/TabPFN
-License: https://github.com/PriorLabs/TabPFN/blob/main/LICENSE
 """
 
 from __future__ import annotations
@@ -111,6 +105,20 @@ class FixedSafePowerTransformer(PowerTransformer):
 
 
 class TabPFNV2Model(AbstractModel):
+    """
+    TabPFNv2 is a tabular foundation model pre-trained purely on synthetic data that achieves
+    state-of-the-art results with in-context learning on small datasets with <=10000 samples and <=500 features.
+    TabPFNv2 is developed and maintained by PriorLabs: https://priorlabs.ai/
+
+    TabPFNv2 is the top performing method for small datasets on TabArena-v0.1: https://tabarena.ai
+
+    Paper: Accurate predictions on small data with a tabular foundation model
+    Authors: Noah Hollmann, Samuel Müller, Lennart Purucker, Arjun Krishnakumar, Max Körfer, Shi Bin Hoo, Robin Tibor Schirrmeister & Frank Hutter
+    Codebase: https://github.com/PriorLabs/TabPFN
+    License: https://github.com/PriorLabs/TabPFN/blob/main/LICENSE
+
+    .. versionadded:: 1.4.0
+    """
     ag_key = "TABPFNV2"
     ag_name = "TabPFNv2"
     ag_priority = 105
@@ -119,12 +127,14 @@ class TabPFNV2Model(AbstractModel):
         super().__init__(**kwargs)
         self._feature_generator = None
         self._cat_features = None
+        self._cat_indices = None
 
     def _preprocess(self, X: pd.DataFrame, is_train=False, **kwargs) -> pd.DataFrame:
         X = super()._preprocess(X, **kwargs)
-        self._cat_indices = []
 
         if is_train:
+            self._cat_indices = []
+
             # X will be the training data.
             self._feature_generator = LabelEncoderFeatureGenerator(verbosity=0)
             self._feature_generator.fit(X=X)
@@ -136,10 +146,11 @@ class TabPFNV2Model(AbstractModel):
                 X=X
             )
 
-            # Detect/set cat features and indices
-            if self._cat_features is None:
-                self._cat_features = self._feature_generator.features_in[:]
-            self._cat_indices = [X.columns.get_loc(col) for col in self._cat_features]
+            if is_train:
+                # Detect/set cat features and indices
+                if self._cat_features is None:
+                    self._cat_features = self._feature_generator.features_in[:]
+                self._cat_indices = [X.columns.get_loc(col) for col in self._cat_features]
 
         return X
 
@@ -187,6 +198,12 @@ class TabPFNV2Model(AbstractModel):
             # logs "Built with PriorLabs-TabPFN"
             self._log_license(device=device)
 
+        if num_gpus == 0:
+            logger.log(
+                30,
+                f"\tWARNING: Running TabPFNv2 on CPU. This can be very slow. We recommend using a GPU instead."
+            )
+
         X = self.preprocess(X, is_train=True)
 
         hps = self._get_model_params()
@@ -366,7 +383,7 @@ class TabPFNV2Model(AbstractModel):
 
         # Add some buffer to each term + 1 GB overhead to be safe
         return int(
-            model_mem + 4 * X_mem + 1.5 * activation_mem + baseline_overhead_mem_est
+            model_mem + 4 * X_mem + 2 * activation_mem + baseline_overhead_mem_est
         )
 
     @classmethod

autogluon/tabular/predictor/predictor.py

@@ -437,18 +437,24 @@ class TabularPredictor:
         presets : list or str or dict, default = ['medium_quality']
             List of preset configurations for various arguments in `fit()`. Can significantly impact predictive accuracy, memory-footprint, and inference latency of trained models, and various other properties of the returned `predictor`.
             It is recommended to specify presets and avoid specifying most other `fit()` arguments or model hyperparameters prior to becoming familiar with AutoGluon.
-            As an example, to get the most accurate overall predictor (regardless of its efficiency), set `presets='best_quality'`.
+            As an example, to get the most accurate overall predictor (regardless of its efficiency), set `presets='best_quality'` (or `extreme_quality` if a GPU is available).
             To get good quality with minimal disk usage, set `presets=['good_quality', 'optimize_for_deployment']`
             Any user-specified arguments in `fit()` will override the values used by presets.
             If specifying a list of presets, later presets will override earlier presets if they alter the same argument.
             For precise definitions of the provided presets, see file: `autogluon/tabular/configs/presets_configs.py`.
             Users can specify custom presets by passing in a dictionary of argument values as an element to the list.
 
-            Available Presets: ['best_quality', 'high_quality', 'good_quality', 'medium_quality', 'experimental_quality', 'optimize_for_deployment', 'interpretable', 'ignore_text']
+            Available Presets: ['extreme_quality', 'best_quality', 'high_quality', 'good_quality', 'medium_quality', 'experimental_quality', 'optimize_for_deployment', 'interpretable', 'ignore_text']
 
             It is recommended to only use one `quality` based preset in a given call to `fit()` as they alter many of the same arguments and are not compatible with each-other.
 
             In-depth Preset Info:
+                extreme_quality={"auto_stack": True, "dynamic_stacking": "auto", "_experimental_dynamic_hyperparameters": True, "hyperparameters": None}
+                    Significantly more accurate than `best_quality` on datasets <= 30000 samples. Requires a GPU for best results.
+                    For datasets <= 30000 samples, will use recent tabular foundation models TabPFNv2, TabICL, and Mitra to maximize performance.
+                    For datasets > 30000 samples, will behave identically to `best_quality`.
+                    Recommended for applications that benefit from the best possible model accuracy.
+
                 best_quality={'auto_stack': True, 'dynamic_stacking': 'auto', 'hyperparameters': 'zeroshot'}
                     Best predictive accuracy with little consideration to inference time or disk usage. Achieve even better results by specifying a large time_limit value.
                     Recommended for applications that benefit from the best possible model accuracy.
@@ -477,7 +483,7 @@ class TabularPredictor:
                         Because unused models will be deleted under this preset, methods like `predictor.leaderboard()` and `predictor.fit_summary()` will no longer show the full set of models that were trained during `fit()`.
                     Recommended for applications where the inner details of AutoGluon's training is not important and there is no intention of manually choosing between the final models.
                     This preset pairs well with the other presets such as `good_quality` to make a very compact final model.
-                    Identical to calling `predictor.delete_models(models_to_keep='best', dry_run=False)` and `predictor.save_space()` directly after `fit()`.
+                    Identical to calling `predictor.delete_models(models_to_keep='best')` and `predictor.save_space()` directly after `fit()`.
 
                 interpretable={'auto_stack': False, 'hyperparameters': 'interpretable'}
                     Fits only interpretable rule-based models from the imodels package.
@@ -491,9 +497,10 @@ class TabularPredictor:
         hyperparameters : str or dict, default = 'default'
             Determines the hyperparameters used by the models.
             If `str` is passed, will use a preset hyperparameter configuration.
-                Valid `str` options: ['default', 'zeroshot', 'light', 'very_light', 'toy', 'multimodal']
+                Valid `str` options: ['default', 'zeroshot', 'zeroshot_2025_tabfm', 'light', 'very_light', 'toy', 'multimodal']
                     'default': Default AutoGluon hyperparameters intended to get strong accuracy with reasonable disk usage and inference time. Used in the 'medium_quality' preset.
                     'zeroshot': A powerful model portfolio learned from TabRepo's ensemble simulation on 200 datasets. Contains ~100 models and is used in 'best_quality' and 'high_quality' presets.
+                    'zeroshot_2025_tabfm': Absolute cutting edge portfolio learned from TabArena's ensemble simulation that leverages tabular foundation models. Contains 22 models and is used in the `extreme_quality` preset.
                     'light': Results in smaller models. Generally will make inference speed much faster and disk usage much lower, but with worse accuracy. Used in the 'good_quality' preset.
                     'very_light': Results in much smaller models. Behaves similarly to 'light', but in many cases with over 10x less disk usage and a further reduction in accuracy.
                     'toy': Results in extremely small models. Only use this when prototyping, as the model quality will be severely reduced.
@@ -505,6 +512,11 @@ class TabularPredictor:
                     'GBM' (LightGBM)
                     'CAT' (CatBoost)
                     'XGB' (XGBoost)
+                    'REALMLP' (RealMLP)
+                    'TABM' (TabM)
+                    'MITRA' (Mitra)
+                    'TABICL' (TabICL)
+                    'TABPFNV2' (TabPFNv2)
                     'RF' (random forest)
                     'XT' (extremely randomized trees)
                     'KNN' (k-nearest neighbors)
@@ -513,9 +525,8 @@ class TabularPredictor:
                     'FASTAI' (neural network with FastAI backend)
                     'AG_AUTOMM' (`MultimodalPredictor` from `autogluon.multimodal`. Supports Tabular, Text, and Image modalities. GPU is required.)
                 Experimental model options include:
-                    'FT_TRANSFORMER' (Tabular Transformer, GPU is recommended. Does not scale well to >100 features.)
+                    'FT_TRANSFORMER' (Tabular Transformer, GPU is recommended. Does not scale well to >100 features. Recommended to use TabM instead.)
                     'FASTTEXT' (FastText. Note: Has not been tested for a long time.)
-                    'TABPFN' (TabPFN. Does not scale well to >100 features or >1000 rows, and does not support regression. Extremely slow inference speed.)
                     'AG_TEXT_NN' (Multimodal Text+Tabular model, GPU is required. Recommended to instead use its successor, 'AG_AUTOMM'.)
                     'AG_IMAGE_NN' (Image model, GPU is required. Recommended to instead use its successor, 'AG_AUTOMM'.)
                 If a certain key is missing from hyperparameters, then `fit()` will not train any models of that type. Omitting a model key from hyperparameters is equivalent to including this model key in `excluded_model_types`.
@@ -623,6 +634,16 @@ class TabularPredictor:
                                 How many GPUs to use during model fit.
                                 If 'auto', model will decide. Some models can use GPUs but don't by default due to differences in model quality.
                                 Set to 0 to disable usage of GPUs.
+                            max_rows : (int, default=None)
+                                If train_data has more rows than `max_rows`, the model will raise an AssertionError at the start of fit.
+                            max_features : (int, default=None)
+                                If train_data has more features than `max_features`, the model will raise an AssertionError at the start of fit.
+                            max_classes : (int, default==None)
+                                If train_data has more classes than `max_classes`, the model will raise an AssertionError at the start of fit.
+                            problem_types : (list[str], default=None)
+                                If the task is not a problem_type in `problem_types`, the model will raise an AssertionError at the start of fit.
+                            ignore_constraints : (bool, default=False)
+                                If True, will ignore the values of `max_rows`, `max_features`, `max_classes`, and `problem_type`, treating them as None.
                     ag_args_ensemble: Dictionary of hyperparameters shared by all models that control how they are ensembled, if bag mode is enabled.
                         Valid keys:
                             use_orig_features: [True, False, "never"], default True
@@ -723,6 +744,7 @@ class TabularPredictor:
             If "sequential", models will be fit sequentially. This is the most stable option with the most readable logging.
             If "parallel", models will be fit in parallel with ray, splitting available compute between them.
                 Note: "parallel" is experimental and may run into issues. It was first added in version 1.2.0.
+                Note: "parallel" does not yet support running with GPUs.
             For machines with 16 or more CPU cores, it is likely that "parallel" will be faster than "sequential".
 
             .. versionadded:: 1.2.0
@@ -933,14 +955,14 @@ class TabularPredictor:
                     This is because by default, refit_full will fall back to cloning the first fold of the bagged model in case it lacks memory to refit.
                     However, if `save_bag_folds=False`, this fallback isn't possible, as there is not fold model to clone because it wasn't saved.
                     In this scenario, refit will raise an exception for `save_bag_folds=False`, but will succeed if `save_bag_folds=True`.
-                Final disk usage of predictor will be identical regardless of the setting after `predictor.delete_models(models_to_keep="best", dry_run=False)` is called post-fit.
+                Final disk usage of predictor will be identical regardless of the setting after `predictor.delete_models(models_to_keep="best")` is called post-fit.
             set_best_to_refit_full : bool, default = False
                 If True, will change the default model that Predictor uses for prediction when model is not specified to the refit_full version of the model that exhibited the highest validation score.
                 Only valid if `refit_full` is set.
             keep_only_best : bool, default = False
                 If True, only the best model and its ancestor models are saved in the outputted `predictor`. All other models are deleted.
                     If you only care about deploying the most accurate predictor with the smallest file-size and no longer need any of the other trained models or functionality beyond prediction on new data, then set: `keep_only_best=True`, `save_space=True`.
-                    This is equivalent to calling `predictor.delete_models(models_to_keep='best', dry_run=False)` directly after `fit()`.
+                    This is equivalent to calling `predictor.delete_models(models_to_keep='best')` directly after `fit()`.
                 If used with `refit_full` and `set_best_to_refit_full`, the best model will be the refit_full model, and the original bagged best model will be deleted.
                     `refit_full` will be automatically set to 'best' in this case to avoid training models which will be later deleted.
             save_space : bool, default = False
@@ -1068,11 +1090,11 @@ class TabularPredictor:
                 20,
                 "No presets specified! To achieve strong results with AutoGluon, it is recommended to use the available presets. Defaulting to `'medium'`...\n"
                 "\tRecommended Presets (For more details refer to https://auto.gluon.ai/stable/tutorials/tabular/tabular-essentials.html#presets):\n"
-                "\tpresets='experimental' : New in v1.2: Pre-trained foundation model + parallel fits. The absolute best accuracy without consideration for inference speed. Does not support GPU.\n"
-                "\tpresets='best'         : Maximize accuracy. Recommended for most users. Use in competitions and benchmarks.\n"
-                "\tpresets='high'         : Strong accuracy with fast inference speed.\n"
-                "\tpresets='good'         : Good accuracy with very fast inference speed.\n"
-                "\tpresets='medium'       : Fast training time, ideal for initial prototyping.",
+                "\tpresets='extreme' : New in v1.4: Massively better than 'best' on datasets <30000 samples by using new models meta-learned on https://tabarena.ai: TabPFNv2, TabICL, Mitra, and TabM. Absolute best accuracy. Requires a GPU. Recommended 64 GB CPU memory and 32+ GB GPU memory.\n"
+                "\tpresets='best'    : Maximize accuracy. Recommended for most users. Use in competitions and benchmarks.\n"
+                "\tpresets='high'    : Strong accuracy with fast inference speed.\n"
+                "\tpresets='good'    : Good accuracy with very fast inference speed.\n"
+                "\tpresets='medium'  : Fast training time, ideal for initial prototyping.",
             )
 
         kwargs_orig = kwargs.copy()
@@ -1127,10 +1149,48 @@ class TabularPredictor:
         )
         infer_limit, infer_limit_batch_size = self._validate_infer_limit(infer_limit=infer_limit, infer_limit_batch_size=infer_limit_batch_size)
 
+        # TODO: Temporary for v1.4. Make this more extensible for v1.5 by letting users make their own dynamic hyperparameters.
+        dynamic_hyperparameters = kwargs["_experimental_dynamic_hyperparameters"]
+        if dynamic_hyperparameters:
+            logger.log(20, f"`extreme` preset uses a dynamic portfolio based on dataset size...")
+            assert hyperparameters is None, f"hyperparameters must be unspecified when `_experimental_dynamic_hyperparameters=True`."
+            n_samples = len(train_data)
+            if n_samples > 30000:
+                data_size = "large"
+            else:
+                data_size = "small"
+            assert data_size in ["large", "small"]
+            if data_size == "large":
+                logger.log(20, f"\tDetected data size: large (>30000 samples), using `zeroshot` portfolio (identical to 'best_quality' preset).")
+                hyperparameters = "zeroshot"
+            else:
+                if "num_stack_levels" not in kwargs_orig:
+                    # disable stacking for tabfm portfolio
+                    num_stack_levels = 0
+                    kwargs["num_stack_levels"] = 0
+                logger.log(
+                    20,
+                    f"\tDetected data size: small (<=30000 samples), using `zeroshot_2025_tabfm` portfolio."
+                    f"\n\t\tNote: `zeroshot_2025_tabfm` portfolio requires a CUDA compatible GPU for best performance."
+                    f"\n\t\tMake sure you have all the relevant dependencies installed: "
+                    f"`pip install autogluon.tabular[tabarena]`."
+                    f"\n\t\tIt is strongly recommended to use a machine with 64+ GB memory "
+                    f"and a CUDA compatible GPU with 32+ GB vRAM when using this preset. "
+                    f"\n\t\tThis portfolio will download foundation model weights from HuggingFace during training. "
+                    f"Ensure you have an internet connection or have pre-downloaded the weights to use these models."
+                    f"\n\t\tThis portfolio was meta-learned with TabArena: https://tabarena.ai"
+                )
+                hyperparameters = "zeroshot_2025_tabfm"
+
         if hyperparameters is None:
             hyperparameters = "default"
         if isinstance(hyperparameters, str):
+            hyperparameters_str = hyperparameters
             hyperparameters = get_hyperparameter_config(hyperparameters)
+            logger.log(
+                20,
+                f"Using hyperparameters preset: hyperparameters='{hyperparameters_str}'",
+            )
         self._validate_hyperparameters(hyperparameters=hyperparameters)
         self.fit_hyperparameters_ = hyperparameters
 
@@ -4341,7 +4401,7 @@ class TabularPredictor:
         models_to_delete: str | list[str] | None = None,
         allow_delete_cascade: bool = False,
         delete_from_disk: bool = True,
-        dry_run: bool | None = None,
+        dry_run: bool = False,
     ):
         """
         Deletes models from `predictor`.
@@ -4372,20 +4432,11 @@ class TabularPredictor:
             If `True`, deletes the models from disk if they were persisted.
             WARNING: This deletes the entire directory for the deleted models, and ALL FILES located there.
                 It is highly recommended to first run with `dry_run=True` to understand which directories will be deleted.
-        dry_run : bool, default = True
-            WARNING: Starting in v1.4.0 dry_run will default to False.
+        dry_run : bool, default = False
             If `True`, then deletions don't occur, and logging statements are printed describing what would have occurred.
             Set `dry_run=False` to perform the deletions.
 
         """
-        if dry_run is None:
-            warnings.warn(
-                f"dry_run was not specified for `TabularPredictor.delete_models`. dry_run prior to version 1.4.0 defaults to True. "
-                f"Starting in version 1.4, AutoGluon will default dry_run to False. "
-                f"If you want to maintain the current logic in future versions, explicitly specify `dry_run=True`.",
-                category=FutureWarning,
-            )
-            dry_run = True
         self._assert_is_fit("delete_models")
         if models_to_keep == "best":
             models_to_keep = self.model_best
@@ -5042,6 +5093,8 @@ class TabularPredictor:
             learning_curves=False,
             test_data=None,
             raise_on_model_failure=False,
+            # experimental
+            _experimental_dynamic_hyperparameters=False,
         )
         kwargs, ds_valid_keys = self._sanitize_dynamic_stacking_kwargs(kwargs)
         kwargs = self._validate_fit_extra_kwargs(kwargs, extra_valid_keys=list(fit_kwargs_default.keys()) + ds_valid_keys)
@@ -5552,7 +5605,7 @@ class TabularPredictor:
         Identical to performing the following operations in order:
 
         predictor_clone = predictor.clone(path=path, return_clone=True, dirs_exist_ok=dirs_exist_ok)
-        predictor_clone.delete_models(models_to_keep=model, dry_run=False)
+        predictor_clone.delete_models(models_to_keep=model)
         predictor_clone.set_model_best(model=model, save_trainer=True)
         predictor_clone.save_space()
 
@@ -5564,7 +5617,7 @@ class TabularPredictor:
             The model to use in the optimized predictor clone.
             All other unrelated models will be deleted to save disk space.
             Refer to the `models_to_keep` argument of `predictor.delete_models` for available options.
-            Internally calls `predictor_clone.delete_models(models_to_keep=model, dry_run=False)`
+            Internally calls `predictor_clone.delete_models(models_to_keep=model)`
         return_clone : bool, default = False
             If True, returns the loaded cloned TabularPredictor object.
             If False, returns the local path to the cloned TabularPredictor object.

autogluon/tabular/trainer/abstract_trainer.py

@@ -2131,6 +2131,8 @@ class AbstractTabularTrainer(AbstractTrainer[AbstractModel]):
         if isinstance(model, BaggedEnsembleModel) and not compute_score:
             # Do not perform OOF predictions when we don't compute a score.
             model_fit_kwargs["_skip_oof"] = True
+        if not isinstance(model, BaggedEnsembleModel):
+            model_fit_kwargs.setdefault("log_resources", True)
 
         model_fit_kwargs = dict(
             model=model,

autogluon/tabular/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.3.2b20250723"
+__version__ = "1.4.0"
 __lite__ = False