autogluon.tabular 1.4.1b20250916__py3-none-any.whl → 1.4.1b20251212__py3-none-any.whl

autogluon/tabular/models/catboost/catboost_model.py

@@ -39,6 +39,7 @@ class CatBoostModel(AbstractModel):
     ag_priority_by_problem_type = MappingProxyType({
         SOFTCLASS: 60
     })
+    seed_name = "random_seed"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -116,9 +117,6 @@ 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):
@@ -128,7 +126,6 @@ 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:
@@ -314,6 +311,8 @@ class CatBoostModel(AbstractModel):
         max_memory_iters = math.floor(available_mem * max_memory_proportion / mem_usage_per_iter)
 
         final_iters = min(default_iters, min(max_memory_iters, estimated_iters_in_time))
+        if final_iters < 1:
+            raise TimeLimitExceeded
         return final_iters
 
     def _predict_proba(self, X, **kwargs):

autogluon/tabular/models/ebm/ebm_model.py

@@ -56,6 +56,7 @@ class EBMModel(AbstractModel):
     ag_key = "EBM"
     ag_name = "EBM"
     ag_priority = 35
+    seed_name = "random_state"
     
     def _fit(
         self,
@@ -89,7 +90,7 @@ class EBMModel(AbstractModel):
 
         # Init Class
         model_cls = get_class_from_problem_type(self.problem_type)
-        self.model = model_cls(random_state=self.random_seed, **params)
+        self.model = model_cls(**params)
 
         # Handle validation data format for EBM
         fit_X = X
@@ -112,11 +113,6 @@ class EBMModel(AbstractModel):
             )
             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():

autogluon/tabular/models/fastainn/tabular_nn_fastai.py

@@ -103,6 +103,7 @@ class NNFastAiTabularModel(AbstractModel):
     ag_priority_by_problem_type = MappingProxyType({
         MULTICLASS: 95,
     })
+    seed_name = "random_seed"
 
     model_internals_file_name = "model-internals.pkl"
 
@@ -322,8 +323,9 @@ class NNFastAiTabularModel(AbstractModel):
         # Make deterministic
         from fastai.torch_core import set_seed
 
-        set_seed(self.random_seed, True)
-        dls.rng.seed(self.random_seed)
+        random_seed = params.pop(self.seed_name, self.default_random_seed)
+        set_seed(random_seed, True)
+        dls.rng.seed(random_seed)
 
         if self.problem_type == QUANTILE:
             dls.c = len(self.quantile_levels)

autogluon/tabular/models/knn/knn_model.py

@@ -255,9 +255,13 @@ class KNNModel(AbstractModel):
             self._X_unused_index = [i for i in range(num_rows_max) if i not in idx]
         return self.model
 
-    def _get_maximum_resources(self) -> Dict[str, Union[int, float]]:
+    def _get_maximum_resources(self) -> dict[str, int | float]:
         # use at most 32 cpus to avoid OpenBLAS error: https://github.com/autogluon/autogluon/issues/1020
-        return {"num_cpus": 32}
+        # no GPU support
+        return {
+            "num_cpus": 32,
+            "num_gpus": 0,
+        }
 
     def _get_default_resources(self):
         # use at most 32 cpus to avoid OpenBLAS error: https://github.com/autogluon/autogluon/issues/1020

autogluon/tabular/models/lgb/lgb_model.py

@@ -46,6 +46,8 @@ class LGBModel(AbstractModel):
     ag_priority_by_problem_type = MappingProxyType({
         SOFTCLASS: 100
     })
+    seed_name = "seed"
+    seed_name_alt = ["seed_value", "random_seed", "random_state"]
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -128,13 +130,6 @@ 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()
@@ -168,7 +163,7 @@ class LGBModel(AbstractModel):
                 #  Before enabling GPU, we should add code to detect that GPU-enabled version is installed and that a valid GPU exists.
                 #  GPU training heavily alters accuracy, often in a negative manner. We will have to be careful about when to use GPU.
                 params["device"] = "gpu"
-                logger.log(20, f"\tTraining {self.name} with GPU, note that this may negatively impact model quality compared to CPU training.")
+                logger.log(20, f"\tWarning: Training LightGBM with GPU. This may negatively impact model quality compared to CPU training.")
         logger.log(15, f"\tFitting {num_boost_round} rounds... Hyperparameters: {params}")
 
         if "num_threads" not in params:
@@ -292,8 +287,6 @@ class LGBModel(AbstractModel):
         elif self.problem_type == QUANTILE:
             train_params["params"]["quantile_levels"] = self.quantile_levels
 
-        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
         from lightgbm.basic import LightGBMError
@@ -305,16 +298,28 @@ class LGBModel(AbstractModel):
             try:
                 self.model = train_lgb_model(early_stopping_callback_kwargs=early_stopping_callback_kwargs, **train_params)
             except LightGBMError:
-                if train_params["params"].get("device", "cpu") != "gpu":
+                if train_params["params"].get("device", "cpu") not in ["gpu", "cuda"]:
                     raise
                 else:
-                    logger.warning(
-                        "Warning: GPU mode might not be installed for LightGBM, GPU training raised an exception. Falling back to CPU training..."
-                        "Refer to LightGBM GPU documentation: https://github.com/Microsoft/LightGBM/tree/master/python-package#build-gpu-version"
-                        "One possible method is:"
-                        "\tpip uninstall lightgbm -y"
-                        "\tpip install lightgbm --install-option=--gpu"
-                    )
+                    if train_params["params"]["device"] == "gpu":
+                        logger.warning(
+                            "Warning: GPU mode might not be installed for LightGBM, "
+                            "GPU training raised an exception. Falling back to CPU training..."
+                            "Refer to LightGBM GPU documentation: "
+                            "https://github.com/Microsoft/LightGBM/tree/master/python-package#build-gpu-version"
+                            "One possible method is:"
+                            "\tpip uninstall lightgbm -y"
+                            "\tpip install lightgbm --install-option=--gpu"
+                        )
+                    elif train_params["params"]["device"] == "cuda":
+                        # Current blocker for using CUDA over GPU: https://github.com/microsoft/LightGBM/issues/6828
+                        # Note that device="cuda" works if AutoGluon (and therefore LightGBM) is installed via conda.
+                        logger.warning(
+                            "Warning: CUDA mode might not be installed for LightGBM, "
+                            "CUDA training raised an exception. Falling back to CPU training..."
+                            "Refer to LightGBM CUDA documentation: "
+                            "https://github.com/Microsoft/LightGBM/tree/master/python-package#build-cuda-version"
+                        )
                     train_params["params"]["device"] = "cpu"
                     self.model = train_lgb_model(early_stopping_callback_kwargs=early_stopping_callback_kwargs, **train_params)
             retrain = False
@@ -515,17 +520,44 @@ class LGBModel(AbstractModel):
         default_auxiliary_params.update(extra_auxiliary_params)
         return default_auxiliary_params
 
-    def _is_gpu_lgbm_installed(self):
+    @staticmethod
+    def _is_gpu_lgbm_installed():
+        # Taken from https://github.com/microsoft/LightGBM/issues/3939
+        try_import_lightgbm()
+        import lightgbm
+
+        rng = np.random.RandomState(42)
+        data = rng.rand(25, 2)
+        label = rng.randint(2, size=25)
+
+        try:
+            train_data = lightgbm.Dataset(data, label=label)
+            params = {
+                "device": "gpu",
+                "verbose": -1,
+            }
+            gbm = lightgbm.train(params, num_boost_round=10, train_set=train_data)
+            return True
+        except Exception as e:
+            return False
+
+    @staticmethod
+    def _is_cuda_lgbm_installed():
         # Taken from https://github.com/microsoft/LightGBM/issues/3939
         try_import_lightgbm()
         import lightgbm
 
+        rng = np.random.RandomState(42)
+        data = rng.rand(25, 2)
+        label = rng.randint(2, size=25)
+
         try:
-            data = np.random.rand(50, 2)
-            label = np.random.randint(2, size=50)
             train_data = lightgbm.Dataset(data, label=label)
-            params = {"device": "gpu"}
-            gbm = lightgbm.train(params, train_set=train_data, verbose=-1)
+            params = {
+                "device": "cuda",
+                "verbose": -1,
+            }
+            gbm = lightgbm.train(params, num_boost_round=10, train_set=train_data)
             return True
         except Exception as e:
             return False
@@ -534,7 +566,7 @@ class LGBModel(AbstractModel):
         minimum_resources = {
             "num_cpus": 1,
         }
-        if is_gpu_available and self._is_gpu_lgbm_installed():
+        if is_gpu_available:
             minimum_resources["num_gpus"] = 0.5
         return minimum_resources
 

autogluon/tabular/models/lr/lr_model.py

@@ -43,6 +43,7 @@ class LinearModel(AbstractModel):
     ag_key = "LR"
     ag_name = "LinearModel"
     ag_priority = 30
+    seed_name = "random_state"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -162,9 +163,6 @@ class LinearModel(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_seed", "N/A")
-
     def _get_default_searchspace(self):
         return get_default_searchspace(self.problem_type)
 
@@ -218,7 +216,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], random_state=self.random_seed, **params)
+        model = model_cls(max_iter=max_iter_list[0], **params)
         early_stop = False
         for i, cur_max_iter in enumerate(max_iter_list):
             if time_left is not None and (i > 0):
@@ -322,6 +320,10 @@ class LinearModel(AbstractModel):
     ) -> int:
         return 4 * get_approximate_df_mem_usage(X).sum()
 
+    def _get_maximum_resources(self) -> dict[str, int | float]:
+        # no GPU support
+        return {"num_gpus": 0}
+
     @classmethod
     def supported_problem_types(cls) -> list[str] | None:
         return ["binary", "multiclass", "regression"]

autogluon/tabular/models/lr/lr_preprocessing_utils.py

@@ -5,20 +5,19 @@ from autogluon.features.generators import OneHotEncoderFeatureGenerator
 
 class OheFeaturesGenerator(BaseEstimator, TransformerMixin):
     def __init__(self):
-        self._feature_names = []
-        self._encoder = None
+        pass
 
     def fit(self, X, y=None):
-        self._encoder = OneHotEncoderFeatureGenerator(max_levels=10000, verbosity=0)
-        self._encoder.fit(X)
-        self._feature_names = self._encoder.features_out
+        self.encoder_ = OneHotEncoderFeatureGenerator(max_levels=10000, verbosity=0)
+        self.encoder_.fit(X)
+        self.feature_names_ = self.encoder_.features_out
         return self
 
     def transform(self, X, y=None):
-        return self._encoder.transform_ohe(X)
+        return self.encoder_.transform_ohe(X)
 
     def get_feature_names(self):
-        return self._feature_names
+        return self.feature_names_
 
 
 class NlpDataPreprocessor(BaseEstimator, TransformerMixin):

autogluon/tabular/models/mitra/mitra_model.py

@@ -32,6 +32,7 @@ class MitraModel(AbstractModel):
     ag_name = "Mitra"
     weights_file_name = "model.pt"
     ag_priority = 55
+    seed_name = "seed"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -77,9 +78,6 @@ 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,
@@ -157,10 +155,7 @@ class MitraModel(AbstractModel):
         if "verbose" not in hyp:
             hyp["verbose"] = verbosity >= 3
 
-        self.model = model_cls(
-            seed=self.random_seed,
-            **hyp,
-        )
+        self.model = model_cls(**hyp)
 
         X = self.preprocess(X, is_train=True)
         if X_val is not None:

autogluon/tabular/models/realmlp/realmlp_model.py

@@ -51,6 +51,7 @@ class RealMLPModel(AbstractModel):
     ag_key = "REALMLP"
     ag_name = "RealMLP"
     ag_priority = 75
+    seed_name = "random_state"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -82,9 +83,6 @@ 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,
@@ -178,7 +176,6 @@ class RealMLPModel(AbstractModel):
         self.model = model_cls(
             n_threads=num_cpus,
             device=device,
-            random_state=self.random_seed,
             **init_kwargs,
             **hyp,
         )

autogluon/tabular/models/rf/rf_model.py

@@ -30,6 +30,7 @@ class RFModel(AbstractModel):
     ag_key = "RF"
     ag_name = "RandomForest"
     ag_priority = 80
+    seed_name = "random_state"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -107,9 +108,6 @@ 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):
@@ -153,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(
@@ -208,7 +206,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(random_state=self.random_seed, **params)
+        model = model_cls(**params)
 
         time_train_start = time.time()
         for i, n_estimators in enumerate(n_estimator_increments):
@@ -370,6 +368,10 @@ class RFModel(AbstractModel):
 
         return self._convert_proba_to_unified_form(y_oof_pred_proba)
 
+    def _get_maximum_resources(self) -> dict[str, int | float]:
+        # no GPU support
+        return {"num_gpus": 0}
+
     def _get_default_auxiliary_params(self) -> dict:
         default_auxiliary_params = super()._get_default_auxiliary_params()
         extra_auxiliary_params = dict(

autogluon/tabular/models/tabicl/tabicl_model.py

@@ -35,6 +35,7 @@ class TabICLModel(AbstractModel):
     ag_key = "TABICL"
     ag_name = "TabICL"
     ag_priority = 65
+    seed_name = "random_state"
 
     def get_model_cls(self):
         from tabicl import TabICLClassifier
@@ -89,7 +90,6 @@ class TabICLModel(AbstractModel):
             **hyp,
             device=device,
             n_jobs=num_cpus,
-            random_state=self.random_seed,
         )
         X = self.preprocess(X)
         self.model = self.model.fit(
@@ -97,9 +97,6 @@ class TabICLModel(AbstractModel):
             y=y,
         )
 
-    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()
         default_auxiliary_params.update(

autogluon/tabular/models/tabm/tabm_model.py

@@ -39,6 +39,7 @@ class TabMModel(AbstractModel):
     ag_key = "TABM"
     ag_name = "TabM"
     ag_priority = 85
+    seed_name = "random_state"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -48,6 +49,7 @@ class TabMModel(AbstractModel):
         self._indicator_columns = None
         self._features_bool = None
         self._bool_to_cat = None
+        self.device = None
 
     def _fit(
         self,
@@ -106,7 +108,6 @@ class TabMModel(AbstractModel):
             device=device,
             problem_type=self.problem_type,
             early_stopping_metric=self.stopping_metric,
-            random_state=self.random_seed,
             **hyp,
         )
 
@@ -142,8 +143,80 @@ class TabMModel(AbstractModel):
 
         return X
 
-    def _get_random_seed_from_hyperparameters(self, hyperparameters: dict) -> int | None | str:
-        return hyperparameters.get("random_state", "N/A")
+    def save(self, path: str = None, verbose=True) -> str:
+        """
+        Need to set device to CPU to be able to load on a non-GPU environment
+        """
+        import torch
+
+        # Save on CPU to ensure the model can be loaded without GPU
+        if self.model is not None:
+            self.device = self.model.device_
+            device_cpu = torch.device("cpu")
+            self.model.model_ = self.model.model_.to(device_cpu)
+            self.model.device_ = device_cpu
+        path = super().save(path=path, verbose=verbose)
+        # Put the model back to the device after the save
+        if self.model is not None:
+            self.model.model_.to(self.device)
+            self.model.device_ = self.device
+
+        return path
+
+    @classmethod
+    def load(cls, path: str, reset_paths=True, verbose=True):
+        """
+        Loads the model from disk to memory.
+        The loaded model will be on the same device it was trained on (cuda/mps);
+        if the device is not available (trained on GPU, deployed on CPU), then `cpu` will be used.
+
+        Parameters
+        ----------
+        path : str
+            Path to the saved model, minus the file name.
+            This should generally be a directory path ending with a '/' character (or appropriate path separator value depending on OS).
+            The model file is typically located in os.path.join(path, cls.model_file_name).
+        reset_paths : bool, default True
+            Whether to reset the self.path value of the loaded model to be equal to path.
+            It is highly recommended to keep this value as True unless accessing the original self.path value is important.
+            If False, the actual valid path and self.path may differ, leading to strange behaviour and potential exceptions if the model needs to load any other files at a later time.
+        verbose : bool, default True
+            Whether to log the location of the loaded file.
+
+        Returns
+        -------
+        model : cls
+            Loaded model object.
+        """
+        import torch
+
+        model: TabMModel = super().load(path=path, reset_paths=reset_paths, verbose=verbose)
+
+        # Put the model on the same device it was trained on (GPU/MPS) if it is available; otherwise use CPU
+        if model.model is not None:
+            original_device_type = model.device.type
+            if "cuda" in original_device_type:
+                # cuda: nvidia GPU
+                device = torch.device(original_device_type if torch.cuda.is_available() else "cpu")
+            elif "mps" in original_device_type:
+                # mps: Apple Silicon
+                device = torch.device(original_device_type if torch.backends.mps.is_available() else "cpu")
+            else:
+                device = torch.device(original_device_type)
+
+            if verbose and (original_device_type != device.type):
+                logger.log(15, f"Model is trained on {original_device_type}, but the device is not available - loading on {device.type}")
+
+            model.set_device(device=device)
+
+        return model
+
+    def set_device(self, device):
+        self.device = device
+        if self.model is not None:
+            self.model.device_ = device
+            if self.model.model_ is not None:
+                self.model.model_ = self.model.model_.to(device)
 
     @classmethod
     def supported_problem_types(cls) -> list[str] | None:

autogluon/tabular/models/tabpfnmix/tabpfnmix_model.py

@@ -42,6 +42,7 @@ class TabPFNMixModel(AbstractModel):
     ag_key = "TABPFNMIX"
     ag_name = "TabPFNMix"
     ag_priority = 45
+    seed_name = "random_state"
 
     weights_file_name = "model.pt"
 
@@ -123,6 +124,7 @@ class TabPFNMixModel(AbstractModel):
             raise AssertionError(f"Max allowed classes for the model is {max_classes}, " f"but found {self.num_classes} classes.")
 
         params = self._get_model_params()
+        random_state = params.pop(self.seed_name, self.default_random_seed)
         sample_rows = ag_params.get("sample_rows", None)
         sample_rows_val = ag_params.get("sample_rows_val", None)
         max_rows = ag_params.get("max_rows", None)
@@ -133,11 +135,11 @@ class TabPFNMixModel(AbstractModel):
 
         # TODO: Make sample_rows generic
         if sample_rows is not None and isinstance(sample_rows, int) and len(X) > sample_rows:
-            X, y = self._subsample_data(X=X, y=y, num_rows=sample_rows)
+            X, y = self._subsample_data(X=X, y=y, num_rows=sample_rows, random_state=random_state)
 
         # TODO: Make sample_rows generic
         if X_val is not None and y_val is not None and sample_rows_val is not None and isinstance(sample_rows_val, int) and len(X_val) > sample_rows_val:
-            X_val, y_val = self._subsample_data(X=X_val, y=y_val, num_rows=sample_rows_val)
+            X_val, y_val = self._subsample_data(X=X_val, y=y_val, num_rows=sample_rows_val, random_state=random_state)
 
         from ._internal.core.enums import Task
         if self.problem_type in [REGRESSION, QUANTILE]:
@@ -178,7 +180,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, seed=self.random_seed)
+        cfg = ConfigRun(hyperparams=params, task=task, device=device, seed=random_state)
 
         if cfg.hyperparams["max_epochs"] == 0 and cfg.hyperparams["n_ensembles"] != 1:
             logger.log(
@@ -242,14 +244,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) -> (pd.DataFrame, pd.Series):
+    def _subsample_data(self, X: pd.DataFrame, y: pd.Series, num_rows: int, random_state: int | None = 0) -> (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=self.random_seed,
+            random_state=random_state,
             min_cls_count_train=1,
         )
         return X, y

autogluon/tabular/models/tabpfnv2/tabpfnv2_model.py

@@ -122,6 +122,7 @@ class TabPFNV2Model(AbstractModel):
     ag_key = "TABPFNV2"
     ag_name = "TabPFNv2"
     ag_priority = 105
+    seed_name = "random_state"
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
@@ -201,7 +202,6 @@ 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
@@ -306,9 +306,6 @@ class TabPFNV2Model(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")
-
     @classmethod
     def supported_problem_types(cls) -> list[str] | None:
         return ["binary", "multiclass", "regression"]

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

@@ -50,6 +50,7 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
     ag_key = "NN_TORCH"
     ag_name = "NeuralNetTorch"
     ag_priority = 25
+    seed_name = "seed_value"
 
     # Constants used throughout this class:
     unique_category_str = np.nan  # string used to represent missing values and unknown categories for categorical features.
@@ -164,9 +165,6 @@ 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,
@@ -194,7 +192,7 @@ class TabularNeuralNetTorchModel(AbstractNeuralNetworkModel):
 
         processor_kwargs, optimizer_kwargs, fit_kwargs, loss_kwargs, params = self._prepare_params(params=params)
 
-        seed_value = self.random_seed
+        seed_value = params.pop(self.seed_name, self.default_random_seed)
 
         self._num_cpus_infer = params.pop("_num_cpus_infer", 1)
         if seed_value is not None:  # Set seeds
@@ -373,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)