autogluon.tabular 1.4.1b20251201__tar.gz → 1.4.1b20251217__tar.gz

{autogluon_tabular-1.4.1b20251201/src/autogluon.tabular.egg-info → autogluon_tabular-1.4.1b20251217}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autogluon.tabular
-Version: 1.4.1b20251201
+Version: 1.4.1b20251217
 Summary: Fast and Accurate ML in 3 Lines of Code
 Home-page: https://github.com/autogluon/autogluon
 Author: AutoGluon Community
@@ -40,8 +40,8 @@ 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.1b20251201
-Requires-Dist: autogluon.features==1.4.1b20251201
+Requires-Dist: autogluon.core==1.4.1b20251217
+Requires-Dist: autogluon.features==1.4.1b20251217
 Provides-Extra: lightgbm
 Requires-Dist: lightgbm<4.7,>=4.0; extra == "lightgbm"
 Provides-Extra: catboost
@@ -55,86 +55,86 @@ Provides-Extra: interpret
 Requires-Dist: interpret-core<0.8,>=0.7.2; extra == "interpret"
 Provides-Extra: fastai
 Requires-Dist: spacy<3.9; extra == "fastai"
-Requires-Dist: torch<2.8,>=2.6; extra == "fastai"
+Requires-Dist: torch<2.10,>=2.6; extra == "fastai"
 Requires-Dist: fastai<2.9,>=2.3.1; extra == "fastai"
 Provides-Extra: tabm
-Requires-Dist: torch<2.8,>=2.6; extra == "tabm"
+Requires-Dist: torch<2.10,>=2.6; extra == "tabm"
 Provides-Extra: tabpfn
 Requires-Dist: tabpfn<2.2,>=2.0.9; extra == "tabpfn"
 Provides-Extra: tabpfnmix
-Requires-Dist: torch<2.8,>=2.6; extra == "tabpfnmix"
+Requires-Dist: torch<2.10,>=2.6; extra == "tabpfnmix"
 Requires-Dist: huggingface_hub[torch]<1.0; extra == "tabpfnmix"
 Requires-Dist: einops<0.9,>=0.7; extra == "tabpfnmix"
 Provides-Extra: mitra
 Requires-Dist: loguru; extra == "mitra"
 Requires-Dist: einx; extra == "mitra"
 Requires-Dist: omegaconf; extra == "mitra"
-Requires-Dist: torch<2.8,>=2.6; extra == "mitra"
+Requires-Dist: torch<2.10,>=2.6; extra == "mitra"
 Requires-Dist: transformers; extra == "mitra"
 Requires-Dist: huggingface_hub[torch]<1.0; extra == "mitra"
 Requires-Dist: einops<0.9,>=0.7; extra == "mitra"
 Provides-Extra: tabicl
 Requires-Dist: tabicl<0.2,>=0.1.3; extra == "tabicl"
 Provides-Extra: ray
-Requires-Dist: autogluon.core[all]==1.4.1b20251201; extra == "ray"
+Requires-Dist: autogluon.core[all]==1.4.1b20251217; extra == "ray"
 Provides-Extra: skex
 Requires-Dist: scikit-learn-intelex<2025.5,>=2024.0; extra == "skex"
 Provides-Extra: imodels
 Requires-Dist: imodels<2.1.0,>=1.3.10; extra == "imodels"
 Provides-Extra: skl2onnx
-Requires-Dist: onnx<1.16.2,>=1.13.0; platform_system == "Windows" and extra == "skl2onnx"
-Requires-Dist: onnx<1.18.0,>=1.13.0; platform_system != "Windows" and extra == "skl2onnx"
-Requires-Dist: skl2onnx<1.18.0,>=1.15.0; extra == "skl2onnx"
-Requires-Dist: onnxruntime<1.20.0,>=1.17.0; extra == "skl2onnx"
-Requires-Dist: onnxruntime-gpu<1.20.0,>=1.17.0; extra == "skl2onnx"
+Requires-Dist: skl2onnx<1.20.0,>=1.15.0; extra == "skl2onnx"
+Requires-Dist: onnx!=1.16.2,<1.21.0,>=1.13.0; platform_system == "Windows" and extra == "skl2onnx"
+Requires-Dist: onnx<1.21.0,>=1.13.0; platform_system != "Windows" and extra == "skl2onnx"
+Requires-Dist: onnxruntime<1.24.0,>=1.17.0; extra == "skl2onnx"
+Requires-Dist: onnxruntime-gpu<1.24.0,>=1.17.0; (platform_system != "Darwin" and platform_machine != "aarch64") and extra == "skl2onnx"
 Provides-Extra: all
+Requires-Dist: autogluon.core[all]==1.4.1b20251217; extra == "all"
+Requires-Dist: loguru; extra == "all"
 Requires-Dist: spacy<3.9; extra == "all"
-Requires-Dist: fastai<2.9,>=2.3.1; extra == "all"
+Requires-Dist: huggingface_hub[torch]<1.0; extra == "all"
 Requires-Dist: einx; extra == "all"
-Requires-Dist: loguru; extra == "all"
-Requires-Dist: transformers; extra == "all"
-Requires-Dist: autogluon.core[all]==1.4.1b20251201; extra == "all"
+Requires-Dist: fastai<2.9,>=2.3.1; extra == "all"
 Requires-Dist: xgboost<3.1,>=2.0; extra == "all"
+Requires-Dist: torch<2.10,>=2.6; extra == "all"
+Requires-Dist: numpy<2.3.0,>=1.25; extra == "all"
 Requires-Dist: einops<0.9,>=0.7; extra == "all"
+Requires-Dist: lightgbm<4.7,>=4.0; extra == "all"
 Requires-Dist: omegaconf; extra == "all"
-Requires-Dist: huggingface_hub[torch]<1.0; extra == "all"
 Requires-Dist: catboost<1.3,>=1.2; extra == "all"
-Requires-Dist: torch<2.8,>=2.6; extra == "all"
-Requires-Dist: numpy<2.3.0,>=1.25; extra == "all"
-Requires-Dist: lightgbm<4.7,>=4.0; extra == "all"
+Requires-Dist: transformers; extra == "all"
 Provides-Extra: tabarena
-Requires-Dist: spacy<3.9; extra == "tabarena"
-Requires-Dist: einx; extra == "tabarena"
-Requires-Dist: transformers; extra == "tabarena"
+Requires-Dist: catboost<1.3,>=1.2; extra == "tabarena"
+Requires-Dist: autogluon.core[all]==1.4.1b20251217; extra == "tabarena"
+Requires-Dist: tabicl<0.2,>=0.1.3; extra == "tabarena"
 Requires-Dist: loguru; extra == "tabarena"
-Requires-Dist: autogluon.core[all]==1.4.1b20251201; extra == "tabarena"
+Requires-Dist: huggingface_hub[torch]<1.0; extra == "tabarena"
+Requires-Dist: einx; extra == "tabarena"
 Requires-Dist: pytabkit<1.7,>=1.6; extra == "tabarena"
+Requires-Dist: fastai<2.9,>=2.3.1; extra == "tabarena"
 Requires-Dist: xgboost<3.1,>=2.0; extra == "tabarena"
+Requires-Dist: torch<2.10,>=2.6; extra == "tabarena"
+Requires-Dist: numpy<2.3.0,>=1.25; extra == "tabarena"
 Requires-Dist: einops<0.9,>=0.7; extra == "tabarena"
 Requires-Dist: lightgbm<4.7,>=4.0; extra == "tabarena"
-Requires-Dist: interpret-core<0.8,>=0.7.2; extra == "tabarena"
 Requires-Dist: omegaconf; extra == "tabarena"
-Requires-Dist: huggingface_hub[torch]<1.0; extra == "tabarena"
-Requires-Dist: catboost<1.3,>=1.2; extra == "tabarena"
-Requires-Dist: tabicl<0.2,>=0.1.3; extra == "tabarena"
-Requires-Dist: torch<2.8,>=2.6; extra == "tabarena"
+Requires-Dist: spacy<3.9; extra == "tabarena"
+Requires-Dist: transformers; extra == "tabarena"
 Requires-Dist: tabpfn<2.2,>=2.0.9; extra == "tabarena"
-Requires-Dist: numpy<2.3.0,>=1.25; extra == "tabarena"
-Requires-Dist: fastai<2.9,>=2.3.1; extra == "tabarena"
+Requires-Dist: interpret-core<0.8,>=0.7.2; extra == "tabarena"
 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"
-Requires-Dist: torch<2.8,>=2.6; extra == "tests"
+Requires-Dist: torch<2.10,>=2.6; extra == "tests"
 Requires-Dist: huggingface_hub[torch]<1.0; extra == "tests"
 Requires-Dist: einops<0.9,>=0.7; extra == "tests"
 Requires-Dist: imodels<2.1.0,>=1.3.10; extra == "tests"
-Requires-Dist: onnx<1.16.2,>=1.13.0; platform_system == "Windows" and extra == "tests"
-Requires-Dist: onnx<1.18.0,>=1.13.0; platform_system != "Windows" and extra == "tests"
-Requires-Dist: skl2onnx<1.18.0,>=1.15.0; extra == "tests"
-Requires-Dist: onnxruntime<1.20.0,>=1.17.0; extra == "tests"
-Requires-Dist: onnxruntime-gpu<1.20.0,>=1.17.0; extra == "tests"
+Requires-Dist: skl2onnx<1.20.0,>=1.15.0; extra == "tests"
+Requires-Dist: onnx!=1.16.2,<1.21.0,>=1.13.0; platform_system == "Windows" and extra == "tests"
+Requires-Dist: onnx<1.21.0,>=1.13.0; platform_system != "Windows" and extra == "tests"
+Requires-Dist: onnxruntime<1.24.0,>=1.17.0; extra == "tests"
+Requires-Dist: onnxruntime-gpu<1.24.0,>=1.17.0; (platform_system != "Darwin" and platform_machine != "aarch64") and extra == "tests"
 Dynamic: author
 Dynamic: classifier
 Dynamic: description

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/setup.py

@@ -92,28 +92,16 @@ extras_require = {
     ],
 }
 
-is_aarch64 = platform.machine() == "aarch64"
-is_darwin = sys.platform == "darwin"
-
-if is_darwin or is_aarch64:
-    # For macOS or aarch64, only use CPU version
-    extras_require["skl2onnx"] = [
-        "onnx>=1.13.0,<1.16.2;platform_system=='Windows'",  # cap at 1.16.1 for issue https://github.com/onnx/onnx/issues/6267
-        "onnx>=1.13.0,<1.18.0;platform_system!='Windows'",
-        "skl2onnx>=1.15.0,<1.18.0",
-        # For macOS, there isn't a onnxruntime-gpu package installed with skl2onnx.
-        # Therefore, we install onnxruntime explicitly here just for macOS.
-        "onnxruntime>=1.17.0,<1.20.0",
-    ]
-else:
-    # For other platforms, include both CPU and GPU versions
-    extras_require["skl2onnx"] = [
-        "onnx>=1.13.0,<1.16.2;platform_system=='Windows'",  # cap at 1.16.1 for issue https://github.com/onnx/onnx/issues/6267
-        "onnx>=1.13.0,<1.18.0;platform_system!='Windows'",
-        "skl2onnx>=1.15.0,<1.18.0",
-        "onnxruntime>=1.17.0,<1.20.0",  # install for gpu system due to https://github.com/autogluon/autogluon/issues/3804
-        "onnxruntime-gpu>=1.17.0,<1.20.0",
-    ]
+extras_require["skl2onnx"] = [
+    "skl2onnx>=1.15.0,<1.20.0",
+    # Sync ONNX requirements with multimodal/setup.py
+    "onnx>=1.13.0,!=1.16.2,<1.21.0;platform_system=='Windows'",  # exclude 1.16.2 for issue https://github.com/onnx/onnx/issues/6267
+    "onnx>=1.13.0,<1.21.0;platform_system!='Windows'",
+    # For macOS, there isn't a onnxruntime-gpu package installed with skl2onnx.
+    # Therefore, we install onnxruntime explicitly here just for macOS.
+    "onnxruntime>=1.17.0,<1.24.0",
+    "onnxruntime-gpu>=1.17.0,<1.24.0; platform_system != 'Darwin' and platform_machine != 'aarch64'",
+]
 
 # TODO: v1.0: Rename `all` to `core`, make `all` contain everything.
 all_requires = []

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/src/autogluon/tabular/learner/default_learner.py

@@ -143,6 +143,7 @@ class DefaultLearner(AbstractTabularLearner):
             infer_limit=infer_limit,
             infer_limit_batch_size=infer_limit_batch_size,
             groups=groups,
+            label_cleaner=copy.deepcopy(self.label_cleaner),
             **trainer_fit_kwargs,
         )
         self.save_trainer(trainer=trainer)

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/src/autogluon/tabular/models/__init__.py

@@ -1,5 +1,6 @@
 from autogluon.core.models.abstract.abstract_model import AbstractModel
 
+from .tabprep.prep_lgb_model import PrepLGBModel
 from .automm.automm_model import MultiModalPredictorModel
 from .automm.ft_transformer import FTTransformerModel
 from .catboost.catboost_model import CatBoostModel

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/src/autogluon/tabular/models/catboost/catboost_model.py

@@ -146,7 +146,7 @@ class CatBoostModel(AbstractModel):
         num_cols_train = len(X.columns)
         num_classes = self.num_classes if self.num_classes else 1  # self.num_classes could be None after initialization if it's a regression problem
 
-        X = self.preprocess(X)
+        X = self.preprocess(X, y=y, is_train=True)
         cat_features = list(X.select_dtypes(include="category").columns)
         X = Pool(data=X, label=y, cat_features=cat_features, weight=sample_weight)
 

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/src/autogluon/tabular/models/lgb/lgb_model.py

@@ -103,10 +103,46 @@ class LGBModel(AbstractModel):
             Scales linearly with the number of estimators, number of classes, and number of leaves.
             Memory usage peaks during model saving, with the peak consuming approximately 2-4x the size of the model in memory.
         """
+        data_mem_usage = get_approximate_df_mem_usage(X).sum()
+        return cls._estimate_memory_usage_common(
+            num_features=X.shape[1],
+            data_mem_usage=data_mem_usage,
+            hyperparameters=hyperparameters,
+            num_classes=num_classes,
+        )
+
+    @classmethod
+    def _estimate_memory_usage_static_lite(
+        cls,
+        num_samples: int,
+        num_features: int,
+        num_bytes_per_cell: float = 4,
+        hyperparameters: dict = None,
+        num_classes: int = 1,
+        **kwargs,
+    ) -> int:
+        data_mem_usage = num_samples * num_features * num_bytes_per_cell
+        return cls._estimate_memory_usage_common(
+            num_features=num_features,
+            data_mem_usage=data_mem_usage,
+            hyperparameters=hyperparameters,
+            num_classes=num_classes,
+        )
+
+    @classmethod
+    def _estimate_memory_usage_common(
+        cls,
+        num_features: int,
+        data_mem_usage: int | float,
+        hyperparameters: dict | None = None,
+        num_classes: int = 1,
+    ) -> int:
+        """
+        Utility method to avoid code duplication
+        """
         if hyperparameters is None:
             hyperparameters = {}
         num_classes = num_classes if num_classes else 1  # num_classes could be None after initialization if it's a regression problem
-        data_mem_usage = get_approximate_df_mem_usage(X).sum()
         data_mem_usage_bytes = data_mem_usage * 5 + data_mem_usage / 4 * num_classes  # TODO: Extremely crude approximation, can be vastly improved
 
         n_trees_per_estimator = num_classes if num_classes > 2 else 1
@@ -114,7 +150,7 @@ class LGBModel(AbstractModel):
         max_bins = hyperparameters.get("max_bins", 255)
         num_leaves = hyperparameters.get("num_leaves", 31)
         # Memory usage of histogram based on https://github.com/microsoft/LightGBM/issues/562#issuecomment-304524592
-        histogram_mem_usage_bytes = 20 * max_bins * len(X.columns) * num_leaves
+        histogram_mem_usage_bytes = 20 * max_bins * num_features * num_leaves
         histogram_mem_usage_bytes_max = hyperparameters.get("histogram_pool_size", None)
         if histogram_mem_usage_bytes_max is not None:
             histogram_mem_usage_bytes_max *= 1e6  # Convert megabytes to bytes, `histogram_pool_size` is in MB.
@@ -124,11 +160,11 @@ class LGBModel(AbstractModel):
 
         mem_size_per_estimator = n_trees_per_estimator * num_leaves * 100  # very rough estimate
         n_estimators = hyperparameters.get("num_boost_round", DEFAULT_NUM_BOOST_ROUND)
-        n_estimators_min = min(n_estimators, 1000)
-        mem_size_estimators = n_estimators_min * mem_size_per_estimator  # memory estimate after fitting up to 1000 estimators
+        n_estimators_min = min(n_estimators, 5000)
+        mem_size_estimators = n_estimators_min * mem_size_per_estimator  # memory estimate after fitting up to 5000 estimators
 
         approx_mem_size_req = data_mem_usage_bytes + histogram_mem_usage_bytes + mem_size_estimators
-        return approx_mem_size_req
+        return int(approx_mem_size_req)
 
     def _fit(self, X, y, X_val=None, y_val=None, time_limit=None, num_gpus=0, num_cpus=0, sample_weight=None, sample_weight_val=None, verbosity=2, **kwargs):
         try_import_lightgbm()  # raise helpful error message if LightGBM isn't installed
@@ -371,6 +407,9 @@ class LGBModel(AbstractModel):
         X = self.preprocess(X, **kwargs)
 
         y_pred_proba = self.model.predict(X, num_threads=num_cpus)
+        return self._post_process_predictions(y_pred_proba=y_pred_proba)
+
+    def _post_process_predictions(self, y_pred_proba) -> np.ndarray:
         if self.problem_type == QUANTILE:
             # y_pred_proba is a pd.DataFrame, need to convert
             y_pred_proba = y_pred_proba.to_numpy()
@@ -423,7 +462,7 @@ class LGBModel(AbstractModel):
         self,
         X: DataFrame,
         y: Series,
-        params,
+        params: dict,
         X_val=None,
         y_val=None,
         X_test=None,
@@ -432,11 +471,14 @@ class LGBModel(AbstractModel):
         sample_weight_val=None,
         sample_weight_test=None,
         save=False,
+        init_train=None,
+        init_val=None,
+        init_test=None,
     ):
         lgb_dataset_params_keys = ["two_round"]  # Keys that are specific to lightGBM Dataset object construction.
         data_params = {key: params[key] for key in lgb_dataset_params_keys if key in params}.copy()
 
-        X = self.preprocess(X, is_train=True)
+        X = self.preprocess(X, y=y, is_train=True)
         if X_val is not None:
             X_val = self.preprocess(X_val)
         if X_test is not None:
@@ -458,7 +500,13 @@ class LGBModel(AbstractModel):
 
         # X, W_train = self.convert_to_weight(X=X)
         dataset_train = construct_dataset(
-            x=X, y=y, location=os.path.join("self.path", "datasets", "train"), params=data_params, save=save, weight=sample_weight
+            x=X,
+            y=y,
+            location=os.path.join("self.path", "datasets", "train"),
+            params=data_params,
+            save=save,
+            weight=sample_weight,
+            init_score=init_train,
         )
         # dataset_train = construct_dataset_lowest_memory(X=X, y=y, location=self.path + 'datasets/train', params=data_params)
         if X_val is not None:
@@ -471,6 +519,7 @@ class LGBModel(AbstractModel):
                 params=data_params,
                 save=save,
                 weight=sample_weight_val,
+                init_score=init_val,
             )
             # dataset_val = construct_dataset_lowest_memory(X=X_val, y=y_val, location=self.path + 'datasets/val', reference=dataset_train, params=data_params)
         else:
@@ -485,6 +534,7 @@ class LGBModel(AbstractModel):
                 params=data_params,
                 save=save,
                 weight=sample_weight_test,
+                init_score=init_test,
             )
         else:
             dataset_test = None

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/src/autogluon/tabular/models/lgb/lgb_utils.py

@@ -104,11 +104,11 @@ def softclass_lgbobj(preds, train_data):
     return grad.flatten("F"), hess.flatten("F")
 
 
-def construct_dataset(x: DataFrame, y: Series, location=None, reference=None, params=None, save=False, weight=None):
+def construct_dataset(x: DataFrame, y: Series, location=None, reference=None, params=None, save=False, weight=None, init_score=None):
     try_import_lightgbm()
     import lightgbm as lgb
 
-    dataset = lgb.Dataset(data=x, label=y, reference=reference, free_raw_data=True, params=params, weight=weight)
+    dataset = lgb.Dataset(data=x, label=y, reference=reference, free_raw_data=True, params=params, weight=weight, init_score=init_score)
 
     if save:
         assert location is not None

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/src/autogluon/tabular/models/rf/rf_model.py

@@ -151,13 +151,13 @@ class RFModel(AbstractModel):
             hyperparameters = {}
         n_estimators_final = hyperparameters.get("n_estimators", 300)
         if isinstance(n_estimators_final, int):
-            n_estimators_minimum = min(40, n_estimators_final)
+            n_estimators = n_estimators_final
         else:  # if search space
-            n_estimators_minimum = 40
+            n_estimators = 40
         num_trees_per_estimator = cls._get_num_trees_per_estimator_static(problem_type=problem_type, num_classes=num_classes)
         bytes_per_estimator = num_trees_per_estimator * len(X) / 60000 * 1e6  # Underestimates by 3x on ExtraTrees
-        expected_min_memory_usage = int(bytes_per_estimator * n_estimators_minimum)
-        return expected_min_memory_usage
+        expected_memory_usage = int(bytes_per_estimator * n_estimators)
+        return expected_memory_usage
 
     def _validate_fit_memory_usage(self, mem_error_threshold: float = 0.5, mem_warning_threshold: float = 0.4, mem_size_threshold: int = 1e7, **kwargs):
         return super()._validate_fit_memory_usage(

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/src/autogluon/tabular/models/tabm/tabm_model.py

@@ -88,7 +88,7 @@ class TabMModel(AbstractModel):
         if X_val is None:
             from autogluon.core.utils import generate_train_test_split
 
-            X_train, X_val, y_train, y_val = generate_train_test_split(
+            X, X_val, y, y_val = generate_train_test_split(
                 X=X,
                 y=y,
                 problem_type=self.problem_type,
@@ -99,7 +99,7 @@ class TabMModel(AbstractModel):
         hyp = self._get_model_params()
         bool_to_cat = hyp.pop("bool_to_cat", True)
 
-        X = self.preprocess(X, is_train=True, bool_to_cat=bool_to_cat)
+        X = self.preprocess(X, y=y, is_train=True, bool_to_cat=bool_to_cat)
         if X_val is not None:
             X_val = self.preprocess(X_val)
 

autogluon_tabular-1.4.1b20251217/src/autogluon/tabular/models/tabprep/prep_lgb_model.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from ..lgb.lgb_model import LGBModel
+from .prep_mixin import ModelAgnosticPrepMixin
+
+
+class PrepLGBModel(ModelAgnosticPrepMixin, LGBModel):
+    ag_key = "GBM_PREP"
+    ag_name = "LightGBMPrep"
+
+    @classmethod
+    def _estimate_memory_usage_static(cls, **kwargs) -> int:
+        memory_usage = super()._estimate_memory_usage_static(**kwargs)
+        # FIXME: 1.5 runs OOM on kddcup09_appetency fold 2 repeat 0 prep_LightGBM_r49_BAG_L1
+        return memory_usage * 2.0  # FIXME: For some reason this underestimates mem usage without this
+
+    @classmethod
+    def _estimate_memory_usage_static_lite(cls, **kwargs) -> int:
+        memory_usage = super()._estimate_memory_usage_static_lite(**kwargs)
+        # FIXME: 1.5 runs OOM on kddcup09_appetency fold 2 repeat 0 prep_LightGBM_r49_BAG_L1
+        return memory_usage * 2.0  # FIXME: For some reason this underestimates mem usage without this

autogluon_tabular-1.4.1b20251217/src/autogluon/tabular/models/tabprep/prep_mixin.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import logging
+from typing import Type
+
+import numpy as np
+import pandas as pd
+
+from autogluon.features import ArithmeticFeatureGenerator
+from autogluon.features import CategoricalInteractionFeatureGenerator
+from autogluon.features import OOFTargetEncodingFeatureGenerator
+from autogluon.features import BulkFeatureGenerator
+from autogluon.features.generators.abstract import AbstractFeatureGenerator
+
+logger = logging.getLogger(__name__)
+
+# TODO: In future we can have a feature generator registry like what is done for models
+_feature_generator_class_lst = [
+    ArithmeticFeatureGenerator,
+    CategoricalInteractionFeatureGenerator,
+    OOFTargetEncodingFeatureGenerator,
+]
+
+_feature_generator_class_map = {
+    feature_generator_cls.__name__: feature_generator_cls for feature_generator_cls in _feature_generator_class_lst
+}
+
+
+def _recursive_expand_prep_param(prep_param: tuple | list[list | tuple]) -> list[tuple]:
+    if isinstance(prep_param, list):
+        if len(prep_param) == 0:
+            param_type = "list"
+        elif len(prep_param) == 2:
+            if isinstance(prep_param[0], (str, AbstractFeatureGenerator)):
+                param_type = "generator"
+            else:
+                param_type = "list"
+        else:
+            param_type = "list"
+    elif isinstance(prep_param, tuple):
+        param_type = "generator"
+    else:
+        raise ValueError(f"Invalid value for prep_param: {prep_param}")
+    if param_type == "list":
+        out = []
+        for p in prep_param:
+            out += _recursive_expand_prep_param(p)
+        return out
+    elif param_type == "generator":
+        return [prep_param]
+    else:
+        raise ValueError(f"Invalid value for prep_param: {prep_param}")
+
+
+# FIXME: Why is preprocessing twice as slow per fold when bagging LightGBM??? Need to investigate. Try sequential fold fit
+# TODO: Why is `prep_params` a dict instead of a list?
+class ModelAgnosticPrepMixin:
+    def _estimate_dtypes_after_preprocessing(self, X: pd.DataFrame, **kwargs) -> int:
+        prep_params = self._get_ag_params().get("prep_params", None)
+        if prep_params is None:
+            prep_params = []
+
+        # FIXME: Temporarily simplify for memory calculation
+        prep_params = _recursive_expand_prep_param(prep_params)
+
+        X_nunique = X.nunique().values
+        n_categorical = X.select_dtypes(exclude=[np.number]).shape[1]
+        n_numeric = X.loc[:, X_nunique > 2].select_dtypes(include=[np.number]).shape[1]
+        n_binary = X.loc[:, X_nunique <= 2].select_dtypes(include=[np.number]).shape[
+            1]  # NOTE: It can happen that features have less than two unique values if cleaning is applied before the bagging, i.e. Bioresponse
+
+        assert n_numeric + n_categorical + n_binary == X.shape[1]  # NOTE: FOr debugging, to be removed later
+        for preprocessor_cls_name, init_params in prep_params:
+            if preprocessor_cls_name == 'ArithmeticFeatureGenerator':
+                prep_cls = ArithmeticFeatureGenerator(target_type=self.problem_type, **init_params)
+            elif preprocessor_cls_name == 'CategoricalInteractionFeatureGenerator':
+                prep_cls = CategoricalInteractionFeatureGenerator(target_type=self.problem_type, **init_params)
+            elif preprocessor_cls_name == 'OOFTargetEncodingFeatureGenerator':
+                prep_cls = OOFTargetEncodingFeatureGenerator(target_type=self.problem_type, **init_params)
+            else:
+                raise ValueError(f"Unknown preprocessor class name: {preprocessor_cls_name}")
+            n_numeric, n_categorical, n_binary = prep_cls.estimate_new_dtypes(n_numeric, n_categorical, n_binary,
+                                                                              num_classes=self.num_classes)
+
+        return n_numeric, n_categorical, n_binary
+
+    def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:
+        hyperparameters = self._get_model_params()
+        n_numeric, n_categorical, n_binary = self._estimate_dtypes_after_preprocessing(X=X, **kwargs)
+
+        if hasattr(self, "_estimate_memory_usage_static_lite"):
+            return self._estimate_memory_usage_static_lite(
+                num_samples=X.shape[0],
+                num_features=n_numeric + n_categorical + n_binary,
+                num_bytes_per_cell=4,
+                hyperparameters=hyperparameters,
+                problem_type=self.problem_type,
+                num_classes=self.num_classes,
+                **kwargs,
+            )
+
+        # TODO: Replace with memory estimation logic based on no. of features instead of dataframe generation
+        shape = X.shape[0]
+        df_lst = []
+        if n_numeric > 0:
+            X_estimate = np.random.random(size=[shape, n_numeric]).astype(np.float32)
+            X_estimate_numeric = pd.DataFrame(X_estimate)
+            df_lst.append(X_estimate_numeric)
+        if n_categorical > 0:
+            cardinality = int(X.select_dtypes(exclude=[np.number]).nunique().mean())
+            X_estimate = np.random.randint(0, cardinality, [shape, n_categorical]).astype('str')
+            X_estimate_cat = pd.DataFrame(X_estimate)
+            df_lst.append(X_estimate_cat)
+        if n_binary > 0:
+            X_estimate = np.random.randint(0, 2, [shape, n_binary]).astype(np.int8)
+            X_estimate_binary = pd.DataFrame(X_estimate)
+            df_lst.append(X_estimate_binary)
+        X = pd.concat(df_lst, ignore_index=True, axis=1)
+
+        return self.estimate_memory_usage_static(
+            X=X,
+            problem_type=self.problem_type,
+            num_classes=self.num_classes,
+            hyperparameters=hyperparameters,
+            **kwargs,
+        )
+
+    def _init_preprocessor(
+            self,
+            preprocessor_cls: Type[AbstractFeatureGenerator] | str,
+            init_params: dict | None,
+    ) -> AbstractFeatureGenerator:
+        if isinstance(preprocessor_cls, str):
+            preprocessor_cls = _feature_generator_class_map[preprocessor_cls]
+        if init_params is None:
+            init_params = {}
+        _init_params = dict(
+            verbosity=0,
+            random_state=self.random_seed,  # FIXME: Not a generic param
+            target_type=self.problem_type,  # FIXME: Not a generic param
+        )
+        _init_params.update(**init_params)
+        return preprocessor_cls(
+            **_init_params,
+        )
+
+    def _recursive_init_preprocessors(self, prep_param: tuple | list[list | tuple]):
+        if isinstance(prep_param, list):
+            if len(prep_param) == 0:
+                param_type = "list"
+            elif len(prep_param) == 2:
+                if isinstance(prep_param[0], (str, AbstractFeatureGenerator)):
+                    param_type = "generator"
+                else:
+                    param_type = "list"
+            else:
+                param_type = "list"
+        elif isinstance(prep_param, tuple):
+            param_type = "generator"
+        else:
+            raise ValueError(f"Invalid value for prep_param: {prep_param}")
+
+        if param_type == "list":
+            out = []
+            for i, p in enumerate(prep_param):
+                out.append(self._recursive_init_preprocessors(p))
+            return out
+        elif param_type == "generator":
+            assert len(prep_param) == 2
+            preprocessor_cls = prep_param[0]
+            init_params = prep_param[1]
+            return self._init_preprocessor(preprocessor_cls=preprocessor_cls, init_params=init_params)
+        else:
+            raise ValueError(f"Invalid value for prep_param: {prep_param}")
+
+    def get_preprocessors(self) -> list[AbstractFeatureGenerator]:
+        ag_params = self._get_ag_params()
+        prep_params = ag_params.get("prep_params", None)
+        passthrough_types = ag_params.get("prep_params.passthrough_types", None)
+        if prep_params is None:
+            return []
+        if not prep_params:
+            return []
+
+        preprocessors = self._recursive_init_preprocessors(prep_param=prep_params)
+        if len(preprocessors) == 0:
+            return []
+        if len(preprocessors) == 1 and isinstance(preprocessors[0], AbstractFeatureGenerator):
+            return preprocessors
+        else:
+            preprocessors = [BulkFeatureGenerator(
+                generators=preprocessors,
+                # TODO: "false_recursive" technically can slow down inference, but need to optimize `True` first
+                #  Refer to `Bioresponse` dataset where setting to `True` -> 200s fit time vs `false_recursive` -> 1s fit time
+                remove_unused_features="false_recursive",
+                post_drop_duplicates=True,
+                passthrough=True,
+                passthrough_types=passthrough_types,
+                verbosity=0,
+            )]
+            return preprocessors
+
+    def _preprocess(self, X: pd.DataFrame, y=None, is_train: bool = False, **kwargs):
+        if is_train:
+            self.preprocessors = self.get_preprocessors()
+            if self.preprocessors:
+                assert y is not None, f"y must be specified to fit preprocessors... Likely the inheriting class isn't passing `y` in its `preprocess` call."
+                # FIXME: add `post_drop_useless`, example: anneal has many useless features
+                feature_metadata_in = self._feature_metadata
+                for prep in self.preprocessors:
+                    X = prep.fit_transform(X, y, feature_metadata_in=feature_metadata_in)
+                    # FIXME: Nick: This is incorrect because it strips away special dtypes. Need to do this properly by fixing in the preprocessors
+                    feature_metadata_in = prep.feature_metadata
+                self._feature_metadata = feature_metadata_in
+                self._features_internal = self._feature_metadata.get_features()
+        else:
+            for prep in self.preprocessors:
+                X = prep.transform(X)
+
+        return super()._preprocess(X, y=y, is_train=is_train, **kwargs)

{autogluon_tabular-1.4.1b20251201 → autogluon_tabular-1.4.1b20251217}/src/autogluon/tabular/models/tabular_nn/torch/tabular_nn_torch.py

@@ -371,7 +371,6 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
         best_epoch = 0
         best_val_metric = -np.inf  # higher = better
         best_val_update = 0
-        val_improve_epoch = 0  # most recent epoch where validation-score strictly improved
         start_fit_time = time.time()
         if time_limit is not None:
             time_limit = time_limit - (start_fit_time - start_time)
@@ -496,7 +495,7 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
 
             if time_limit is not None:
                 time_elapsed = time.time() - start_fit_time
-                time_epoch_average = time_elapsed / (epoch + 1)
+                time_epoch_average = time_elapsed / max(epoch, 1)  # avoid divide by 0
                 time_left = time_limit - time_elapsed
                 if time_left < time_epoch_average:
                     logger.log(20, f"\tRan out of time, stopping training early. (Stopping on epoch {epoch})")