autogluon.tabular 1.4.1b20250801__tar.gz → 1.4.1b20250803__tar.gz

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/PKG-INFO

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

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/catboost/catboost_model.py

@@ -48,7 +48,6 @@ class CatBoostModel(AbstractModel):
         default_params = get_param_baseline(problem_type=self.problem_type)
         for param, val in default_params.items():
             self._set_default_param_value(param, val)
-        self._set_default_param_value("random_seed", 0)  # Remove randomness for reproducibility
         # Set 'allow_writing_files' to True in order to keep log files created by catboost during training (these will be saved in the directory where AutoGluon stores this model)
         self._set_default_param_value("allow_writing_files", False)  # Disables creation of catboost logging files during training by default
         if self.problem_type != SOFTCLASS:  # TODO: remove this after catboost 0.24
@@ -117,6 +116,9 @@ class CatBoostModel(AbstractModel):
         approx_mem_size_req = data_mem_usage_bytes + histogram_mem_usage_bytes + baseline_memory_bytes
         return approx_mem_size_req
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("random_seed", "N/A")
+
     # TODO: Use Pool in preprocess, optimize bagging to do Pool.split() to avoid re-computing pool for each fold! Requires stateful + y
     #  Pool is much more memory efficient, avoids copying data twice in memory
     def _fit(self, X, y, X_val=None, y_val=None, time_limit=None, num_gpus=0, num_cpus=-1, sample_weight=None, sample_weight_val=None, **kwargs):
@@ -126,6 +128,8 @@ class CatBoostModel(AbstractModel):
 
         ag_params = self._get_ag_params()
         params = self._get_model_params()
+        params["random_seed"] = self.random_seed
+
         params["thread_count"] = num_cpus
         if self.problem_type == SOFTCLASS:
             # FIXME: This is extremely slow due to unoptimized metric / objective sent to CatBoost

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/fastainn/tabular_nn_fastai.py

@@ -322,8 +322,8 @@ class NNFastAiTabularModel(AbstractModel):
         # Make deterministic
         from fastai.torch_core import set_seed
 
-        set_seed(0, True)
-        dls.rng.seed(0)
+        set_seed(self.random_seed, True)
+        dls.rng.seed(self.random_seed)
 
         if self.problem_type == QUANTILE:
             dls.c = len(self.quantile_levels)

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/knn/knn_model.py

@@ -214,7 +214,7 @@ class KNNModel(AbstractModel):
         def sample_func(chunk, frac):
             # Guarantee at least 1 sample (otherwise log_loss would crash or model would return different column counts in pred_proba)
             n = max(math.ceil(len(chunk) * frac), 1)
-            return chunk.sample(n=n, replace=False, random_state=0)
+            return chunk.sample(n=n, replace=False, random_state=self.random_seed)
 
         if self.problem_type != REGRESSION:
             y_df = y.to_frame(name="label").reset_index(drop=True)

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/lgb/lgb_model.py

@@ -128,6 +128,13 @@ class LGBModel(AbstractModel):
         approx_mem_size_req = data_mem_usage_bytes + histogram_mem_usage_bytes + mem_size_estimators
         return approx_mem_size_req
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        if "seed_value" in hyperparameters:
+            return hyperparameters["seed_value"]
+        if "seed" in hyperparameters:
+            return hyperparameters["seed"]
+        return "N/A"
+
     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
         start_time = time.time()
@@ -225,7 +232,6 @@ class LGBModel(AbstractModel):
         if log_period is not None:
             callbacks.append(log_evaluation(period=log_period))
 
-        seed_val = params.pop("seed_value", 0)
         train_params = {
             "params": params,
             "train_set": dataset_train,
@@ -285,8 +291,8 @@ class LGBModel(AbstractModel):
             train_params["params"]["num_classes"] = self.num_classes
         elif self.problem_type == QUANTILE:
             train_params["params"]["quantile_levels"] = self.quantile_levels
-        if seed_val is not None:
-            train_params["params"]["seed"] = seed_val
+
+        train_params["params"]["seed"] = self.random_seed
 
         # Train LightGBM model:
         # Note that self.model contains a <class 'lightgbm.basic.Booster'> not a LightBGMClassifier or LightGBMRegressor object

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/lr/lr_model.py

@@ -155,13 +155,16 @@ class LinearModel(AbstractModel):
         return self._pipeline.fit_transform(X)
 
     def _set_default_params(self):
-        default_params = {"random_state": 0, "fit_intercept": True}
+        default_params = {"fit_intercept": True}
         if self.problem_type != REGRESSION:
             default_params.update({"solver": _get_solver(self.problem_type)})
         default_params.update(get_param_baseline())
         for param, val in default_params.items():
             self._set_default_param_value(param, val)
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("random_seed", "N/A")
+
     def _get_default_searchspace(self):
         return get_default_searchspace(self.problem_type)
 
@@ -215,7 +218,7 @@ class LinearModel(AbstractModel):
         total_iter = 0
         total_iter_used = 0
         total_max_iter = sum(max_iter_list)
-        model = model_cls(max_iter=max_iter_list[0], **params)
+        model = model_cls(max_iter=max_iter_list[0], random_state=self.random_seed, **params)
         early_stop = False
         for i, cur_max_iter in enumerate(max_iter_list):
             if time_left is not None and (i > 0):

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/mitra/mitra_model.py

@@ -77,6 +77,9 @@ class MitraModel(AbstractModel):
 
         return X
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("seed", "N/A")
+
     def _fit(
         self,
         X: pd.DataFrame,
@@ -139,6 +142,7 @@ class MitraModel(AbstractModel):
             hyp["verbose"] = verbosity >= 3
 
         self.model = model_cls(
+            seed=self.random_seed,
             **hyp,
         )
 

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/realmlp/realmlp_model.py

@@ -82,6 +82,9 @@ class RealMLPModel(AbstractModel):
                 model_cls = RealMLP_TD_S_Regressor
         return model_cls
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("random_state", "N/A")
+
     def _fit(
         self,
         X: pd.DataFrame,
@@ -175,6 +178,7 @@ class RealMLPModel(AbstractModel):
         self.model = model_cls(
             n_threads=num_cpus,
             device=device,
+            random_state=self.random_seed,
             **init_kwargs,
             **hyp,
         )
@@ -243,8 +247,6 @@ class RealMLPModel(AbstractModel):
 
     def _set_default_params(self):
         default_params = dict(
-            random_state=0,
-
             # Don't use early stopping by default, seems to work well without
             use_early_stopping=False,
             early_stopping_additive_patience=40,

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/rf/rf_model.py

@@ -97,7 +97,6 @@ class RFModel(AbstractModel):
             #  This size scales linearly with number of rows.
             "max_leaf_nodes": 15000,
             "n_jobs": -1,
-            "random_state": 0,
             "bootstrap": True,  # Required for OOB estimates, setting to False will raise exception if bagging.
             # TODO: min_samples_leaf=5 is too large on most problems, however on some datasets it helps a lot (airlines likes >40 min_samples_leaf, adult likes 2 much better than 1)
             #  This value would need to be tuned per dataset, likely very worthwhile.
@@ -108,6 +107,9 @@ class RFModel(AbstractModel):
         for param, val in default_params.items():
             self._set_default_param_value(param, val)
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("random_state", "N/A")
+
     # TODO: Add in documentation that Categorical default is the first index
     # TODO: enable HPO for RF models
     def _get_default_searchspace(self):
@@ -206,7 +208,7 @@ class RFModel(AbstractModel):
             # FIXME: This is inefficient but sklearnex doesn't support computing oob_score after training
             params["oob_score"] = True
 
-        model = model_cls(**params)
+        model = model_cls(random_state=self.random_seed, **params)
 
         time_train_start = time.time()
         for i, n_estimators in enumerate(n_estimator_increments):

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/tabicl/tabicl_model.py

@@ -89,6 +89,7 @@ class TabICLModel(AbstractModel):
             **hyp,
             device=device,
             n_jobs=num_cpus,
+            random_state=self.random_seed,
         )
         X = self.preprocess(X)
         self.model = self.model.fit(
@@ -96,12 +97,8 @@ class TabICLModel(AbstractModel):
             y=y,
         )
 
-    def _set_default_params(self):
-        default_params = {
-            "random_state": 42,
-        }
-        for param, val in default_params.items():
-            self._set_default_param_value(param, val)
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("random_state", "N/A")
 
     def _get_default_auxiliary_params(self) -> dict:
         default_auxiliary_params = super()._get_default_auxiliary_params()

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/tabm/tabm_model.py

@@ -106,6 +106,7 @@ class TabMModel(AbstractModel):
             device=device,
             problem_type=self.problem_type,
             early_stopping_metric=self.stopping_metric,
+            random_state=self.random_seed,
             **hyp,
         )
 
@@ -141,12 +142,8 @@ class TabMModel(AbstractModel):
 
         return X
 
-    def _set_default_params(self):
-        default_params = dict(
-            random_state=0,
-        )
-        for param, val in default_params.items():
-            self._set_default_param_value(param, val)
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("random_state", "N/A")
 
     @classmethod
     def supported_problem_types(cls) -> list[str] | None:

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py

@@ -178,7 +178,7 @@ class TabPFNMixModel(AbstractModel):
         elif weights_path is not None:
             logger.log(15, f'\tLoading pre-trained weights from file... (weights_path="{weights_path}")')
 
-        cfg = ConfigRun(hyperparams=params, task=task, device=device)
+        cfg = ConfigRun(hyperparams=params, task=task, device=device, seed=self.random_seed)
 
         if cfg.hyperparams["max_epochs"] == 0 and cfg.hyperparams["n_ensembles"] != 1:
             logger.log(
@@ -242,14 +242,14 @@ class TabPFNMixModel(AbstractModel):
         return self
 
     # TODO: Make this generic by creating a generic `preprocess_train` and putting this logic prior to `_preprocess`.
-    def _subsample_data(self, X: pd.DataFrame, y: pd.Series, num_rows: int, random_state=0) -> (pd.DataFrame, pd.Series):
+    def _subsample_data(self, X: pd.DataFrame, y: pd.Series, num_rows: int) -> (pd.DataFrame, pd.Series):
         num_rows_to_drop = len(X) - num_rows
         X, _, y, _ = generate_train_test_split(
             X=X,
             y=y,
             problem_type=self.problem_type,
             test_size=num_rows_to_drop,
-            random_state=random_state,
+            random_state=self.random_seed,
             min_cls_count_train=1,
         )
         return X, y

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/tabpfnv2/tabpfnv2_model.py

@@ -201,6 +201,7 @@ class TabPFNV2Model(AbstractModel):
         X = self.preprocess(X, is_train=True)
 
         hps = self._get_model_params()
+        hps["random_state"] = self.random_seed
         hps["device"] = device
         hps["n_jobs"] = num_cpus
         hps["categorical_features_indices"] = self._cat_indices
@@ -300,12 +301,14 @@ class TabPFNV2Model(AbstractModel):
 
     def _set_default_params(self):
         default_params = {
-            "random_state": 42,
             "ignore_pretraining_limits": True,  # to ignore warnings and size limits
         }
         for param, val in default_params.items():
             self._set_default_param_value(param, val)
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("random_state", "N/A")
+
     @classmethod
     def supported_problem_types(cls) -> list[str] | None:
         return ["binary", "multiclass", "regression"]

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/tabular_nn/hyperparameters/parameters.py

@@ -7,9 +7,7 @@ from autogluon.core.constants import BINARY, MULTICLASS, QUANTILE, REGRESSION
 
 def get_fixed_params(framework):
     """Parameters that currently cannot be searched during HPO"""
-    fixed_params = {
-        # 'seed_value': 0,  # random seed for reproducibility (set = None to ignore)
-    }
+    fixed_params = {}
     # TODO: v1.2 Change default epochs_wo_improve to "auto", so that None can mean no early stopping.
     pytorch_fixed_params = {
         "num_epochs": 1000,  # maximum number of epochs (passes over full dataset) for training NN

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/tabular_nn/torch/tabular_nn_torch.py

@@ -164,6 +164,9 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
 
         return processor_kwargs, optimizer_kwargs, fit_kwargs, loss_kwargs, params
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("seed_value", "N/A")
+
     def _fit(
         self,
         X: pd.DataFrame,
@@ -191,7 +194,7 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
 
         processor_kwargs, optimizer_kwargs, fit_kwargs, loss_kwargs, params = self._prepare_params(params=params)
 
-        seed_value = params.pop("seed_value", 0)
+        seed_value = self.random_seed
 
         self._num_cpus_infer = params.pop("_num_cpus_infer", 1)
         if seed_value is not None:  # Set seeds

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/models/xgboost/xgboost_model.py

@@ -75,11 +75,15 @@ class XGBoostModel(AbstractModel):
 
         return X
 
+    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
+        return hyperparameters.get("seed", "N/A")
+
     def _fit(self, X, y, X_val=None, y_val=None, time_limit=None, num_gpus=0, num_cpus=None, sample_weight=None, sample_weight_val=None, verbosity=2, **kwargs):
         # TODO: utilize sample_weight_val in early-stopping if provided
         start_time = time.time()
         ag_params = self._get_ag_params()
         params = self._get_model_params()
+        params["seed"] = self.random_seed
         generate_curves = ag_params.get("generate_curves", False)
 
         if generate_curves:

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon/tabular/version.py

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

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon.tabular.egg-info/PKG-INFO

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

{autogluon.tabular-1.4.1b20250801 → autogluon.tabular-1.4.1b20250803}/src/autogluon.tabular.egg-info/requires.txt

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