autogluon.tabular 1.4.1b20250819__tar.gz → 1.4.1b20250821__tar.gz

{autogluon.tabular-1.4.1b20250819 → autogluon.tabular-1.4.1b20250821}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.4.1b20250819
+Version: 1.4.1b20250821
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

autogluon.tabular-1.4.1b20250821/src/autogluon/tabular/configs/pipeline_presets.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import math
+
+from autogluon.core.constants import BINARY, PROBLEM_TYPES
+from autogluon.core.utils.utils import default_holdout_frac
+
+USE_BAG_HOLDOUT_AUTO_THRESHOLD = 1_000_000
+
+
+def _get_validation_preset(num_train_rows: int, hpo_enabled: bool) -> dict[str, int | float]:
+    """Recommended validation preset manually defined by the AutoGluon developers."""
+
+    # -- Default recommendation
+    #  max 8 due to 8 cores per CPU being very common.
+    #  down to 5 folds for small datasets to have enough samples for a representative validation set.
+    num_bag_folds = min(8, max(5, math.floor(num_train_rows / 10)))
+
+    num_bag_sets = 1  # More repeats do not seem to help due to overfitting on val data.
+    use_bag_holdout = num_train_rows >= USE_BAG_HOLDOUT_AUTO_THRESHOLD
+    holdout_frac = round(default_holdout_frac(num_train_rows=num_train_rows, hyperparameter_tune=hpo_enabled), 4)
+
+    return dict(
+        num_bag_sets=num_bag_sets,
+        num_bag_folds=num_bag_folds,
+        use_bag_holdout=use_bag_holdout,
+        holdout_frac=holdout_frac,
+    )
+
+
+# TODO(refactor): use a data class for the config of the validation method.
+# TODO(improvement): Implement a more sophisticated solution.
+#   Could also use more metadata such as  num_features, num_models,
+#   or time_limit for a heuristic.
+#       num_features: The number of features in the dataset.
+#       num_models: The number of models in the portfolio to fit.
+#       time_limit: The time limit for fitting models.
+#   Pointer for non-heuristic approach:
+#       -> meta-learning like Auto-Sklearn 2.0, needs a lot of metadata
+def get_validation_and_stacking_method(
+    # Validation parameters
+    num_bag_folds: int | None,
+    num_bag_sets: int | None,
+    use_bag_holdout: bool | None,
+    holdout_frac: float | None,
+    # Stacking/Pipeline parameters
+    auto_stack: bool,
+    num_stack_levels: int | None,
+    dynamic_stacking: bool | None,
+    refit_full: bool | None,
+    # Metadata
+    num_train_rows: int,
+    problem_type: PROBLEM_TYPES,
+    hpo_enabled: bool,
+) -> tuple[int, int, int, bool, bool, float, bool]:
+    """Get the validation method for AutoGluon via a heuristic.
+
+    Input variables are `None` if they were not specified by the user or have an explicit default.
+
+    Parameters
+    ----------
+    num_bag_folds: int | None
+        The number of folds for cross-validation.
+    num_bag_sets: int | None
+        The number of repeats for cross-validation.
+    use_bag_holdout: bool | None
+        Whether to use (additional) holdout validation.
+    holdout_frac: float | None
+        The fraction of data to holdout for validation.
+    auto_stack: bool
+        Whether to automatically determine the stacking method.
+    num_stack_levels: int | None
+        The number of stacking levels.
+    dynamic_stacking: bool | None
+        Whether to use dynamic stacking.
+    refit_full: bool
+        Whether to refit the full training dataset.
+    num_train_rows: int
+        The number of rows in the training dataset.
+    problem_type: PROBLEM_TYPES
+        The type of problem to solve.
+    hpo_enabled: bool
+        If True, HPO is enabled during the run of AutoGluon.
+
+    Returns:
+    --------
+    Returns all variables needed to define the validation method.
+    """
+
+    cv_preset = _get_validation_preset(num_train_rows=num_train_rows, hpo_enabled=hpo_enabled)
+
+    # Independent of `auto_stack`
+    if use_bag_holdout is None:
+        use_bag_holdout = cv_preset["use_bag_holdout"]
+    if holdout_frac is None:
+        holdout_frac = cv_preset["holdout_frac"]
+    if dynamic_stacking is None:
+        dynamic_stacking = not use_bag_holdout
+    if refit_full is None:
+        refit_full = False
+
+    # Changed by `auto_stack`
+    if num_bag_folds is None:
+        # `num_bag_folds == 0` -> only use holdout validation
+        num_bag_folds = cv_preset["num_bag_folds"] if auto_stack else 0
+    if num_bag_sets is None:
+        # `num_bag_sets == 1` -> no repeats
+        num_bag_sets = cv_preset["num_bag_sets"] if auto_stack else 1
+    if num_stack_levels is None:
+        # Disable multi-layer stacking by default
+        num_stack_levels = 0
+
+        # Activate multi-layer stacking for `auto_stack` if
+        if auto_stack and (
+            dynamic_stacking  # -> We use dynamic stacking
+            or
+            # -> We have holdout validation or a non-binary problem with more than 750 training rows
+            ((use_bag_holdout or (problem_type != BINARY)) and (num_train_rows >= 750))
+        ):
+            num_stack_levels = 1
+
+    return (
+        num_bag_folds,
+        num_bag_sets,
+        num_stack_levels,
+        dynamic_stacking,
+        use_bag_holdout,
+        holdout_frac,
+        refit_full,
+    )

{autogluon.tabular-1.4.1b20250819 → autogluon.tabular-1.4.1b20250821}/src/autogluon/tabular/configs/presets_configs.py

@@ -6,7 +6,6 @@ tabular_presets_dict = dict(
     best_quality={
         "auto_stack": True,
         "dynamic_stacking": "auto",
-        "num_bag_sets": 1,
         "hyperparameters": "zeroshot",
         "time_limit": 3600,
     },
@@ -16,7 +15,6 @@ tabular_presets_dict = dict(
     high_quality={
         "auto_stack": True,
         "dynamic_stacking": "auto",
-        "num_bag_sets": 1,
         "hyperparameters": "zeroshot",
         "time_limit": 3600,
         "refit_full": True,
@@ -29,7 +27,6 @@ tabular_presets_dict = dict(
     good_quality={
         "auto_stack": True,
         "dynamic_stacking": "auto",
-        "num_bag_sets": 1,
         "hyperparameters": "light",
         "time_limit": 3600,
         "refit_full": True,

{autogluon.tabular-1.4.1b20250819 → autogluon.tabular-1.4.1b20250821}/src/autogluon/tabular/models/mitra/_internal/models/tab2d.py

@@ -278,18 +278,18 @@ class Padder(torch.nn.Module):
         self.cpu_mode = False
 
         # Original flash attention initialization logic
-        x_o, self.indices_o, self.cu_seqlens_o, self.max_seqlen_in_batch_o = unpad_input(x, ~self.padding_mask)
+        x_o, self.indices_o, self.cu_seqlens_o, self.max_seqlen_in_batch_o, *_ = unpad_input(x, ~self.padding_mask)
 
         self.feature_mask_big = einops.repeat(self.feature_mask, 'b f -> b s f', s=n_obs)
-        self.feature_mask_big, _, _, _ = unpad_input(self.feature_mask_big, ~self.padding_mask)
-        x_of, self.indices_of, self.cu_seqlens_of, self.max_seqlen_in_batch_of = unpad_input(x_o, ~self.feature_mask_big)
+        self.feature_mask_big, _, _, _, *_ = unpad_input(self.feature_mask_big, ~self.padding_mask)
+        x_of, self.indices_of, self.cu_seqlens_of, self.max_seqlen_in_batch_of, *_ = unpad_input(x_o, ~self.feature_mask_big)
 
         x_rearranged = einx.rearrange('b s f d -> b f s d', x)
-        x_f, self.indices_f, self.cu_seqlens_f, self.max_seqlen_in_batch_f = unpad_input(x_rearranged, ~self.feature_mask)
+        x_f, self.indices_f, self.cu_seqlens_f, self.max_seqlen_in_batch_f, *_ = unpad_input(x_rearranged, ~self.feature_mask)
 
         self.padding_mask_big = einops.repeat(self.padding_mask, 'b s -> b f s', f=n_feat)
-        self.padding_mask_big, _, _, _ = unpad_input(self.padding_mask_big, ~self.feature_mask)
-        x_fo, self.indices_fo, self.cu_seqlens_fo, self.max_seqlen_in_batch_fo = unpad_input(x_f, ~self.padding_mask_big)
+        self.padding_mask_big, _, _, _, *_ = unpad_input(self.padding_mask_big, ~self.feature_mask)
+        x_fo, self.indices_fo, self.cu_seqlens_fo, self.max_seqlen_in_batch_fo, *_ = unpad_input(x_f, ~self.padding_mask_big)
 
         self.batch_size_f = x_f.shape[0]
         self.batch_size_o = x_o.shape[0]
@@ -307,8 +307,8 @@ class Padder(torch.nn.Module):
 
         # GPU path with flash attention
         x = einx.rearrange('b s f d -> b f s d', x)
-        x, _, _, _ = unpad_input(x, ~self.feature_mask)
-        x, _, _, _ = unpad_input(x, ~self.padding_mask_big)
+        x, _, _, _, *_ = unpad_input(x, ~self.feature_mask)
+        x, _, _, _, *_ = unpad_input(x, ~self.padding_mask_big)
         return x
 
     def base_to_feat(self, x: torch.Tensor) -> torch.Tensor:
@@ -319,8 +319,8 @@ class Padder(torch.nn.Module):
             return x.view(b * f, s * d)
 
         # GPU path with flash attention
-        x, _, _, _ = unpad_input(x, ~self.padding_mask)
-        x, _, _, _ = unpad_input(x, ~self.feature_mask_big)
+        x, _, _, _, *_ = unpad_input(x, ~self.padding_mask)
+        x, _, _, _, *_ = unpad_input(x, ~self.feature_mask_big)
         return x
 
     def obs_to_base(self, x: torch.Tensor) -> torch.Tensor:

{autogluon.tabular-1.4.1b20250819 → autogluon.tabular-1.4.1b20250821}/src/autogluon/tabular/predictor/predictor.py

@@ -48,10 +48,14 @@ from autogluon.core.utils import get_pred_from_proba_df, plot_performance_vs_tri
 from autogluon.core.utils.decorators import apply_presets
 from autogluon.core.utils.loaders import load_pkl, load_str
 from autogluon.core.utils.savers import save_pkl, save_str
-from autogluon.core.utils.utils import CVSplitter, default_holdout_frac, generate_train_test_split_combined
+from autogluon.core.utils.utils import CVSplitter, generate_train_test_split_combined
 
 from ..configs.feature_generator_presets import get_default_feature_generator
 from ..configs.hyperparameter_configs import get_hyperparameter_config
+from ..configs.pipeline_presets import (
+    USE_BAG_HOLDOUT_AUTO_THRESHOLD,
+    get_validation_and_stacking_method,
+)
 from ..configs.presets_configs import tabular_presets_alias, tabular_presets_dict
 from ..learner import AbstractTabularLearner, DefaultLearner
 from ..trainer.abstract_trainer import AbstractTabularTrainer
@@ -429,12 +433,17 @@ class TabularPredictor:
             Table of the training data as a pandas DataFrame.
             If str is passed, `train_data` will be loaded using the str value as the file path.
         tuning_data : :class:`pd.DataFrame` or str, optional
-            Another dataset containing validation data reserved for tuning processes such as early stopping and hyperparameter tuning.
+            Another dataset containing validation data reserved for tuning processes such as early stopping, hyperparameter tuning, and ensembling.
             This dataset should be in the same format as `train_data`.
             If str is passed, `tuning_data` will be loaded using the str value as the file path.
-            Note: final model returned may be fit on `tuning_data` as well as `train_data`. Do not provide your evaluation test data here!
-            In particular, when `num_bag_folds` > 0 or `num_stack_levels` > 0, models will be trained on both `tuning_data` and `train_data`.
-            If `tuning_data = None`, `fit()` will automatically hold out some random validation examples from `train_data`.
+            Note: If `refit_full=True` is specified, the final model may be fit on `tuning_data` as well as `train_data`.
+            Note: Because `tuning_data` is used to determine which model is the 'best' model, as well as to determine the ensemble weights,
+                it should not be considered a fully unseen dataset. It is possible that AutoGluon will be overfit to the `tuning_data`.
+                To ensure an unbiased evaluation, use separate unseen test data to evaluate the final model using `predictor.leaderboard(test_data, display=True)`.
+                Do not provide your evaluation test data as `tuning_data`!
+            If bagging is not enabled and `tuning_data = None`: `fit()` will automatically hold out some random validation samples from `train_data`.
+            If bagging is enabled  and `tuning_data = None`: no tuning data will be used. Instead, AutoGluon will perform cross-validation.
+            If bagging is enabled: `use_bag_holdout=True` must be specified in order to provide tuning data. If specified, AutoGluon will still perform cross-validation for model fits, but will use `tuning_data` for optimizing the weighted ensemble weights and model calibration.
         time_limit : int, default = None
             Approximately how long `fit()` should run for (wallclock time in seconds).
             If not specified, `fit()` will run until all models have completed training, but will not repeatedly bag models unless `num_bag_sets` is specified.
@@ -1121,10 +1130,6 @@ class TabularPredictor:
         self._validate_calibrate_decision_threshold(calibrate_decision_threshold=calibrate_decision_threshold)
         self._validate_fit_strategy(fit_strategy=fit_strategy)
 
-        holdout_frac = kwargs["holdout_frac"]
-        num_bag_folds = kwargs["num_bag_folds"]
-        num_bag_sets = kwargs["num_bag_sets"]
-        num_stack_levels = kwargs["num_stack_levels"]
         auto_stack = kwargs["auto_stack"]
         feature_generator = kwargs["feature_generator"]
         unlabeled_data = kwargs["unlabeled_data"]
@@ -1220,16 +1225,46 @@ class TabularPredictor:
         else:
             ag_args_fit = learning_curves
 
+        use_bag_holdout_was_auto = False
+        dynamic_stacking_was_auto = False
+        if isinstance(use_bag_holdout,str) and use_bag_holdout == "auto":
+            use_bag_holdout = None
+            use_bag_holdout_was_auto = True
+        if isinstance(dynamic_stacking,str) and dynamic_stacking == "auto":
+            dynamic_stacking = None
+            dynamic_stacking_was_auto = True
+
+        (
+            num_bag_folds,
+            num_bag_sets,
+            num_stack_levels,
+            dynamic_stacking,
+            use_bag_holdout,
+            holdout_frac,
+            refit_full,
+        ) = get_validation_and_stacking_method(
+            num_bag_folds=kwargs["num_bag_folds"],
+            num_bag_sets=kwargs["num_bag_sets"],
+            use_bag_holdout=use_bag_holdout,
+            holdout_frac=kwargs["holdout_frac"],
+            auto_stack=auto_stack,
+            num_stack_levels=kwargs["num_stack_levels"],
+            dynamic_stacking=dynamic_stacking,
+            refit_full=kwargs["refit_full"],
+            num_train_rows=len(train_data),
+            problem_type=inferred_problem_type,
+            hpo_enabled=ag_args.get("hyperparameter_tune_kwargs", None) is not None,
+        )
+
         num_bag_folds, num_bag_sets, num_stack_levels, dynamic_stacking, use_bag_holdout = self._sanitize_stack_args(
             num_bag_folds=num_bag_folds,
             num_bag_sets=num_bag_sets,
             num_stack_levels=num_stack_levels,
-            time_limit=time_limit,
-            auto_stack=auto_stack,
             num_train_rows=len(train_data),
-            problem_type=inferred_problem_type,
             dynamic_stacking=dynamic_stacking,
             use_bag_holdout=use_bag_holdout,
+            use_bag_holdout_was_auto=use_bag_holdout_was_auto,
+            dynamic_stacking_was_auto=dynamic_stacking_was_auto,
         )
         if auto_stack:
             logger.log(
@@ -1238,9 +1273,6 @@ class TabularPredictor:
                 f"num_stack_levels={num_stack_levels}, num_bag_folds={num_bag_folds}, num_bag_sets={num_bag_sets}",
             )
 
-        if holdout_frac is None:
-            holdout_frac = default_holdout_frac(len(train_data), ag_args.get("hyperparameter_tune_kwargs", None) is not None)
-
         if kwargs["save_bag_folds"] is not None and kwargs["_save_bag_folds"] is not None:
             raise ValueError(
                 f"Cannot specify both `save_bag_folds` and `_save_bag_folds` at the same time. "
@@ -1328,7 +1360,7 @@ class TabularPredictor:
         )
         ag_post_fit_kwargs = dict(
             keep_only_best=kwargs["keep_only_best"],
-            refit_full=kwargs["refit_full"],
+            refit_full=refit_full,
             set_best_to_refit_full=kwargs["set_best_to_refit_full"],
             save_space=kwargs["save_space"],
             calibrate=kwargs["calibrate"],
@@ -5489,41 +5521,12 @@ class TabularPredictor:
         num_bag_folds: int,
         num_bag_sets: int,
         num_stack_levels: int,
-        time_limit: float | None,
-        auto_stack: bool,
         num_train_rows: int,
-        problem_type: str,
         dynamic_stacking: bool | str,
         use_bag_holdout: bool | str,
+        use_bag_holdout_was_auto: bool,
+        dynamic_stacking_was_auto: bool,
     ):
-        use_bag_holdout_auto_threshold = 1000000
-        use_bag_holdout_was_auto = False
-        dynamic_stacking_was_auto = False
-        if isinstance(use_bag_holdout, str) and use_bag_holdout == "auto":
-            # Leverage use_bag_holdout when data is large to safeguard against stack leakage
-            use_bag_holdout = num_train_rows >= use_bag_holdout_auto_threshold
-            use_bag_holdout_was_auto = True
-        if isinstance(dynamic_stacking, str) and dynamic_stacking == "auto":
-            dynamic_stacking = not use_bag_holdout
-            dynamic_stacking_was_auto = True
-        if auto_stack:
-            # TODO: What about datasets that are 100k+? At a certain point should we not bag?
-            # TODO: What about time_limit? Metalearning can tell us expected runtime of each model, then we can select optimal folds + stack levels to fit time constraint
-            if num_bag_folds is None:
-                num_bag_folds = min(8, max(5, math.floor(num_train_rows / 10)))
-            if num_stack_levels is None:
-                if dynamic_stacking:
-                    num_stack_levels = 1
-                else:
-                    if use_bag_holdout or problem_type != BINARY:
-                        num_stack_levels = min(1, max(0, math.floor(num_train_rows / 750)))
-                    else:
-                        # Disable multi-layer stacking to avoid stack info leakage
-                        num_stack_levels = 0
-        if num_bag_folds is None:
-            num_bag_folds = 0
-        if num_stack_levels is None:
-            num_stack_levels = 0
         if not isinstance(num_bag_folds, int):
             raise ValueError(f"num_bag_folds must be an integer. (num_bag_folds={num_bag_folds})")
         if not isinstance(num_stack_levels, int):
@@ -5532,8 +5535,6 @@ class TabularPredictor:
             raise ValueError(f"num_bag_folds must be equal to 0 or >=2. (num_bag_folds={num_bag_folds})")
         if num_stack_levels != 0 and num_bag_folds == 0:
             raise ValueError(f"num_stack_levels must be 0 if num_bag_folds is 0. (num_stack_levels={num_stack_levels}, num_bag_folds={num_bag_folds})")
-        if num_bag_sets is None:
-            num_bag_sets = 1
         if not isinstance(num_bag_sets, int):
             raise ValueError(f"num_bag_sets must be an integer. (num_bag_sets={num_bag_sets})")
         if not isinstance(dynamic_stacking, bool):
@@ -5543,11 +5544,11 @@ class TabularPredictor:
 
         if use_bag_holdout_was_auto and num_bag_folds != 0:
             if use_bag_holdout:
-                log_extra = f"Reason: num_train_rows >= {use_bag_holdout_auto_threshold}. (num_train_rows={num_train_rows})"
+                log_extra = f"Reason: num_train_rows >= {USE_BAG_HOLDOUT_AUTO_THRESHOLD}. (num_train_rows={num_train_rows})"
             else:
-                log_extra = f"Reason: num_train_rows < {use_bag_holdout_auto_threshold}. (num_train_rows={num_train_rows})"
+                log_extra = f"Reason: num_train_rows < {USE_BAG_HOLDOUT_AUTO_THRESHOLD}. (num_train_rows={num_train_rows})"
             logger.log(20, f"Setting use_bag_holdout from 'auto' to {use_bag_holdout}. {log_extra}")
-        log_extra_ds = None
+
         if dynamic_stacking and num_stack_levels < 1:
             log_extra_ds = f"Reason: Stacking is not enabled. (num_stack_levels={num_stack_levels})"
             if not dynamic_stacking_was_auto:

{autogluon.tabular-1.4.1b20250819 → autogluon.tabular-1.4.1b20250821}/src/autogluon/tabular/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.4.1b20250819"
+__version__ = "1.4.1b20250821"
 __lite__ = False

{autogluon.tabular-1.4.1b20250819 → autogluon.tabular-1.4.1b20250821}/src/autogluon.tabular.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.4.1b20250819
+Version: 1.4.1b20250821
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community

{autogluon.tabular-1.4.1b20250819 → autogluon.tabular-1.4.1b20250821}/src/autogluon.tabular.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ src/autogluon/tabular/configs/__init__.py
 src/autogluon/tabular/configs/config_helper.py
 src/autogluon/tabular/configs/feature_generator_presets.py
 src/autogluon/tabular/configs/hyperparameter_configs.py
+src/autogluon/tabular/configs/pipeline_presets.py
 src/autogluon/tabular/configs/presets_configs.py
 src/autogluon/tabular/configs/zeroshot/__init__.py
 src/autogluon/tabular/configs/zeroshot/zeroshot_portfolio_2023.py

{autogluon.tabular-1.4.1b20250819 → autogluon.tabular-1.4.1b20250821}/src/autogluon.tabular.egg-info/requires.txt

@@ -3,24 +3,24 @@ scipy<1.17,>=1.5.4
 pandas<2.4.0,>=2.0.0
 scikit-learn<1.8.0,>=1.4.0
 networkx<4,>=3.0
-autogluon.core==1.4.1b20250819
-autogluon.features==1.4.1b20250819
+autogluon.core==1.4.1b20250821
+autogluon.features==1.4.1b20250821
 
 [all]
-omegaconf
-huggingface_hub[torch]
-einx
-numpy<2.3.0,>=1.25
+xgboost<3.1,>=2.0
 catboost<1.3,>=1.2
-einops<0.9,>=0.7
-autogluon.core[all]==1.4.1b20250819
-torch<2.8,>=2.6
+numpy<2.3.0,>=1.25
+transformers
+omegaconf
 loguru
-lightgbm<4.7,>=4.0
 spacy<3.9
-xgboost<3.1,>=2.0
+autogluon.core[all]==1.4.1b20250821
+torch<2.8,>=2.6
 fastai<2.9,>=2.3.1
-transformers
+einx
+huggingface_hub[torch]
+einops<0.9,>=0.7
+lightgbm<4.7,>=4.0
 
 [all:platform_system == "Windows" and python_version == "3.9"]
 blis<1.2.1,>=0.7.0
@@ -53,7 +53,7 @@ huggingface_hub[torch]
 einops<0.9,>=0.7
 
 [ray]
-autogluon.core[all]==1.4.1b20250819
+autogluon.core[all]==1.4.1b20250821
 
 [realmlp]
 pytabkit<1.7,>=1.6
@@ -73,23 +73,23 @@ onnx<1.18.0,>=1.13.0
 onnx<1.16.2,>=1.13.0
 
 [tabarena]
+xgboost<3.1,>=2.0
+catboost<1.3,>=1.2
+numpy<2.3.0,>=1.25
+transformers
 omegaconf
-huggingface_hub[torch]
+loguru
+spacy<3.9
+autogluon.core[all]==1.4.1b20250821
+tabpfn<2.2,>=2.0.9
+torch<2.8,>=2.6
+fastai<2.9,>=2.3.1
 einx
-numpy<2.3.0,>=1.25
-catboost<1.3,>=1.2
-einops<0.9,>=0.7
-autogluon.core[all]==1.4.1b20250819
+huggingface_hub[torch]
 tabicl<0.2,>=0.1.3
-torch<2.8,>=2.6
-tabpfn<2.2,>=2.0.9
 pytabkit<1.7,>=1.6
-loguru
+einops<0.9,>=0.7
 lightgbm<4.7,>=4.0
-spacy<3.9
-xgboost<3.1,>=2.0
-fastai<2.9,>=2.3.1
-transformers
 
 [tabarena:platform_system == "Windows" and python_version == "3.9"]
 blis<1.2.1,>=0.7.0