autogluon.tabular 1.4.1b20250821__py3-none-any.whl → 1.4.1b20250823__py3-none-any.whl

autogluon/tabular/models/__init__.py

@@ -3,6 +3,7 @@ from autogluon.core.models.abstract.abstract_model import AbstractModel
 from .automm.automm_model import MultiModalPredictorModel
 from .automm.ft_transformer import FTTransformerModel
 from .catboost.catboost_model import CatBoostModel
+from .ebm.ebm_model import EBMModel
 from .fastainn.tabular_nn_fastai import NNFastAiTabularModel
 from .fasttext.fasttext_model import FastTextModel
 from .image_prediction.image_predictor import ImagePredictorModel

autogluon/tabular/models/ebm/ebm_model.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+import time
+import warnings
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION
+from autogluon.core.models import AbstractModel
+
+from .hyperparameters.parameters import get_param_baseline
+from .hyperparameters.searchspaces import get_default_searchspace
+
+if TYPE_CHECKING:
+    from autogluon.core.metrics import Scorer
+
+
+class EbmCallback:
+    """Time limit callback for EBM."""
+
+    def __init__(self, seconds: float):
+        self.seconds = seconds
+        self.end_time: float | None = None
+
+    def __call__(self, *args, **kwargs):
+        if self.end_time is None:
+            self.end_time = time.monotonic() + self.seconds
+            return False
+        return time.monotonic() > self.end_time
+
+
+class EBMModel(AbstractModel):
+    """
+    The Explainable Boosting Machine (EBM) is a glass-box generalized additive model
+    with automatic interaction detection (https://interpret.ml/docs). EBMs are
+    designed to be highly interpretable while achieving accuracy comparable to
+    black-box models on a wide range of tabular datasets.
+
+    Requires the 'interpret' or 'interpret-core' package. Install via:
+    
+    pip install interpret
+
+
+    Paper: InterpretML: A Unified Framework for Machine Learning Interpretability
+    
+    Authors: H. Nori, S. Jenkins, P. Koch, and R. Caruana 2019
+    
+    Codebase: https://github.com/interpretml/interpret
+
+    License: MIT
+
+    .. versionadded:: 1.5.0
+    """
+
+    ag_key = "EBM"
+    ag_name = "EBM"
+    ag_priority = 35
+    
+    def _fit(
+        self,
+        X: pd.DataFrame,
+        y: pd.Series,
+        X_val: pd.DataFrame | None = None,
+        y_val: pd.Series | None = None,
+        time_limit: float | None = None,
+        sample_weight: np.ndarray | None = None,
+        sample_weight_val: np.ndarray | None = None,
+        num_cpus: int | str = "auto",
+        **kwargs,
+    ):
+        # Preprocess data.
+        X = self.preprocess(X)
+        if X_val is not None:
+            X_val = self.preprocess(X_val)
+
+        features = self._features
+        if features is None:
+            features = X.columns
+
+        params = construct_ebm_params(
+            self.problem_type,
+            self._get_model_params(),
+            features,
+            self.stopping_metric,
+            num_cpus,
+            time_limit,
+        )
+
+        # Init Class
+        model_cls = get_class_from_problem_type(self.problem_type)
+        self.model = model_cls(random_state=self.random_seed, **params)
+
+        # Handle validation data format for EBM
+        fit_X = X
+        fit_y = y
+        fit_sample_weight = sample_weight
+        bags = None
+        if X_val is not None:
+            fit_X = pd.concat([X, X_val], ignore_index=True)
+            fit_y = pd.concat([y, y_val], ignore_index=True)
+            if sample_weight is not None:
+                fit_sample_weight = np.hstack([sample_weight, sample_weight_val])
+            bags = np.full((len(fit_X), 1), 1, np.int8)
+            bags[len(X) :, 0] = -1
+
+        with warnings.catch_warnings():  # try to filter joblib warnings
+            warnings.filterwarnings(
+                "ignore",
+                category=UserWarning,
+                message=".*resource_tracker: process died.*",
+            )
+            self.model.fit(fit_X, fit_y, sample_weight=fit_sample_weight, bags=bags)
+
+    def _get_random_seed_from_hyperparameters(
+        self, hyperparameters: dict
+    ) -> int | None | str:
+        return hyperparameters.get("random_state", "N/A")
+
+    def _set_default_params(self):
+        default_params = get_param_baseline(problem_type=self.problem_type, num_classes=self.num_classes)
+        for param, val in default_params.items():
+            self._set_default_param_value(param, val)
+
+    def _get_default_searchspace(self):
+        return get_default_searchspace(problem_type=self.problem_type, num_classes=self.num_classes)
+
+    def _get_default_auxiliary_params(self) -> dict:
+        default_auxiliary_params = super()._get_default_auxiliary_params()
+        extra_auxiliary_params = {
+            "valid_raw_types": ["int", "float", "category"],
+        }
+        default_auxiliary_params.update(extra_auxiliary_params)
+        return default_auxiliary_params
+
+    @classmethod
+    def supported_problem_types(cls) -> list[str] | None:
+        return ["binary", "multiclass", "regression"]
+
+    @classmethod
+    def _class_tags(cls) -> dict:
+        return {"can_estimate_memory_usage_static": True}
+
+    def _more_tags(self) -> dict:
+        """EBMs support refit full."""
+        return {"can_refit_full": True}
+
+    def _estimate_memory_usage(self, X: pd.DataFrame, y: pd.Series | None = None, **kwargs) -> int:
+        return self.estimate_memory_usage_static(
+            X=X,
+            y=y,
+            hyperparameters=self._get_model_params(),
+            problem_type=self.problem_type,
+            num_classes=self.num_classes,
+            features=self._features,
+            **kwargs,
+        )
+
+    @classmethod
+    def _estimate_memory_usage_static(
+        cls,
+        *,
+        X: pd.DataFrame,
+        y: pd.Series | None = None,
+        hyperparameters: dict | None = None,
+        problem_type: str = "infer",
+        num_classes: int = 1,
+        features=None,
+        **kwargs,
+    ) -> int:
+        """Returns the expected peak memory usage in bytes of the EBM model during fit."""
+        # TODO: we can improve the memory estimate slightly by using num_classes if y is None
+
+        if features is None:
+            features = X.columns
+
+        model_cls = get_class_from_problem_type(problem_type)
+        params = construct_ebm_params(problem_type, hyperparameters, features)
+        baseline_memory_bytes = 400_000_000  # 400 MB baseline memory
+
+        # assuming we call pd.concat([X, X_val], ignore_index=True), then X size will be doubled
+        return baseline_memory_bytes + model_cls(**params).estimate_mem(
+            X, y, data_multiplier=2.0
+        )
+
+    def _validate_fit_memory_usage(self, mem_error_threshold: float = 1, **kwargs):
+        # Given the good mem estimates with overhead, we set the threshold to 1.
+        return super()._validate_fit_memory_usage(
+            mem_error_threshold=mem_error_threshold, **kwargs
+        )
+
+
+def construct_ebm_params(
+    problem_type,
+    hyperparameters=None,
+    features=None,
+    stopping_metric=None,
+    num_cpus=-1,
+    time_limit=None,
+):
+    if hyperparameters is None:
+        hyperparameters = {}
+
+    hyperparameters = hyperparameters.copy()  # we pop values below, so copy.
+
+    # The user can specify nominal and continuous columns.
+    continuous_columns = hyperparameters.pop("continuous_columns", [])
+    nominal_columns = hyperparameters.pop("nominal_columns", [])
+
+    feature_types = None
+    if features is not None:
+        feature_types = []
+        for c in features:
+            if c in continuous_columns:
+                f_type = "continuous"
+            elif c in nominal_columns:
+                f_type = "nominal"
+            else:
+                f_type = "auto"
+            feature_types.append(f_type)
+
+    # Default parameters for EBM
+    params = {
+        "outer_bags": 1,  # AutoGluon ensemble creates outer bags, no need for this overhead.
+        "n_jobs": 1,  # EBM only parallelizes across outer bags currently, so ignore num_cpus
+        "feature_names": features,
+        "feature_types": feature_types,
+    }
+    if stopping_metric is not None:
+        params["objective"] = get_metric_from_ag_metric(
+            metric=stopping_metric, problem_type=problem_type
+        )
+    if time_limit is not None:
+        params["callback"] = EbmCallback(time_limit)
+
+    params.update(hyperparameters)
+    return params
+
+
+def get_class_from_problem_type(problem_type: str):
+    if problem_type in [BINARY, MULTICLASS]:
+        from interpret.glassbox import ExplainableBoostingClassifier
+
+        model_cls = ExplainableBoostingClassifier
+    elif problem_type == REGRESSION:
+        from interpret.glassbox import ExplainableBoostingRegressor
+
+        model_cls = ExplainableBoostingRegressor
+    else:
+        raise ValueError(f"Unsupported problem type: {problem_type}")
+    return model_cls
+
+
+def get_metric_from_ag_metric(*, metric: Scorer, problem_type: str):
+    """Map AutoGluon metric to EBM metric for early stopping."""
+    if problem_type in [BINARY, MULTICLASS]:
+        metric_class = "log_loss"
+    elif problem_type == REGRESSION:
+        metric_class = "rmse"
+    else:
+        raise AssertionError(f"EBM does not support {problem_type} problem type.")
+
+    return metric_class

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

@@ -0,0 +1,39 @@
+from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION, SOFTCLASS
+
+def get_param_baseline(problem_type, num_classes=None):
+    if problem_type == BINARY:
+        return get_param_binary_baseline()
+    elif problem_type == MULTICLASS:
+        return get_param_multiclass_baseline(num_classes=num_classes)
+    elif problem_type == SOFTCLASS:
+        return get_param_multiclass_baseline(num_classes=num_classes)
+    elif problem_type == REGRESSION:
+        return get_param_regression_baseline()
+    else:
+        return get_param_binary_baseline()
+
+
+def get_base_params():
+    base_params = {}
+    return base_params
+
+
+def get_param_binary_baseline():
+    params = get_base_params()
+    baseline_params = {}
+    params.update(baseline_params)
+    return params
+
+
+def get_param_multiclass_baseline(num_classes):
+    params = get_base_params()
+    baseline_params = {}
+    params.update(baseline_params)
+    return params
+
+
+def get_param_regression_baseline():
+    params = get_base_params()
+    baseline_params = {}
+    params.update(baseline_params)
+    return params

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

@@ -0,0 +1,72 @@
+"""Default hyperparameter search spaces used in EBM model"""
+
+from autogluon.common import space
+from autogluon.core.constants import BINARY, MULTICLASS, REGRESSION
+
+def get_default_searchspace(problem_type, num_classes=None):
+    if problem_type == BINARY:
+        return get_searchspace_binary_baseline()
+    elif problem_type == MULTICLASS:
+        return get_searchspace_multiclass_baseline(num_classes=num_classes)
+    elif problem_type == REGRESSION:
+        return get_searchspace_regression_baseline()
+    else:
+        return get_searchspace_binary_baseline()
+
+
+def get_base_searchspace():
+    base_params = {
+        "max_leaves": space.Int(2, 3, default=2),
+        "smoothing_rounds": space.Int(0, 1000, default=200),
+        "learning_rate": space.Real(0.0025, 0.2, default=0.02, log=True),
+        "interactions": space.Categorical(
+            0,
+            "0.5x",
+            "1x",
+            "1.5x",
+            "2x",
+            "2.5x",
+            "3x",
+            "3.5x",
+            "4x",
+            "4.5x",
+            "5x",
+            "6x",
+            "7x",
+            "8x",
+            "9x",
+            "10x",
+            "15x",
+            "20x",
+            "25x",
+        ),
+        "interaction_smoothing_rounds": space.Int(0, 200, default=90),
+        "min_hessian": space.Real(1e-10, 1e-2, default=1e-4, log=True),
+        "min_samples_leaf": space.Int(2, 20, default=4),
+        "gain_scale": space.Real(0.5, 5.0, default=5.0, log=True),
+        "min_cat_samples": space.Int(5, 20, default=10),
+        "cat_smooth": space.Real(5.0, 100.0, default=10.0, log=True),
+        "missing": space.Categorical("separate", "low", "high", "gain"),
+    }
+    return base_params
+
+
+def get_searchspace_multiclass_baseline(num_classes):
+    params = get_base_searchspace()
+    baseline_params = {}
+    params.update(baseline_params)
+    return params
+
+
+def get_searchspace_binary_baseline():
+    params = get_base_searchspace()
+    baseline_params = {}
+    params.update(baseline_params)
+    return params
+
+
+def get_searchspace_regression_baseline():
+    params = get_base_searchspace()
+    baseline_params = {}
+    params.update(baseline_params)
+    return params

autogluon/tabular/models/mitra/mitra_model.py

@@ -116,6 +116,22 @@ class MitraModel(AbstractModel):
 
         hyp = self._get_model_params()
 
+        hf_cls_model = hyp.pop("hf_cls_model", None)
+        hf_reg_model = hyp.pop("hf_reg_model", None)
+        if self.problem_type in ["binary", "multiclass"]:
+            hf_model = hf_cls_model
+        elif self.problem_type == "regression":
+            hf_model = hf_reg_model
+        else:
+            raise AssertionError(f"Unsupported problem_type: {self.problem_type}")
+        if hf_model is None:
+            hf_model = hyp.pop("hf_general_model", None)
+        if hf_model is None:
+            hf_model = hyp.pop("hf_model", None)
+        if hf_model is not None:
+            logger.log(30, f"\tCustom hf_model specified: {hf_model}")
+            hyp["hf_model"] = hf_model
+
         if hyp.get("device", None) is None:
             if num_gpus == 0:
                 hyp["device"] = "cpu"

autogluon/tabular/models/mitra/sklearn_interface.py

@@ -30,7 +30,6 @@ RANDOM_MIRROR_X = True # [True, False]
 LR = 0.0001 # [0.00001, 0.000025, 0.00005, 0.000075, 0.0001, 0.00025, 0.0005, 0.00075, 0.001]
 PATIENCE = 40 # [30, 35, 40, 45, 50]
 WARMUP_STEPS = 1000 # [500, 750, 1000, 1250, 1500]
-DEFAULT_GENERAL_MODEL = 'autogluon/mitra-classifier'
 DEFAULT_CLS_MODEL = 'autogluon/mitra-classifier'
 DEFAULT_REG_MODEL = 'autogluon/mitra-regressor'
 
@@ -67,9 +66,7 @@ class MitraBase(BaseEstimator):
             fine_tune_steps=DEFAULT_FINE_TUNE_STEPS,
             metric=DEFAULT_CLS_METRIC,
             state_dict=None,
-            hf_general_model=DEFAULT_GENERAL_MODEL,
-            hf_cls_model=DEFAULT_CLS_MODEL,
-            hf_reg_model=DEFAULT_REG_MODEL,
+            hf_model=None,
             patience=PATIENCE,
             lr=LR,
             warmup_steps=WARMUP_STEPS,
@@ -104,9 +101,7 @@ class MitraBase(BaseEstimator):
         self.fine_tune_steps = fine_tune_steps
         self.metric = metric
         self.state_dict = state_dict
-        self.hf_general_model = hf_general_model
-        self.hf_cls_model = hf_cls_model
-        self.hf_reg_model = hf_reg_model
+        self.hf_model = hf_model
         self.patience = patience
         self.lr = lr
         self.warmup_steps = warmup_steps
@@ -200,20 +195,8 @@ class MitraBase(BaseEstimator):
                 self.train_time = 0
                 for _ in range(self.n_estimators):
                     if USE_HF:
-                        if task == 'classification':
-                            if self.hf_cls_model is not None:
-                                model = Tab2D.from_pretrained(self.hf_cls_model, device=self.device)
-                            elif self.hf_general_model is not None:
-                                model = Tab2D.from_pretrained(self.hf_general_model, device=self.device)
-                            else:
-                                model = Tab2D.from_pretrained("autogluon/mitra-classifier", device=self.device)
-                        elif task == 'regression':
-                            if self.hf_reg_model is not None:
-                                model = Tab2D.from_pretrained(self.hf_reg_model, device=self.device)
-                            elif self.hf_general_model is not None:
-                                model = Tab2D.from_pretrained(self.hf_general_model, device=self.device)
-                            else:
-                                model = Tab2D.from_pretrained("autogluon/mitra-regressor", device=self.device)
+                        assert self.hf_model is not None, f"hf_model must not be None."
+                        model = Tab2D.from_pretrained(self.hf_model, device=self.device)
                     else:
                         model = Tab2D(
                             dim=cfg.hyperparams['dim'],
@@ -274,6 +257,7 @@ class MitraClassifier(MitraBase, ClassifierMixin):
             fine_tune_steps=DEFAULT_FINE_TUNE_STEPS,
             metric=DEFAULT_CLS_METRIC,
             state_dict=None,
+            hf_model=DEFAULT_CLS_MODEL,
             patience=PATIENCE,
             lr=LR,
             warmup_steps=WARMUP_STEPS,
@@ -294,6 +278,7 @@ class MitraClassifier(MitraBase, ClassifierMixin):
             fine_tune_steps,
             metric,
             state_dict,
+            hf_model=hf_model,
             patience=patience,
             lr=lr,
             warmup_steps=warmup_steps,
@@ -404,6 +389,7 @@ class MitraRegressor(MitraBase, RegressorMixin):
             fine_tune_steps=DEFAULT_FINE_TUNE_STEPS,
             metric=DEFAULT_REG_METRIC,
             state_dict=None,
+            hf_model=DEFAULT_REG_MODEL,
             patience=PATIENCE,
             lr=LR,
             warmup_steps=WARMUP_STEPS,
@@ -424,6 +410,7 @@ class MitraRegressor(MitraBase, RegressorMixin):
             fine_tune_steps,
             metric,
             state_dict,
+            hf_model=hf_model,
             patience=patience,
             lr=lr,
             warmup_steps=warmup_steps,

autogluon/tabular/predictor/predictor.py

@@ -525,6 +525,7 @@ class TabularPredictor:
                     'GBM' (LightGBM)
                     'CAT' (CatBoost)
                     'XGB' (XGBoost)
+                    'EBM' (Explainable Boosting Machine)
                     'REALMLP' (RealMLP)
                     'TABM' (TabM)
                     'MITRA' (Mitra)

autogluon/tabular/registry/_ag_model_registry.py

@@ -8,6 +8,7 @@ from . import ModelRegistry
 from ..models import (
     BoostedRulesModel,
     CatBoostModel,
+    EBMModel,
     FastTextModel,
     FigsModel,
     FTTransformerModel,
@@ -64,6 +65,7 @@ REGISTERED_MODEL_CLS_LST = [
     HSTreeModel,
     BoostedRulesModel,
     DummyModel,
+    EBMModel,
 ]
 
 # TODO: Replace logic in `autogluon.tabular.trainer.model_presets.presets` with `ag_model_registry`

autogluon/tabular/version.py

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

{autogluon.tabular-1.4.1b20250821.dist-info → autogluon.tabular-1.4.1b20250823.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.4.1b20250821
+Version: 1.4.1b20250823
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -41,23 +41,23 @@ Requires-Dist: scipy<1.17,>=1.5.4
 Requires-Dist: pandas<2.4.0,>=2.0.0
 Requires-Dist: scikit-learn<1.8.0,>=1.4.0
 Requires-Dist: networkx<4,>=3.0
-Requires-Dist: autogluon.core==1.4.1b20250821
-Requires-Dist: autogluon.features==1.4.1b20250821
+Requires-Dist: autogluon.core==1.4.1b20250823
+Requires-Dist: autogluon.features==1.4.1b20250823
 Provides-Extra: all
-Requires-Dist: xgboost<3.1,>=2.0; extra == "all"
 Requires-Dist: catboost<1.3,>=1.2; extra == "all"
-Requires-Dist: numpy<2.3.0,>=1.25; extra == "all"
-Requires-Dist: transformers; extra == "all"
-Requires-Dist: omegaconf; extra == "all"
-Requires-Dist: loguru; extra == "all"
-Requires-Dist: spacy<3.9; extra == "all"
-Requires-Dist: autogluon.core[all]==1.4.1b20250821; extra == "all"
-Requires-Dist: torch<2.8,>=2.6; extra == "all"
-Requires-Dist: fastai<2.9,>=2.3.1; extra == "all"
-Requires-Dist: einx; extra == "all"
 Requires-Dist: huggingface-hub[torch]; extra == "all"
 Requires-Dist: einops<0.9,>=0.7; extra == "all"
 Requires-Dist: lightgbm<4.7,>=4.0; extra == "all"
+Requires-Dist: torch<2.8,>=2.6; extra == "all"
+Requires-Dist: xgboost<3.1,>=2.0; extra == "all"
+Requires-Dist: einx; extra == "all"
+Requires-Dist: numpy<2.3.0,>=1.25; extra == "all"
+Requires-Dist: fastai<2.9,>=2.3.1; extra == "all"
+Requires-Dist: loguru; extra == "all"
+Requires-Dist: omegaconf; extra == "all"
+Requires-Dist: transformers; extra == "all"
+Requires-Dist: autogluon.core[all]==1.4.1b20250823; extra == "all"
+Requires-Dist: spacy<3.9; extra == "all"
 Requires-Dist: blis<1.2.1,>=0.7.0; (platform_system == "Windows" and python_version == "3.9") and extra == "all"
 Provides-Extra: catboost
 Requires-Dist: numpy<2.3.0,>=1.25; extra == "catboost"
@@ -69,6 +69,8 @@ Requires-Dist: fastai<2.9,>=2.3.1; extra == "fastai"
 Requires-Dist: blis<1.2.1,>=0.7.0; (platform_system == "Windows" and python_version == "3.9") and extra == "fastai"
 Provides-Extra: imodels
 Requires-Dist: imodels<2.1.0,>=1.3.10; extra == "imodels"
+Provides-Extra: interpret
+Requires-Dist: interpret-core<0.8,>=0.7.2; extra == "interpret"
 Provides-Extra: lightgbm
 Requires-Dist: lightgbm<4.7,>=4.0; extra == "lightgbm"
 Provides-Extra: mitra
@@ -80,7 +82,7 @@ Requires-Dist: transformers; extra == "mitra"
 Requires-Dist: huggingface-hub[torch]; extra == "mitra"
 Requires-Dist: einops<0.9,>=0.7; extra == "mitra"
 Provides-Extra: ray
-Requires-Dist: autogluon.core[all]==1.4.1b20250821; extra == "ray"
+Requires-Dist: autogluon.core[all]==1.4.1b20250823; extra == "ray"
 Provides-Extra: realmlp
 Requires-Dist: pytabkit<1.7,>=1.6; extra == "realmlp"
 Provides-Extra: skex
@@ -92,23 +94,24 @@ Requires-Dist: onnxruntime-gpu<1.20.0,>=1.17.0; extra == "skl2onnx"
 Requires-Dist: onnx<1.18.0,>=1.13.0; platform_system != "Windows" and extra == "skl2onnx"
 Requires-Dist: onnx<1.16.2,>=1.13.0; platform_system == "Windows" and extra == "skl2onnx"
 Provides-Extra: tabarena
-Requires-Dist: xgboost<3.1,>=2.0; extra == "tabarena"
-Requires-Dist: catboost<1.3,>=1.2; extra == "tabarena"
-Requires-Dist: numpy<2.3.0,>=1.25; extra == "tabarena"
-Requires-Dist: transformers; extra == "tabarena"
-Requires-Dist: omegaconf; extra == "tabarena"
-Requires-Dist: loguru; extra == "tabarena"
-Requires-Dist: spacy<3.9; extra == "tabarena"
-Requires-Dist: autogluon.core[all]==1.4.1b20250821; extra == "tabarena"
-Requires-Dist: tabpfn<2.2,>=2.0.9; extra == "tabarena"
+Requires-Dist: interpret-core<0.8,>=0.7.2; extra == "tabarena"
+Requires-Dist: huggingface-hub[torch]; extra == "tabarena"
 Requires-Dist: torch<2.8,>=2.6; extra == "tabarena"
-Requires-Dist: fastai<2.9,>=2.3.1; extra == "tabarena"
 Requires-Dist: einx; extra == "tabarena"
-Requires-Dist: huggingface-hub[torch]; extra == "tabarena"
-Requires-Dist: tabicl<0.2,>=0.1.3; extra == "tabarena"
+Requires-Dist: numpy<2.3.0,>=1.25; extra == "tabarena"
 Requires-Dist: pytabkit<1.7,>=1.6; extra == "tabarena"
+Requires-Dist: fastai<2.9,>=2.3.1; extra == "tabarena"
+Requires-Dist: tabpfn<2.2,>=2.0.9; extra == "tabarena"
+Requires-Dist: catboost<1.3,>=1.2; extra == "tabarena"
 Requires-Dist: einops<0.9,>=0.7; extra == "tabarena"
+Requires-Dist: autogluon.core[all]==1.4.1b20250823; extra == "tabarena"
+Requires-Dist: xgboost<3.1,>=2.0; extra == "tabarena"
+Requires-Dist: tabicl<0.2,>=0.1.3; extra == "tabarena"
+Requires-Dist: loguru; extra == "tabarena"
+Requires-Dist: omegaconf; extra == "tabarena"
+Requires-Dist: transformers; extra == "tabarena"
 Requires-Dist: lightgbm<4.7,>=4.0; extra == "tabarena"
+Requires-Dist: spacy<3.9; extra == "tabarena"
 Requires-Dist: blis<1.2.1,>=0.7.0; (platform_system == "Windows" and python_version == "3.9") and extra == "tabarena"
 Provides-Extra: tabicl
 Requires-Dist: tabicl<0.2,>=0.1.3; extra == "tabicl"
@@ -121,6 +124,7 @@ Requires-Dist: torch<2.8,>=2.6; extra == "tabpfnmix"
 Requires-Dist: huggingface-hub[torch]; extra == "tabpfnmix"
 Requires-Dist: einops<0.9,>=0.7; extra == "tabpfnmix"
 Provides-Extra: tests
+Requires-Dist: interpret-core<0.8,>=0.7.2; extra == "tests"
 Requires-Dist: tabicl<0.2,>=0.1.3; extra == "tests"
 Requires-Dist: tabpfn<2.2,>=2.0.9; extra == "tests"
 Requires-Dist: pytabkit<1.7,>=1.6; extra == "tests"

{autogluon.tabular-1.4.1b20250821.dist-info → autogluon.tabular-1.4.1b20250823.dist-info}/RECORD

@@ -1,6 +1,6 @@
-autogluon.tabular-1.4.1b20250821-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
+autogluon.tabular-1.4.1b20250823-py3.9-nspkg.pth,sha256=cQGwpuGPqg1GXscIwt-7PmME1OnSpD-7ixkikJ31WAY,554
 autogluon/tabular/__init__.py,sha256=2OXpJCvENRHubBTYNIPpHX93WWuFZzsJBtTZbNVHVas,400
-autogluon/tabular/version.py,sha256=-fdAQH1qSxLHmHM4b_9xaur5t6COmaik-4oCHK_efEY,91
+autogluon/tabular/version.py,sha256=QVRPZmSbEROxD6VvAs3eoKlm8lwUnPqufg_65PsisRo,91
 autogluon/tabular/configs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/configs/config_helper.py,sha256=Rby5gRhuY5IlZWdKbtsmzbSt948B97qxwQ2f1MbH_38,21070
 autogluon/tabular/configs/feature_generator_presets.py,sha256=EV5Ym8VW15q92MwOUpTi7wZFS2QooM51fLg3RdUsn-M,1223
@@ -18,7 +18,7 @@ autogluon/tabular/experimental/plot_leaderboard.py,sha256=BN_kB-zmOZNUYWyI7z9pF6
 autogluon/tabular/learner/__init__.py,sha256=Hhmk5WpKQHohVmI-veOaKMelKJpIdzeXrmw_DPn3DTU,63
 autogluon/tabular/learner/abstract_learner.py,sha256=0kf0huvg0nphe-lrdKtNTzdIFr14jzJPsfZDRBkKo3g,55253
 autogluon/tabular/learner/default_learner.py,sha256=hjdKbcFtIQxQ3-k1LiGOo-w5sLxIIQAyFLs3-R35aw0,24781
-autogluon/tabular/models/__init__.py,sha256=-Yi0lq_jsMdKTjZkuRvNDeZdC5KRAsOKRNp-v4bcyy4,1216
+autogluon/tabular/models/__init__.py,sha256=grZ23UfuNZ_LxoNdl-yjIUmq71TeovT5CJPhbatiqvg,1252
 autogluon/tabular/models/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/_utils/rapids_utils.py,sha256=9A2Y10Owva6zhcLkBVQ_T4tOAMDp1idSMzDWhl_QyBI,1083
 autogluon/tabular/models/_utils/torch_utils.py,sha256=dxs_KMMAOmNkRNjYf_hrzqaHIfkqn1xoKRKqCFbQ1Rk,537
@@ -33,6 +33,11 @@ autogluon/tabular/models/catboost/catboost_utils.py,sha256=zJMIsbgyW_JH0eULhUeu_
 autogluon/tabular/models/catboost/hyperparameters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/catboost/hyperparameters/parameters.py,sha256=Hxi4mPTc2ML9GdpW0TalkDgtsYJLwpEcd-LiyLOsmlA,956
 autogluon/tabular/models/catboost/hyperparameters/searchspaces.py,sha256=Oe86ixuvd1xJCdSHs2Oh5Ifx0501YJBsdyL2l9Z4nxM,1458
+autogluon/tabular/models/ebm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autogluon/tabular/models/ebm/ebm_model.py,sha256=vUnOXtBaoqc2JrY1DcJ7Y1KfMem3ZrXE-7cQWn1DwEQ,8693
+autogluon/tabular/models/ebm/hyperparameters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autogluon/tabular/models/ebm/hyperparameters/parameters.py,sha256=IbDv3Ufx8CGHvejqSbAggZKlMq5X9k0Ggclm_DCoiII,1080
+autogluon/tabular/models/ebm/hyperparameters/searchspaces.py,sha256=G6zgHERKt_KJlVfZ06tFKw2aOUuM7DdDyCm0s5RBXoc,2191
 autogluon/tabular/models/fastainn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 autogluon/tabular/models/fastainn/callbacks.py,sha256=3WvOEwqd1YAVInooKsFOTzAkCLeIXjEelsglYwfofq0,4788
 autogluon/tabular/models/fastainn/fastai_helpers.py,sha256=gGYzyrAFl8hi8GnsemZNLGZn5xr7cyJXdFl08PIlza4,1393
@@ -70,8 +75,8 @@ autogluon/tabular/models/lr/hyperparameters/__init__.py,sha256=47DEQpj8HBSa-_TIm
 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/mitra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autogluon/tabular/models/mitra/mitra_model.py,sha256=lHcOtaQwIy4EpgK4TAiuRqQQFhBN3NzSdejFjkNpZPg,13447
-autogluon/tabular/models/mitra/sklearn_interface.py,sha256=Znwx1uMagauu1DwcutM_kgGY8maQrxOE0KsP1uS46qE,18751
+autogluon/tabular/models/mitra/mitra_model.py,sha256=6mf37K0a_OK3KTGxWMcP1J3agMpd4EHBcuCgSPqxpXE,14136
+autogluon/tabular/models/mitra/sklearn_interface.py,sha256=vyg8kkmYKzEJRWiehEqEsgZeOCV20tnZAZaaaJkwDuA,17739
 autogluon/tabular/models/mitra/_internal/__init__.py,sha256=dN2dz1pGMgQTFiSf9oYbyq23iJUxV8QNlOX3qw3KUO4,35
 autogluon/tabular/models/mitra/_internal/config/__init__.py,sha256=Exu_Sx6-K-D5peDQ_TibsjZpqAALs2-9IXfq8hu1mwU,40
 autogluon/tabular/models/mitra/_internal/config/config_pretrain.py,sha256=CeaD96EcDX69LdcLTYGlFmYLdBNINEJXRMWmJ6LbhTg,6038
@@ -174,9 +179,9 @@ autogluon/tabular/models/xt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMp
 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=sEnBSfM18OreAPH1fG9bNSsx62wCXKNv494Wowt7Atk,361051
+autogluon/tabular/predictor/predictor.py,sha256=5iexlgiMkDUdGTqvq87MExfsnVdpLWZZrLZcq9lB3do,361108
 autogluon/tabular/registry/__init__.py,sha256=vZpzX4Xve7bfA9crt5LxjgQv9PPfxbi1E1U6Im0Y_xU,93
-autogluon/tabular/registry/_ag_model_registry.py,sha256=Aa-o_KZZiroPBpvZozIBXOlWYvQJN-MVsl_Gl66gkE8,1550
+autogluon/tabular/registry/_ag_model_registry.py,sha256=2Zx5qxXvOdXIbL1FKslNh2M_JM2YG_7GvsCMFF11wDY,1578
 autogluon/tabular/registry/_model_registry.py,sha256=Rl8Q7BLzaif4hxNxJF20xGE02vrWwh2ZuUaTmA-UJnE,6824
 autogluon/tabular/testing/__init__.py,sha256=XrEGLmMdmRT6QHNR13M9wna57LO4O3Q4tt27Ca8omAc,79
 autogluon/tabular/testing/fit_helper.py,sha256=0eTvPtqM8k8hlOUIHQiwTzik4juTjHQt12BySk0klt4,19816
@@ -190,11 +195,11 @@ autogluon/tabular/trainer/model_presets/presets.py,sha256=hoWADaOG576Q_XLV1nY_ju
 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.4.1b20250821.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
-autogluon.tabular-1.4.1b20250821.dist-info/METADATA,sha256=JedS27_gdgqCMNhrbxrtfRXXqC9qqYmQ-DAFHwIoqhg,16238
-autogluon.tabular-1.4.1b20250821.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
-autogluon.tabular-1.4.1b20250821.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-autogluon.tabular-1.4.1b20250821.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.tabular-1.4.1b20250821.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
-autogluon.tabular-1.4.1b20250821.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-autogluon.tabular-1.4.1b20250821.dist-info/RECORD,,
+autogluon.tabular-1.4.1b20250823.dist-info/LICENSE,sha256=CeipvOyAZxBGUsFoaFqwkx54aPnIKEtm9a5u2uXxEws,10142
+autogluon.tabular-1.4.1b20250823.dist-info/METADATA,sha256=kLo399XYTpuIWA98xYJRhUC0a9ChfQbN9KXI89F2tWA,16451
+autogluon.tabular-1.4.1b20250823.dist-info/NOTICE,sha256=7nPQuj8Kp-uXsU0S5so3-2dNU5EctS5hDXvvzzehd7E,114
+autogluon.tabular-1.4.1b20250823.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+autogluon.tabular-1.4.1b20250823.dist-info/namespace_packages.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.tabular-1.4.1b20250823.dist-info/top_level.txt,sha256=giERA4R78OkJf2ijn5slgjURlhRPzfLr7waIcGkzYAo,10
+autogluon.tabular-1.4.1b20250823.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autogluon.tabular-1.4.1b20250823.dist-info/RECORD,,