autogluon.tabular 1.2.1b20250305__py3-none-any.whl → 1.2.1b20250306__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
 import os
@@ -83,11 +84,14 @@ class MultiModalPredictorModel(AbstractModel):
         default_ag_args = super()._get_default_ag_args()
         extra_ag_args = {
             "valid_stacker": False,
-            "problem_types": [BINARY, MULTICLASS, REGRESSION],
         }
         default_ag_args.update(extra_ag_args)
         return default_ag_args
 
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]
+
     # FIXME: Enable parallel bagging once AutoMM supports being run within Ray without hanging
     @classmethod
     def _get_default_ag_args_ensemble(cls, **kwargs) -> dict:

autogluon/tabular/models/automm/ft_transformer.py

@@ -1,4 +1,5 @@
 """Wrapper of the MultiModalPredictor."""
+from __future__ import annotations
 
 import logging
 from typing import Dict

autogluon/tabular/models/catboost/catboost_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import math
 import os

autogluon/tabular/models/fasttext/fasttext_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 __all__ = ["FastTextModel"]
 
 import contextlib
@@ -49,10 +51,14 @@ class FastTextModel(AbstractModel):
     @classmethod
     def _get_default_ag_args(cls) -> dict:
         default_ag_args = super()._get_default_ag_args()
-        extra_ag_args = {"valid_stacker": False, "problem_types": [BINARY, MULTICLASS]}
+        extra_ag_args = {"valid_stacker": False}
         default_ag_args.update(extra_ag_args)
         return default_ag_args
 
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass"]
+
     def _fit(self, X, y, sample_weight=None, **kwargs):
         if self.problem_type not in (BINARY, MULTICLASS):
             raise ValueError("FastText model only supports binary or multiclass classification")

autogluon/tabular/models/image_prediction/image_predictor.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 
 import numpy as np
@@ -123,3 +125,7 @@ class ImagePredictorModel(MultiModalPredictorModel):
         else:
             raise NotImplementedError(f"Computing dummy pred_proba is not implemented for {self.problem_type}.")
         return pred_proba_mean
+
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]

autogluon/tabular/models/imodels/imodels_models.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from abc import abstractmethod
 
 import numpy as np
@@ -63,6 +65,10 @@ class _IModelsModel(AbstractModel):
         for param, val in default_params.items():
             self._set_default_param_value(param, val)
 
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]
+
     def _get_default_auxiliary_params(self) -> dict:
         default_auxiliary_params = super()._get_default_auxiliary_params()
         extra_auxiliary_params = dict(

autogluon/tabular/models/knn/knn_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import math
 import time

autogluon/tabular/models/lr/lr_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import re
 import time

autogluon/tabular/models/rf/rf_model.py

@@ -399,8 +399,10 @@ class RFModel(AbstractModel):
             tags["valid_oof"] = True
         return tags
 
-    def _valid_compilers(self):
+    @classmethod
+    def _valid_compilers(cls):
         return [RFNativeCompiler, RFOnnxCompiler]
 
-    def _default_compiler(self):
+    @classmethod
+    def _default_compiler(cls):
         return RFNativeCompiler

autogluon/tabular/models/tab_transformer/tab_transformer_model.py

@@ -1,4 +1,5 @@
 """TabTransformer model"""
+from __future__ import annotations
 
 import logging
 import os
@@ -486,6 +487,10 @@ class TabTransformerModel(AbstractNeuralNetworkModel):
     def _get_default_searchspace(self):
         return get_default_searchspace()
 
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]
+
     def save(self, path: str = None, verbose=True) -> str:
         import torch
 

autogluon/tabular/models/tabpfn/tabpfn_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import numpy as np
 import pandas as pd
 
@@ -97,13 +99,8 @@ class TabPFNModel(AbstractModel):
             self._set_default_param_value(param, val)
 
     @classmethod
-    def _get_default_ag_args(cls) -> dict:
-        default_ag_args = super()._get_default_ag_args()
-        extra_ag_args = {
-            "problem_types": [BINARY, MULTICLASS],
-        }
-        default_ag_args.update(extra_ag_args)
-        return default_ag_args
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass"]
 
     def _get_default_auxiliary_params(self) -> dict:
         """

autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py

@@ -297,13 +297,8 @@ class TabPFNMixModel(AbstractModel):
         return os.path.join(self.path, self.weights_file_name)
 
     @classmethod
-    def _get_default_ag_args(cls) -> dict:
-        default_ag_args = super()._get_default_ag_args()
-        extra_ag_args = {
-            "problem_types": [BINARY, MULTICLASS, REGRESSION],
-        }
-        default_ag_args.update(extra_ag_args)
-        return default_ag_args
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]
 
     def _get_default_auxiliary_params(self) -> dict:
         default_auxiliary_params = super()._get_default_auxiliary_params()
@@ -314,15 +309,6 @@ class TabPFNMixModel(AbstractModel):
         )
         return default_auxiliary_params
 
-    @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 = {
-           #  "fold_fitting_strategy": "sequential_local",  # FIXME: Comment out after debugging for large speedup
-        }
-        default_ag_args_ensemble.update(extra_ag_args_ensemble)
-        return default_ag_args_ensemble
-
     def _get_maximum_resources(self) -> dict[str, int | float]:
         # torch model trains slower when utilizing virtual cores and this issue scale up when the number of cpu cores increases
         return {"num_cpus": ResourceManager.get_cpu_count_psutil(logical=False)}

autogluon/tabular/models/tabular_nn/torch/tabular_nn_torch.py

@@ -897,10 +897,12 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
             minimum_resources["num_gpus"] = 1
         return minimum_resources
 
-    def _valid_compilers(self):
+    @classmethod
+    def _valid_compilers(cls):
         return [TabularNeuralNetTorchNativeCompiler, TabularNeuralNetTorchOnnxCompiler]
 
-    def _default_compiler(self):
+    @classmethod
+    def _default_compiler(cls):
         return TabularNeuralNetTorchNativeCompiler
 
     def _ag_params(self) -> set:

autogluon/tabular/models/text_prediction/text_prediction_v1_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 
 from autogluon.common.features.types import (
@@ -30,3 +32,7 @@ class TextPredictorModel(MultiModalPredictorModel):
         )
         default_auxiliary_params.update(extra_auxiliary_params)
         return default_auxiliary_params
+
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]

autogluon/tabular/models/vowpalwabbit/vowpalwabbit_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import os
 import time
@@ -267,11 +269,14 @@ class VowpalWabbitModel(AbstractModel):
         default_ag_args = super()._get_default_ag_args()
         extra_ag_args = {
             "valid_stacker": False,
-            "problem_types": [BINARY, MULTICLASS, REGRESSION],
         }
         default_ag_args.update(extra_ag_args)
         return default_ag_args
 
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]
+
     def _more_tags(self):
         # `can_refit_full=True` because best epoch is communicated at end of `_fit`: `self.params_trained['passes'] = epoch`
         return {"can_refit_full": True}

autogluon/tabular/models/xgboost/xgboost_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import math
 import os
@@ -141,10 +143,11 @@ class XGBoostModel(AbstractModel):
                 eval_set["test"] = (X_test, y_test)
 
         if num_gpus != 0:
-            params["tree_method"] = "gpu_hist"
-            if "gpu_id" not in params:
-                params["gpu_id"] = 0
-        elif "tree_method" not in params:
+            if "device" not in params:
+                # FIXME: figure out which GPUs are available to this model instead of hardcoding GPU 0.
+                #  Need to update BaggedEnsembleModel
+                params["device"] = "cuda:0"
+        if "tree_method" not in params:
             params["tree_method"] = "hist"
 
         try_import_xgboost()

autogluon/tabular/models/xt/xt_model.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from autogluon.core.constants import QUANTILE, REGRESSION
 
 from ..rf.rf_model import RFModel

autogluon/tabular/testing/__init__.py

@@ -0,0 +1,2 @@
+from .fit_helper import FitHelper
+from .model_fit_helper import ModelFitHelper

autogluon/tabular/testing/fit_helper.py

@@ -0,0 +1,476 @@
+from __future__ import annotations
+
+import copy
+import os
+import pandas as pd
+import shutil
+import uuid
+from typing import Any, Type
+
+from autogluon.common.utils.path_converter import PathConverter
+from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION
+from autogluon.core.metrics import METRICS
+from autogluon.core.models import AbstractModel, BaggedEnsembleModel
+from autogluon.core.stacked_overfitting.utils import check_stacked_overfitting_from_leaderboard
+from autogluon.core.utils import download, generate_train_test_split_combined, infer_problem_type, unzip
+
+from autogluon.tabular import TabularDataset, TabularPredictor
+from autogluon.tabular.testing.generate_datasets import (
+    generate_toy_binary_dataset,
+    generate_toy_binary_10_dataset,
+    generate_toy_multiclass_dataset,
+    generate_toy_regression_dataset,
+    generate_toy_quantile_dataset,
+    generate_toy_multiclass_10_dataset,
+    generate_toy_regression_10_dataset,
+    generate_toy_quantile_10_dataset,
+    generate_toy_multiclass_30_dataset,
+)
+
+
+class DatasetLoaderHelper:
+    dataset_info_dict = dict(
+        # Binary dataset
+        adult={
+            "url": "https://autogluon.s3.amazonaws.com/datasets/AdultIncomeBinaryClassification.zip",
+            "name": "AdultIncomeBinaryClassification",
+            "problem_type": BINARY,
+            "label": "class",
+        },
+        # Multiclass big dataset with 7 classes, all features are numeric. Runs SLOW.
+        covertype={
+            "url": "https://autogluon.s3.amazonaws.com/datasets/CoverTypeMulticlassClassification.zip",
+            "name": "CoverTypeMulticlassClassification",
+            "problem_type": MULTICLASS,
+            "label": "Cover_Type",
+        },
+        # Subset of covertype dataset with 3k train/test rows. Ratio of labels is preserved.
+        covertype_small={
+            "url": "https://autogluon.s3.amazonaws.com/datasets/CoverTypeMulticlassClassificationSmall.zip",
+            "name": "CoverTypeMulticlassClassificationSmall",
+            "problem_type": MULTICLASS,
+            "label": "Cover_Type",
+        },
+        # Regression with mixed feature-types, skewed Y-values.
+        ames={
+            "url": "https://autogluon.s3.amazonaws.com/datasets/AmesHousingPriceRegression.zip",
+            "name": "AmesHousingPriceRegression",
+            "problem_type": REGRESSION,
+            "label": "SalePrice",
+        },
+        # Regression with multiple text field and categorical
+        sts={
+            "url": "https://autogluon-text.s3.amazonaws.com/glue_sts.zip",
+            "name": "glue_sts",
+            "problem_type": REGRESSION,
+            "label": "score",
+        },
+    )
+
+    toy_map = dict(
+        toy_binary=generate_toy_binary_dataset,
+        toy_multiclass=generate_toy_multiclass_dataset,
+        toy_regression=generate_toy_regression_dataset,
+        toy_quantile=generate_toy_quantile_dataset,
+        toy_binary_10=generate_toy_binary_10_dataset,
+        toy_multiclass_10=generate_toy_multiclass_10_dataset,
+        toy_regression_10=generate_toy_regression_10_dataset,
+        toy_quantile_10=generate_toy_quantile_10_dataset,
+        toy_multiclass_30=generate_toy_multiclass_30_dataset,
+    )
+
+    @staticmethod
+    def load_dataset(name: str, directory_prefix: str = "./datasets/") -> tuple[pd.DataFrame, pd.DataFrame, dict]:
+        if name in DatasetLoaderHelper.toy_map:
+            return DatasetLoaderHelper.toy_map[name]()
+        dataset_info = copy.deepcopy(DatasetLoaderHelper.dataset_info_dict[name])
+        train_file = dataset_info.pop("train_file", "train_data.csv")
+        test_file = dataset_info.pop("test_file", "test_data.csv")
+        name_inner = dataset_info.pop("name")
+        url = dataset_info.pop("url", None)
+        train_data, test_data = DatasetLoaderHelper.load_data(
+            directory_prefix=directory_prefix,
+            train_file=train_file,
+            test_file=test_file,
+            name=name_inner,
+            url=url,
+        )
+
+        return train_data, test_data, dataset_info
+
+    # TODO: Refactor this eventually, this is old code from 2019 that can be improved (use consistent local path for datasets, don't assume zip files, etc.)
+    @staticmethod
+    def load_data(
+        directory_prefix: str,
+        train_file: str,
+        test_file: str,
+        name: str,
+        url: str | None = None,
+    ) -> tuple[pd.DataFrame, pd.DataFrame]:
+        """
+        Will check if files exist locally for:
+            directory_prefix/name/train_file
+            directory_prefix/name/test_file
+        If either don't exist, then download the files from the `url` location.
+        Then, load both train and test data and return them.
+
+        Parameters
+        ----------
+        directory_prefix
+        train_file
+        test_file
+        name
+        url
+
+        Returns
+        -------
+        train_data: pd.DataFrame
+        test_data: pd.DataFrame
+        """
+        if not os.path.exists(directory_prefix):
+            os.mkdir(directory_prefix)
+        directory = directory_prefix + name + "/"
+        train_file_path = directory + train_file
+        test_file_path = directory + test_file
+        if (not os.path.exists(train_file_path)) or (not os.path.exists(test_file_path)):
+            # fetch files from s3:
+            print("%s data not found locally, so fetching from %s" % (name, url))
+            zip_name = download(url, directory_prefix)
+            unzip(zip_name, directory_prefix)
+            os.remove(zip_name)
+
+        train_data = TabularDataset(train_file_path)
+        test_data = TabularDataset(test_file_path)
+        return train_data, test_data
+
+
+class FitHelper:
+    """
+    Helper functions to test and verify predictors and models when fit through TabularPredictor's API.
+    """
+    @staticmethod
+    def fit_and_validate_dataset(
+        dataset_name: str,
+        fit_args: dict[str, Any],
+        init_args: dict[str, Any] | None = None,
+        sample_size: int | None = 1000,  # FIXME: default to None
+        refit_full: bool = True,
+        delete_directory: bool = True,
+        extra_metrics: list[str] | None = None,
+        extra_info: bool = False,
+        predictor_info: bool = False,
+        expected_model_count: int | None = 2,
+        fit_weighted_ensemble: bool = True,
+        min_cls_count_train: int = 1,
+        path_as_absolute: bool = False,
+        compile: bool = False,
+        compiler_configs: dict | None = None,
+        allowed_dataset_features: list[str] | None = None,
+        expected_stacked_overfitting_at_test: bool | None = None,
+        expected_stacked_overfitting_at_val: bool | None = None,
+        scikit_api: bool = False,
+        use_test_data: bool = False,
+        use_test_for_val: bool = False,
+        raise_on_model_failure: bool | None = None,
+        deepcopy_fit_args: bool = True,
+    ) -> TabularPredictor:
+        if compiler_configs is None:
+            compiler_configs = {}
+        directory_prefix = "./datasets/"
+        train_data, test_data, dataset_info = DatasetLoaderHelper.load_dataset(name=dataset_name, directory_prefix=directory_prefix)
+        label = dataset_info["label"]
+        problem_type = dataset_info["problem_type"]
+        _init_args = dict(
+            label=label,
+            problem_type=problem_type,
+        )
+        if "init_kwargs" in dataset_info:
+            _init_args.update(dataset_info["init_kwargs"])
+        if allowed_dataset_features is not None:
+            train_data = train_data[allowed_dataset_features + [label]]
+            test_data = test_data[allowed_dataset_features + [label]]
+
+        if init_args is None:
+            init_args = _init_args
+        else:
+            init_args = copy.deepcopy(init_args)
+            _init_args.update(init_args)
+            init_args = _init_args
+        if "path" not in init_args:
+            init_args["path"] = os.path.join(directory_prefix, dataset_name, f"AutogluonOutput_{uuid.uuid4()}")
+        if path_as_absolute:
+            init_args["path"] = PathConverter.to_absolute(path=init_args["path"])
+            assert PathConverter._is_absolute(path=init_args["path"])
+        save_path = init_args["path"]
+
+        if deepcopy_fit_args:
+            fit_args = copy.deepcopy(fit_args)
+        if use_test_data:
+            fit_args["test_data"] = test_data
+            if use_test_for_val:
+                fit_args["tuning_data"] = test_data
+        if raise_on_model_failure is not None and "raise_on_model_failure" not in fit_args:
+            fit_args["raise_on_model_failure"] = raise_on_model_failure
+        if "fit_weighted_ensemble" not in fit_args:
+            if not fit_weighted_ensemble and expected_model_count is not None:
+                expected_model_count -= 1
+            fit_args["fit_weighted_ensemble"] = fit_weighted_ensemble
+
+        predictor: TabularPredictor = FitHelper.fit_dataset(
+            train_data=train_data,
+            init_args=init_args,
+            fit_args=fit_args,
+            sample_size=sample_size,
+            scikit_api=scikit_api,
+            min_cls_count_train=min_cls_count_train,
+        )
+        if compile:
+            predictor.compile(models="all", compiler_configs=compiler_configs)
+            predictor.persist(models="all")
+        if sample_size is not None and sample_size < len(test_data):
+            test_data = test_data.sample(n=sample_size, random_state=0)
+        predictor.predict(test_data)
+        predictor.evaluate(test_data)
+
+        if predictor.can_predict_proba:
+            pred_proba = predictor.predict_proba(test_data)
+            predictor.evaluate_predictions(y_true=test_data[label], y_pred=pred_proba)
+        else:
+            try:
+                predictor.predict_proba(test_data)
+            except AssertionError:
+                pass  # expected
+            else:
+                raise AssertionError("Expected `predict_proba` to raise AssertionError, but it didn't!")
+
+        model_names = predictor.model_names()
+        model_name = model_names[0]
+        if expected_model_count is not None:
+            assert len(model_names) == expected_model_count
+        if refit_full:
+            refit_model_names = predictor.refit_full()
+            if expected_model_count is not None:
+                assert len(refit_model_names) == expected_model_count
+            refit_model_name = refit_model_names[model_name]
+            assert "_FULL" in refit_model_name
+            predictor.predict(test_data, model=refit_model_name)
+            if predictor.can_predict_proba:
+                predictor.predict_proba(test_data, model=refit_model_name)
+
+            # verify that val_in_fit is False if the model supports refit_full
+            model = predictor._trainer.load_model(refit_model_name)
+            if isinstance(model, BaggedEnsembleModel):
+                model = model.load_child(model.models[0])
+            model_info = model.get_info()
+            can_refit_full = model._get_tags()["can_refit_full"]
+            if can_refit_full:
+                assert not model_info["val_in_fit"], f"val data must not be present in refit model if `can_refit_full=True`. Maybe an exception occurred?"
+            else:
+                assert model_info["val_in_fit"], f"val data must be present in refit model if `can_refit_full=False`"
+
+        if predictor_info:
+            predictor.info()
+        lb_kwargs = {}
+        if extra_info:
+            lb_kwargs["extra_info"] = True
+        lb = predictor.leaderboard(test_data, extra_metrics=extra_metrics, **lb_kwargs)
+        stacked_overfitting_assert(lb, predictor, expected_stacked_overfitting_at_val, expected_stacked_overfitting_at_test)
+
+        predictor_load = predictor.load(path=predictor.path)
+        predictor_load.predict(test_data)
+
+        assert os.path.realpath(save_path) == os.path.realpath(predictor.path)
+        if delete_directory:
+            shutil.rmtree(save_path, ignore_errors=True)  # Delete AutoGluon output directory to ensure runs' information has been removed.
+        return predictor
+
+    @staticmethod
+    def load_dataset(name: str, directory_prefix: str = "./datasets/") -> tuple[pd.DataFrame, pd.DataFrame, dict]:
+        return DatasetLoaderHelper.load_dataset(name=name, directory_prefix=directory_prefix)
+
+    @staticmethod
+    def fit_dataset(
+        train_data: pd.DataFrame,
+        init_args: dict[str, Any],
+        fit_args: dict[str, Any],
+        sample_size: int | None = None,
+        min_cls_count_train: int = 1,
+        scikit_api: bool = False,
+    ) -> TabularPredictor:
+        if "problem_type" in init_args:
+            problem_type = init_args["problem_type"]
+        else:
+            problem_type = infer_problem_type(train_data[init_args["label"]])
+
+        if sample_size is not None and sample_size < len(train_data):
+            train_data, _ = generate_train_test_split_combined(
+                data=train_data,
+                label=init_args["label"],
+                problem_type=problem_type,
+                test_size=len(train_data) - sample_size,
+                min_cls_count_train=min_cls_count_train,
+            )
+
+        if scikit_api:
+            from autogluon.tabular.experimental import TabularClassifier, TabularRegressor
+
+            X = train_data.drop(columns=[init_args["label"]])
+            y = train_data[init_args["label"]]
+            if problem_type in [REGRESSION]:
+                regressor = TabularRegressor(init_args=init_args, fit_args=fit_args)
+                regressor.fit(X, y)
+                return regressor.predictor_
+            else:
+                classifier = TabularClassifier(init_args=init_args, fit_args=fit_args)
+                classifier.fit(X, y)
+                return classifier.predictor_
+        else:
+            return TabularPredictor(**init_args).fit(train_data, **fit_args)
+
+    @staticmethod
+    def verify_model(
+        model_cls: Type[AbstractModel],
+        model_hyperparameters: dict[str, Any],
+        bag: bool | str = "first",
+        refit_full: bool | str = "first",
+        extra_metrics: bool = False,
+        require_known_problem_types: bool = True,
+        raise_on_model_failure: bool = True,
+        problem_types: list[str] | None = None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        model_cls
+        model_hyperparameters
+        bag
+        refit_full
+        extra_metrics
+        require_known_problem_types
+        raise_on_model_failure
+        problem_types: list[str], optional
+            If specified, checks the given problem_types.
+            If None, checks `model_cls.supported_problem_types()`
+        **kwargs
+
+        Returns
+        -------
+
+        """
+        fit_args = dict(
+            hyperparameters={model_cls: model_hyperparameters},
+        )
+        supported_problem_types = model_cls.supported_problem_types()
+        if supported_problem_types is None:
+            raise AssertionError(
+                f"Model must specify `cls.supported_problem_types`"
+                f"""\nExample code:
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression", "quantile"]
+        """
+            )
+        assert isinstance(supported_problem_types, list)
+        assert len(supported_problem_types) > 0
+
+        known_problem_types = [
+            "binary",
+            "multiclass",
+            "regression",
+            "quantile",
+            "softclass",
+        ]
+
+        if require_known_problem_types:
+            for problem_type in supported_problem_types:
+                if problem_type not in known_problem_types:
+                    raise AssertionError(
+                        f"Model {model_cls.__name__} supports an unknown problem_type: {problem_type}"
+                        f"\nKnown problem types: {known_problem_types}"
+                        f"\nEither remove the unknown problem_type from `model_cls.supported_problem_types` or set `require_known_problem_types=False`"
+                    )
+
+        problem_type_dataset_map = {
+            "binary": "toy_binary",
+            "multiclass": "toy_multiclass",
+            "regression": "toy_regression",
+            "quantile": "toy_quantile",
+        }
+
+        problem_types_refit_full = []
+        if refit_full:
+            if isinstance(refit_full, bool):
+                problem_types_refit_full = supported_problem_types
+            elif refit_full == "first":
+                problem_types_refit_full = supported_problem_types[:1]
+
+        if problem_types is None:
+            problem_types_to_check = supported_problem_types
+        else:
+            problem_types_to_check = problem_types
+
+        for problem_type in problem_types_to_check:
+            if problem_type not in problem_type_dataset_map:
+                print(f"WARNING: Skipping check on problem_type='{problem_type}': No dataset available")
+                continue
+            _extra_metrics = None
+            if extra_metrics:
+                _extra_metrics = METRICS.get(problem_type, None)
+            refit_full = problem_type in problem_types_refit_full
+            dataset_name = problem_type_dataset_map[problem_type]
+            FitHelper.fit_and_validate_dataset(
+                dataset_name=dataset_name,
+                fit_args=fit_args,
+                fit_weighted_ensemble=False,
+                refit_full=refit_full,
+                extra_metrics=_extra_metrics,
+                raise_on_model_failure=raise_on_model_failure,
+                **kwargs,
+            )
+
+        if bag:
+            model_params_bag = copy.deepcopy(model_hyperparameters)
+            model_params_bag["ag_args_ensemble"] = {"fold_fitting_strategy": "sequential_local"}
+            fit_args_bag = dict(
+                hyperparameters={model_cls: model_params_bag},
+                num_bag_folds=2,
+                num_bag_sets=1,
+            )
+            if isinstance(bag, bool):
+                problem_types_bag = supported_problem_types
+            elif bag == "first":
+                problem_types_bag = supported_problem_types[:1]
+            else:
+                raise ValueError(f"Unknown 'bag' value: {bag}")
+
+            for problem_type in problem_types_bag:
+                _extra_metrics = None
+                if extra_metrics:
+                    _extra_metrics = METRICS.get(problem_type, None)
+                refit_full = problem_type in problem_types_refit_full
+                dataset_name = problem_type_dataset_map[problem_type]
+                FitHelper.fit_and_validate_dataset(
+                    dataset_name=dataset_name,
+                    fit_args=fit_args_bag,
+                    fit_weighted_ensemble=False,
+                    refit_full=refit_full,
+                    extra_metrics=_extra_metrics,
+                    raise_on_model_failure=raise_on_model_failure,
+                    **kwargs,
+                )
+
+
+def stacked_overfitting_assert(
+    lb: pd.DataFrame,
+    predictor: TabularPredictor,
+    expected_stacked_overfitting_at_val: bool | None,
+    expected_stacked_overfitting_at_test: bool | None,
+):
+    if expected_stacked_overfitting_at_val is not None:
+        assert predictor._stacked_overfitting_occurred == expected_stacked_overfitting_at_val, "Expected stacked overfitting at val mismatch!"
+
+    if expected_stacked_overfitting_at_test is not None:
+        stacked_overfitting = check_stacked_overfitting_from_leaderboard(lb)
+        assert stacked_overfitting == expected_stacked_overfitting_at_test, "Expected stacked overfitting at test mismatch!"

autogluon/tabular/testing/generate_datasets.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import pandas as pd
+from sklearn.datasets import make_blobs
+
+from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION, QUANTILE
+
+
+def generate_toy_binary_dataset():
+    label = "label"
+    dummy_dataset = {
+        "int": [0, 1, 2, 3],
+        label: [0, 0, 1, 1],
+    }
+
+    dataset_info = {
+        "problem_type": BINARY,
+        "label": label,
+    }
+
+    train_data = pd.DataFrame(dummy_dataset)
+    test_data = train_data
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_multiclass_dataset():
+    label = "label"
+    dummy_dataset = {
+        "int": [0, 1, 2, 3, 4, 5],
+        label: [0, 0, 1, 1, 2, 2],
+    }
+
+    dataset_info = {
+        "problem_type": MULTICLASS,
+        "label": label,
+    }
+
+    train_data = pd.DataFrame(dummy_dataset)
+    test_data = train_data
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_regression_dataset():
+    label = "label"
+    dummy_dataset = {
+        "int": [0, 1, 2, 3],
+        label: [0.1, 0.9, 1.1, 1.9],
+    }
+
+    dataset_info = {
+        "problem_type": REGRESSION,
+        "label": label,
+    }
+
+    train_data = pd.DataFrame(dummy_dataset)
+    test_data = train_data
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_quantile_dataset():
+    train_data, test_data, dataset_info = generate_toy_regression_dataset()
+    dataset_info["problem_type"] = QUANTILE
+    dataset_info["init_kwargs"] = {"quantile_levels": [0.25, 0.5, 0.75]}
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_binary_10_dataset():
+    label = "label"
+    dummy_dataset = {
+        "int": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+        label: [0, 0, 1, 1, 0, 0, 1, 1, 0, 0],
+    }
+
+    dataset_info = {
+        "problem_type": BINARY,
+        "label": label,
+    }
+
+    train_data = pd.DataFrame(dummy_dataset)
+    test_data = train_data
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_multiclass_10_dataset():
+    label = "label"
+    dummy_dataset = {
+        "int": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+        label: [0, 0, 1, 1, 2, 2, 0, 0, 1, 1],
+    }
+
+    dataset_info = {
+        "problem_type": MULTICLASS,
+        "label": label,
+    }
+
+    train_data = pd.DataFrame(dummy_dataset)
+    test_data = train_data
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_regression_10_dataset():
+    label = "label"
+    dummy_dataset = {
+        "int": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+        label: [0.1, 0.9, 1.1, 1.9, 0.2, 0.8, 1.2, 1.8, -0.1, 0.7],
+    }
+
+    dataset_info = {
+        "problem_type": REGRESSION,
+        "label": label,
+    }
+
+    train_data = pd.DataFrame(dummy_dataset)
+    test_data = train_data
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_quantile_10_dataset():
+    train_data, test_data, dataset_info = generate_toy_regression_10_dataset()
+    dataset_info["problem_type"] = QUANTILE
+    dataset_info["init_kwargs"] = {"quantile_levels": [0.25, 0.5, 0.75]}
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_multiclass_30_dataset():
+    label = "label"
+    train_data = generate_toy_multiclass_n_dataset(n_samples=30, n_features=2, n_classes=3)
+    test_data = train_data
+
+    dataset_info = {
+        "problem_type": MULTICLASS,
+        "label": label,
+    }
+    return train_data, test_data, dataset_info
+
+
+def generate_toy_multiclass_n_dataset(n_samples, n_features, n_classes) -> pd.DataFrame:
+    X, y = make_blobs(centers=n_classes, n_samples=n_samples, n_features=n_features, cluster_std=0.5, random_state=0)
+    data = pd.DataFrame(X)
+    data["label"] = y
+    return data

autogluon/tabular/testing/model_fit_helper.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+import numpy as np
+import pandas as pd
+
+from autogluon.core.data.label_cleaner import LabelCleaner
+from autogluon.core.models import AbstractModel, BaggedEnsembleModel
+from autogluon.core.utils import generate_train_test_split, infer_problem_type
+from autogluon.features.generators import AbstractFeatureGenerator, AutoMLPipelineFeatureGenerator
+
+from autogluon.tabular.testing.fit_helper import FitHelper
+
+
+# Helper functions for training models outside of predictors
+class ModelFitHelper:
+    """
+    Helper functions to test and verify models when fit outside TabularPredictor's API (aka as stand-alone models)
+    """
+    @staticmethod
+    def fit_and_validate_dataset(
+        dataset_name: str,
+        model: AbstractModel,
+        fit_args: dict,
+        sample_size: int = 1000,
+        check_predict_children: bool = False,
+    ) -> AbstractModel:
+        directory_prefix = "./datasets/"
+        train_data, test_data, dataset_info = FitHelper.load_dataset(name=dataset_name, directory_prefix=directory_prefix)
+        label = dataset_info["label"]
+        model, label_cleaner, feature_generator = ModelFitHelper.fit_dataset(
+            train_data=train_data, model=model, label=label, fit_args=fit_args, sample_size=sample_size
+        )
+        if sample_size is not None and sample_size < len(test_data):
+            test_data = test_data.sample(n=sample_size, random_state=0)
+
+        X_test = test_data.drop(columns=[label])
+        X_test = feature_generator.transform(X_test)
+
+        y_pred = model.predict(X_test)
+        assert isinstance(y_pred, np.ndarray), f"Expected np.ndarray as model.predict(X_test) output. Got: {y_pred.__class__}"
+
+        y_pred_proba = model.predict_proba(X_test)
+        assert isinstance(y_pred_proba, np.ndarray), f"Expected np.ndarray as model.predict_proba(X_test) output. Got: {y_pred.__class__}"
+        model.get_info()
+
+        if check_predict_children:
+            assert isinstance(model, BaggedEnsembleModel)
+            y_pred_children = model.predict_children(X_test)
+            assert len(y_pred_children) == model.n_children
+            if model.can_predict_proba:
+                y_pred_proba_children = model.predict_proba_children(X_test)
+                assert len(y_pred_proba_children) == model.n_children
+                y_pred_proba_from_children = np.mean(y_pred_proba_children, axis=0)
+                assert np.isclose(y_pred_proba_from_children, y_pred_proba).all()
+
+                for y_pred_proba_child, y_pred_child in zip(y_pred_proba_children, y_pred_children):
+                    y_pred_child_from_proba = model.predict_from_proba(y_pred_proba=y_pred_proba_child)
+                    assert np.isclose(y_pred_child_from_proba, y_pred_child).all()
+
+        return model
+
+    @staticmethod
+    def fit_dataset(
+        train_data: pd.DataFrame,
+        model: AbstractModel,
+        label: str,
+        fit_args: dict,
+        sample_size: int = None,
+    ) -> Tuple[AbstractModel, LabelCleaner, AbstractFeatureGenerator]:
+        if sample_size is not None and sample_size < len(train_data):
+            train_data = train_data.sample(n=sample_size, random_state=0)
+        X = train_data.drop(columns=[label])
+        y = train_data[label]
+
+        problem_type = infer_problem_type(y)
+        label_cleaner = LabelCleaner.construct(problem_type=problem_type, y=y)
+        y = label_cleaner.transform(y)
+        feature_generator = AutoMLPipelineFeatureGenerator()
+        X = feature_generator.fit_transform(X, y)
+
+        X, X_val, y, y_val = generate_train_test_split(X, y, problem_type=problem_type, test_size=0.2, random_state=0)
+
+        model.fit(X=X, y=y, X_val=X_val, y_val=y_val, **fit_args)
+        return model, label_cleaner, feature_generator

autogluon/tabular/version.py

@@ -1,4 +1,4 @@
 """This is the autogluon version file."""
 
-__version__ = "1.2.1b20250305"
+__version__ = "1.2.1b20250306"
 __lite__ = False

{autogluon.tabular-1.2.1b20250305.dist-info → autogluon.tabular-1.2.1b20250306.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.2.1b20250305
+Version: 1.2.1b20250306
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -41,19 +41,19 @@ Requires-Dist: scipy<1.16,>=1.5.4
 Requires-Dist: pandas<2.3.0,>=2.0.0
 Requires-Dist: scikit-learn<1.5.3,>=1.4.0
 Requires-Dist: networkx<4,>=3.0
-Requires-Dist: autogluon.core==1.2.1b20250305
-Requires-Dist: autogluon.features==1.2.1b20250305
+Requires-Dist: autogluon.core==1.2.1b20250306
+Requires-Dist: autogluon.features==1.2.1b20250306
 Provides-Extra: all
-Requires-Dist: catboost<1.3,>=1.2; extra == "all"
-Requires-Dist: numpy<2.0.0,>=1.25; extra == "all"
-Requires-Dist: lightgbm<4.6,>=4.0; extra == "all"
 Requires-Dist: spacy<3.8; extra == "all"
-Requires-Dist: autogluon.core[all]==1.2.1b20250305; extra == "all"
+Requires-Dist: catboost<1.3,>=1.2; extra == "all"
+Requires-Dist: torch<2.6,>=2.2; extra == "all"
 Requires-Dist: fastai<2.8,>=2.3.1; extra == "all"
-Requires-Dist: xgboost<2.2,>=1.6; extra == "all"
-Requires-Dist: einops<0.9,>=0.7; extra == "all"
 Requires-Dist: huggingface-hub[torch]; extra == "all"
-Requires-Dist: torch<2.6,>=2.2; extra == "all"
+Requires-Dist: lightgbm<4.6,>=4.0; extra == "all"
+Requires-Dist: autogluon.core[all]==1.2.1b20250306; extra == "all"
+Requires-Dist: einops<0.9,>=0.7; extra == "all"
+Requires-Dist: numpy<2.0.0,>=1.25; extra == "all"
+Requires-Dist: xgboost<2.2,>=2.0; extra == "all"
 Provides-Extra: catboost
 Requires-Dist: numpy<2.0.0,>=1.25; extra == "catboost"
 Requires-Dist: catboost<1.3,>=1.2; extra == "catboost"
@@ -66,7 +66,7 @@ Requires-Dist: imodels<1.4.0,>=1.3.10; extra == "imodels"
 Provides-Extra: lightgbm
 Requires-Dist: lightgbm<4.6,>=4.0; extra == "lightgbm"
 Provides-Extra: ray
-Requires-Dist: autogluon.core[all]==1.2.1b20250305; extra == "ray"
+Requires-Dist: autogluon.core[all]==1.2.1b20250306; extra == "ray"
 Provides-Extra: skex
 Requires-Dist: scikit-learn-intelex<2025.1,>=2024.0; extra == "skex"
 Provides-Extra: skl2onnx
@@ -96,7 +96,7 @@ Requires-Dist: vowpalwabbit<9.10,>=9; (python_version < "3.11" and sys_platform
 Provides-Extra: vowpalwabbit
 Requires-Dist: vowpalwabbit<9.10,>=9; (python_version < "3.11" and sys_platform != "darwin") and extra == "vowpalwabbit"
 Provides-Extra: xgboost
-Requires-Dist: xgboost<2.2,>=1.6; extra == "xgboost"
+Requires-Dist: xgboost<2.2,>=2.0; extra == "xgboost"
 
 
 

{autogluon.tabular-1.2.1b20250305.dist-info → autogluon.tabular-1.2.1b20250306.dist-info}/RECORD

@@ -1,6 +1,6 @@
-autogluon.tabular-1.2.1b20250305-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.tabular-1.2.1b20250306-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/tabular/__init__.py,sha256=2OXpJCvENRHubBTYNIPpHX93WWuFZzsJBtTZbNVHVas,400
-autogluon/tabular/version.py,sha256=hjp__CpU1tLt2wGIEfd4tVSKrES_x0vHTkZdLuoYGnE,91
+autogluon/tabular/version.py,sha256=vpLPQw8Tz1FiEFDl7STt_ZrtxXTVYzhhywUGcg_8Fec,91
 autogluon/tabular/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/configs/config_helper.py,sha256=Pb2aW9Z9w77pYKPRVZ3nBzHY3KJaiEJSJ747zZcJIVk,21132
 autogluon/tabular/configs/feature_generator_presets.py,sha256=EV5Ym8VW15q92MwOUpTi7wZFS2QooM51fLg3RdUsn-M,1223
@@ -21,11 +21,11 @@ autogluon/tabular/models/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 autogluon/tabular/models/_utils/rapids_utils.py,sha256=gbej9Hjn4alCWZuGN9sOLXMMAyWbgHPThTsp2feS39o,1038
 autogluon/tabular/models/_utils/torch_utils.py,sha256=dxs_KMMAOmNkRNjYf_hrzqaHIfkqn1xoKRKqCFbQ1Rk,537
 autogluon/tabular/models/automm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/automm/automm_model.py,sha256=_FPkXiHjowuc_KTKVkrzstaj1pecPDxIAZfw0LVjbJ0,11220
-autogluon/tabular/models/automm/ft_transformer.py,sha256=ryaMWA4tPmx_8_qdqOyzbIW6f5cBbLSwdtiHf9kfs80,3851
+autogluon/tabular/models/automm/automm_model.py,sha256=GvrMBC8Z-zobalmSzX1iDHTYMmQ4Jp5hINJa_fSm-j8,11322
+autogluon/tabular/models/automm/ft_transformer.py,sha256=yZ9-TTA4GbtutHhz0Djkrl-rIFNxc7A2LBOFOXYOxVY,3886
 autogluon/tabular/models/catboost/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/catboost/callbacks.py,sha256=l8x17n_w7oEFs-iDECSdBKZ89yW5g1z-zvj4XLgQPkw,7098
-autogluon/tabular/models/catboost/catboost_model.py,sha256=UmM7vnDAeQnIXRZ2MXYMP0mwB3Vw_oNhUGmRrxBJ5sw,17380
+autogluon/tabular/models/catboost/catboost_model.py,sha256=ApltUyLY0BUuS-Rb8z2_OgkAniXrm3Zlpd9FDZkRMjM,17416
 autogluon/tabular/models/catboost/catboost_softclass_utils.py,sha256=UiW0SUb3hFueW5qYtQn6Sbk7Wg7BWN4jqKWeFtbMvgU,3919
 autogluon/tabular/models/catboost/catboost_utils.py,sha256=YSc94V4DjrwbmkeUM8306zV7z21oq-K-qGCOj0UE_wg,3167
 autogluon/tabular/models/catboost/hyperparameters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -41,16 +41,16 @@ autogluon/tabular/models/fastainn/hyperparameters/__init__.py,sha256=47DEQpj8HBS
 autogluon/tabular/models/fastainn/hyperparameters/parameters.py,sha256=DkQwAZZ7CuODKoljr-yrkx-uFxBSPRxkKuvPdwO-UhQ,2069
 autogluon/tabular/models/fastainn/hyperparameters/searchspaces.py,sha256=5qdknZDrHtdPdrhSqjamYQrCxvupXvlN3bVGEPgs48E,1660
 autogluon/tabular/models/fasttext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/fasttext/fasttext_model.py,sha256=0_Dbjz0_rzrRtBKVALlGZ8khnqeO5hPsvmZHi_ktv78,7090
+autogluon/tabular/models/fasttext/fasttext_model.py,sha256=Tiwe9qxWlJ7Z_HGsLApPP4bTyvUgJbbYNXk7ni7CP1o,7203
 autogluon/tabular/models/fasttext/hyperparameters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/fasttext/hyperparameters/parameters.py,sha256=DbkLlHlxRh1uGWJ_sUYNrweSJj4yjlOBH_H2COyaWL8,1234
 autogluon/tabular/models/image_prediction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/image_prediction/image_predictor.py,sha256=2KBxnFzw-wAIjKYpJkmwKfsB_laUpWbY5HOxyDL6uqQ,5454
+autogluon/tabular/models/image_prediction/image_predictor.py,sha256=ZDW9vMEZtI5KOE2MDxGB9XDytpUum0DsjrfWEb4PE1Y,5620
 autogluon/tabular/models/imodels/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/imodels/imodels_models.py,sha256=JE-VFeFc8Ot2T1IUtlNMP4_T-9F1I1NzQt4zA5aZ-to,4712
+autogluon/tabular/models/imodels/imodels_models.py,sha256=89uQwbRAtqcUvPwYsKnER8SUMIbwkGZUd9spoG_mP10,4878
 autogluon/tabular/models/knn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/knn/_knn_loo_variants.py,sha256=-n2znYS7OBA0bZvtei6JZiEMRWp4GX-Qp64uheaHyhQ,4562
-autogluon/tabular/models/knn/knn_model.py,sha256=SdNIJW4fSV6Ae7JG5CwIDkUOmLuqibSC-FT2PXMtVC0,13941
+autogluon/tabular/models/knn/knn_model.py,sha256=qZwBnDVPT2Fd5aDPZqcwugszeUYREm5nZ_-bHVVE3_s,13977
 autogluon/tabular/models/knn/knn_rapids_model.py,sha256=0FFApNZFH8nyrDqlBSUV7jO-2fLe0-h_UHp1GsyQJ8E,1550
 autogluon/tabular/models/knn/knn_utils.py,sha256=XU1cxVXp1BAoQnja2_KmSIn9_q9gZkjAya7-9b0uStk,7455
 autogluon/tabular/models/lgb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -61,14 +61,14 @@ autogluon/tabular/models/lgb/hyperparameters/__init__.py,sha256=47DEQpj8HBSa-_TI
 autogluon/tabular/models/lgb/hyperparameters/parameters.py,sha256=LLEQ-Ns3HElWBsFJx3ogRV7L6qw_nXlcl7EyO0C0fVQ,1336
 autogluon/tabular/models/lgb/hyperparameters/searchspaces.py,sha256=tvNNR7niWz_B-PndYQXb6vVNABxSfBYRHj6ZVQJ1x2E,1930
 autogluon/tabular/models/lr/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/lr/lr_model.py,sha256=NqkK5eH-9HLXW-uuEcPeQWteq6H4F6WzvAwaXKTWZOQ,15563
+autogluon/tabular/models/lr/lr_model.py,sha256=wTrrTWVwmlAyx4RAxhfXHbkvZTAVIvAiTadpEChGEzc,15599
 autogluon/tabular/models/lr/lr_preprocessing_utils.py,sha256=zkmVZtv05BQPDasVBz1J8LmXEfLgoggsv57s6cXuTMQ,1094
 autogluon/tabular/models/lr/lr_rapids_model.py,sha256=a07JvjWemrL0L08moA3K4lnYieukRlAdb2Z_uWA44k8,2127
 autogluon/tabular/models/lr/hyperparameters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/lr/hyperparameters/parameters.py,sha256=Hr5YC13zjbt3CfCbzGj8iXUIuDn-Q7FvDT2uSuiSVlM,1414
 autogluon/tabular/models/lr/hyperparameters/searchspaces.py,sha256=Igywc-B6qJ9EBLdasrDhW-Ot5FGirIzbXLwv5HRe5Xo,276
 autogluon/tabular/models/rf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/rf/rf_model.py,sha256=V_lnpaVArQkt3QuzyUDGzKaGHax5srRw_sKZ2_G-RAE,21497
+autogluon/tabular/models/rf/rf_model.py,sha256=MwhTUk9PknLgZWyT5bz_7DtjEW8ADU5wiBvlOjzVLkA,21529
 autogluon/tabular/models/rf/rf_quantile.py,sha256=2S8FE8po9lMnZaeKuVkzOUFOcdil46ZbFqm49OuvNZY,36460
 autogluon/tabular/models/rf/rf_rapids_model.py,sha256=3s-8M11dzCl_2Lu5iB3H8YjHLgyP_SElrm_4w_HfmqY,2028
 autogluon/tabular/models/rf/compilers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -80,15 +80,15 @@ autogluon/tabular/models/tab_transformer/pretexts.py,sha256=UEoDq_8hLKbY7EbE5IyL
 autogluon/tabular/models/tab_transformer/tab_model_base.py,sha256=4rmY1IrwoFuJejy-9gOoYSz-ar3DvZY8uXyDUBKk7Iw,3615
 autogluon/tabular/models/tab_transformer/tab_transformer.py,sha256=1c1oTJfSsGxQjzZJVN8doqFmYV-Wwwbqcu7RcW77kJk,6991
 autogluon/tabular/models/tab_transformer/tab_transformer_encoder.py,sha256=v2G1S_MSESzKqtvSfxS5uEse2CWtOn_K2E-uIwuE6zI,24701
-autogluon/tabular/models/tab_transformer/tab_transformer_model.py,sha256=E_qPm2AMZY3I7EdKqPD5APKDbat5S-A7ohKaXAO-29w,22752
+autogluon/tabular/models/tab_transformer/tab_transformer_model.py,sha256=5J3xeIWEoSMljJ-ghMeRmHv0sFqY3ASJ2aN7ivOIqww,22917
 autogluon/tabular/models/tab_transformer/utils.py,sha256=rrNk0X6Y0vzt7ivylRmTf0zjDx1DIF-5_ibf6B9Taz8,4554
 autogluon/tabular/models/tab_transformer/hyperparameters/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 autogluon/tabular/models/tab_transformer/hyperparameters/parameters.py,sha256=-vJRG8PVj5FgQnF9FNJHMvoIzzyazGE4XLRyQKL5VT8,3854
 autogluon/tabular/models/tab_transformer/hyperparameters/searchspaces.py,sha256=poiOFwOVIf1ONcPIjOqsA31YbqBgWxy0DlVFpVwKNHM,650
 autogluon/tabular/models/tabpfn/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon/tabular/models/tabpfn/tabpfn_model.py,sha256=xdxBq9Bg4e8Cg6Y7jfUEwWr60mM7OvSOOLN0usrUn0I,6917
+autogluon/tabular/models/tabpfn/tabpfn_model.py,sha256=PEYMuIh5TFLIDy3hcjfz1DcvDu77rbwRq0pKWyuUR04,6787
 autogluon/tabular/models/tabpfnmix/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py,sha256=mc3mMRwytBYaxXjnnrlAQyS2dowT9sRd4xfvEkJfCW8,16765
+autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py,sha256=Bo-JMnNgI0fYXXTHy3zLAE1OHZv9ikgH4bFBaVSa79g,16174
 autogluon/tabular/models/tabpfnmix/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/tabpfnmix/_internal/tabpfnmix_classifier.py,sha256=U3DAhtSLpHUu-22GgR3QCZJnpRYpOW95XoTV7tE9J5Y,3425
 autogluon/tabular/models/tabpfnmix/_internal/tabpfnmix_regressor.py,sha256=J6JvrK6L6y3s-Ah6sHQdjSK0mwAMP-Wy3RRBwzB0AoA,3196
@@ -121,7 +121,7 @@ autogluon/tabular/models/tabular_nn/hyperparameters/__init__.py,sha256=47DEQpj8H
 autogluon/tabular/models/tabular_nn/hyperparameters/parameters.py,sha256=Z3t_U1f7jfolPey6lzqgJyoFbVgoncFNSvCKXSuLxeU,6465
 autogluon/tabular/models/tabular_nn/hyperparameters/searchspaces.py,sha256=pT9cJ3MaWPnaQwAf47Yz6f0-L9qDBknahERbggAp52U,2810
 autogluon/tabular/models/tabular_nn/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/tabular_nn/torch/tabular_nn_torch.py,sha256=mQt3zso10kSsbka1bJDeTake9yGpcooZR6SRp6J9r4w,42555
+autogluon/tabular/models/tabular_nn/torch/tabular_nn_torch.py,sha256=tDxWg4SLUjBFaNcdmbEYfC8nPWCYtCQMTX_XG00x13s,42587
 autogluon/tabular/models/tabular_nn/torch/tabular_torch_dataset.py,sha256=RdnQGZSrvY1iuJB4JTANniH3Dorw-DP0Em_JK3_h7RM,13497
 autogluon/tabular/models/tabular_nn/torch/torch_network_modules.py,sha256=Qc3PwXTD8A7PgXi6EGuaBCrN3jsFAXDLCW7i6tE5wYI,11338
 autogluon/tabular/models/tabular_nn/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -129,25 +129,29 @@ autogluon/tabular/models/tabular_nn/utils/categorical_encoders.py,sha256=uLQaHku
 autogluon/tabular/models/tabular_nn/utils/data_preprocessor.py,sha256=ypXqtxdt1qH6la1hcq-BJ0dzQBNtgKY-BjXmIWxPjCg,5237
 autogluon/tabular/models/tabular_nn/utils/nn_architecture_utils.py,sha256=tttzR5EtYcFa6sIrUG9wyegdYmYE5DPK_CiLF1-L3c8,2875
 autogluon/tabular/models/text_prediction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/text_prediction/text_prediction_v1_model.py,sha256=XCKKb9N3mKXLtbMHMjQ3y5HwKQFF25enA287WHv-ebc,924
+autogluon/tabular/models/text_prediction/text_prediction_v1_model.py,sha256=PBN7F98qgEAO6U76rV_hxZfAmKr_XpVKjElOdBvfX8c,1090
 autogluon/tabular/models/vowpalwabbit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/vowpalwabbit/vowpalwabbit_model.py,sha256=hToCVe0KP3PIkOl3-jEh0R1m7_9xwGXMY8RRH2bzXnM,11699
+autogluon/tabular/models/vowpalwabbit/vowpalwabbit_model.py,sha256=h_j33hnsuxDM0mfExpmejO2pu5lIpTm1uIEirS2OXXI,11802
 autogluon/tabular/models/vowpalwabbit/vowpalwabbit_utils.py,sha256=jZ0STjvqwKw8jJDeoo5yAXTvgwFvY8Fsz6OqSif_JGI,3677
 autogluon/tabular/models/xgboost/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/xgboost/callbacks.py,sha256=uynimXya07XQMBkDvec-7mXK6OfMGP6M8MiVYu8OVRI,7008
-autogluon/tabular/models/xgboost/xgboost_model.py,sha256=8LovgYAW61zLDcNCqRzzPD2OKx_cdhsXKbnEMa29AFk,14152
+autogluon/tabular/models/xgboost/xgboost_model.py,sha256=tTSnTzEot2JB0qEvhki4h3RdaLjEpfMs-jWKsxlJWO4,14304
 autogluon/tabular/models/xgboost/xgboost_utils.py,sha256=FVqZ8h4JAe_pifSvNx83cLZHwsuzTXylrrcan07AoNo,5757
 autogluon/tabular/models/xgboost/hyperparameters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/xgboost/hyperparameters/parameters.py,sha256=ay6bVVpiPzftbtz6TTS76w7j4vjDjzHFpuf2Bjf6Zu4,1673
 autogluon/tabular/models/xgboost/hyperparameters/searchspaces.py,sha256=lFwI34pcRtlVQkxmsdZsSaPry8t_WSMBhig4soMK54k,2140
 autogluon/tabular/models/xt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/xt/xt_model.py,sha256=vXy1HQ06fG1YjPTf0-THBKgcA9Edw1XhmBC4aOB3qVA,967
+autogluon/tabular/models/xt/xt_model.py,sha256=qOHJ5h1lHI7uYJfbl0BWm-29R3MNp2WeZB9ptcq5Xis,1003
 autogluon/tabular/predictor/__init__.py,sha256=zCMgjxQlWpDWnr1l1xjBCiK3rWC3N3RoD8UXBnazT74,107
 autogluon/tabular/predictor/interpretable_predictor.py,sha256=5UeKgnMFsfY65tiO3kxfHBPr03lyswLrgdtjPhI0Y7Q,6934
 autogluon/tabular/predictor/predictor.py,sha256=jOkpypHAPrL2nsI4iypVkZV90TpMORK-G_Ixr3Kw3XQ,357182
 autogluon/tabular/register/__init__.py,sha256=7CLOTWIUho0wi4eAwhYJ5Y0PfvNCWKnRwlw3bwYoTNE,93
 autogluon/tabular/register/_ag_model_register.py,sha256=tMr-QgxgCE49tdThdSFOZaJg2D9ckDh6fiR5K4cRtvk,1564
 autogluon/tabular/register/_model_register.py,sha256=jqSg0d89dXAAcp-OT4II90ce994ByKMMzAYmpkyaRbI,6824
+autogluon/tabular/testing/__init__.py,sha256=XrEGLmMdmRT6QHNR13M9wna57LO4O3Q4tt27Ca8omAc,79
+autogluon/tabular/testing/fit_helper.py,sha256=gVHTdAsp_lSZ_qbwjXM7aA5fI32zHj3_zXwEXC9C_ds,19586
+autogluon/tabular/testing/generate_datasets.py,sha256=UXPNfviUNZqGcx4mTYIloJxRED6DRMxAgHqbOvjEUCs,3603
+autogluon/tabular/testing/model_fit_helper.py,sha256=ZjWpw2nyeFnsrccmkfQtx3qbA8HJx282XX2rwdS-LIs,3808
 autogluon/tabular/trainer/__init__.py,sha256=PW_PGL-tWoQzx3ES2S53bQEZOtsRWTYiM9QdOqsk0dI,38
 autogluon/tabular/trainer/abstract_trainer.py,sha256=lqOjVTLUaZNue4B7u47PYXTXsBEFbSJ4SyruNeChFCk,231925
 autogluon/tabular/trainer/auto_trainer.py,sha256=FyRWM8iUJuDvw_aqV5EV_xdh_pb-nHzAvG1sbEhvs0g,8680
@@ -156,11 +160,11 @@ autogluon/tabular/trainer/model_presets/presets.py,sha256=bTPGPyz07a7GG6327yO6ry
 autogluon/tabular/trainer/model_presets/presets_distill.py,sha256=MnFC2GJc6RmDBNAGbsO2XMfo3PjR8cUrZoilWW8gTYQ,3295
 autogluon/tabular/tuning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/tuning/feature_pruner.py,sha256=9iNku8gVbYEkjuKlyITPJDicsNkoraaQOlINQq9iZlQ,6877
-autogluon.tabular-1.2.1b20250305.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.tabular-1.2.1b20250305.dist-info/METADATA,sha256=cakvMqjhws1tFxCEq1ooyd8wqFoimmrVHE27YYzoUM4,14386
-autogluon.tabular-1.2.1b20250305.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.tabular-1.2.1b20250305.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.tabular-1.2.1b20250305.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.tabular-1.2.1b20250305.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.tabular-1.2.1b20250305.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.tabular-1.2.1b20250305.dist-info/RECORD,,
+autogluon.tabular-1.2.1b20250306.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.tabular-1.2.1b20250306.dist-info/METADATA,sha256=YgXdgjQUF_qTbiUXze0zDW5m1-lQO6pPMBOhZPp8Jqs,14386
+autogluon.tabular-1.2.1b20250306.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.tabular-1.2.1b20250306.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.tabular-1.2.1b20250306.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.tabular-1.2.1b20250306.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.tabular-1.2.1b20250306.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.tabular-1.2.1b20250306.dist-info/RECORD,,