autogluon.tabular 1.4.1b20250822__tar.gz → 1.4.1b20250823__tar.gz

{autogluon.tabular-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.4.1b20250822
+Version: 1.4.1b20250823
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -38,6 +38,7 @@ Provides-Extra: lightgbm
 Provides-Extra: catboost
 Provides-Extra: xgboost
 Provides-Extra: realmlp
+Provides-Extra: interpret
 Provides-Extra: fastai
 Provides-Extra: tabm
 Provides-Extra: tabpfn

{autogluon.tabular-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/setup.py

@@ -49,6 +49,9 @@ extras_require = {
     "realmlp": [
         "pytabkit>=1.6,<1.7",
     ],
+    "interpret": [
+        "interpret-core>=0.7.2,<0.8",
+    ],
     "fastai": [
         "spacy<3.9",
         "torch",  # version range defined in `core/_setup_utils.py`
@@ -129,6 +132,7 @@ extras_require["all"] = all_requires
 
 tabarena_requires = copy.deepcopy(all_requires)
 for extra_package in [
+    "interpret", 
     "tabicl",
     "tabpfn",
     "realmlp",
@@ -139,6 +143,7 @@ extras_require["tabarena"] = tabarena_requires
 
 test_requires = []
 for test_package in [
+    "interpret", 
     "tabicl",  # Currently has unnecessary extra dependencies such as xgboost and wandb
     "tabpfn",
     "realmlp",  # Will consider to put as part of `all_requires` once part of a portfolio

{autogluon.tabular-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/src/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-1.4.1b20250823/src/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-1.4.1b20250823/src/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-1.4.1b20250823/src/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-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/src/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-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/src/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-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/src/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-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/src/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-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/src/autogluon/tabular/version.py

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

{autogluon.tabular-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/src/autogluon.tabular.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.tabular
-Version: 1.4.1b20250822
+Version: 1.4.1b20250823
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -38,6 +38,7 @@ Provides-Extra: lightgbm
 Provides-Extra: catboost
 Provides-Extra: xgboost
 Provides-Extra: realmlp
+Provides-Extra: interpret
 Provides-Extra: fastai
 Provides-Extra: tabm
 Provides-Extra: tabpfn

{autogluon.tabular-1.4.1b20250822 → autogluon.tabular-1.4.1b20250823}/src/autogluon.tabular.egg-info/SOURCES.txt

@@ -42,6 +42,11 @@ src/autogluon/tabular/models/catboost/catboost_utils.py
 src/autogluon/tabular/models/catboost/hyperparameters/__init__.py
 src/autogluon/tabular/models/catboost/hyperparameters/parameters.py
 src/autogluon/tabular/models/catboost/hyperparameters/searchspaces.py
+src/autogluon/tabular/models/ebm/__init__.py
+src/autogluon/tabular/models/ebm/ebm_model.py
+src/autogluon/tabular/models/ebm/hyperparameters/__init__.py
+src/autogluon/tabular/models/ebm/hyperparameters/parameters.py
+src/autogluon/tabular/models/ebm/hyperparameters/searchspaces.py
 src/autogluon/tabular/models/fastainn/__init__.py
 src/autogluon/tabular/models/fastainn/callbacks.py
 src/autogluon/tabular/models/fastainn/fastai_helpers.py