autogluon.tabular 1.4.0__py3-none-any.whl → 1.4.1b20251128__py3-none-any.whl

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)
@@ -161,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:
@@ -225,7 +227,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 +286,6 @@ 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 LightGBM model:
         # Note that self.model contains a <class 'lightgbm.basic.Booster'> not a LightBGMClassifier or LightGBMRegressor object
@@ -299,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
@@ -509,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
@@ -528,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)
@@ -155,7 +156,7 @@ 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())
@@ -319,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/_internal/models/tab2d.py

@@ -278,18 +278,18 @@ class Padder(torch.nn.Module):
         self.cpu_mode = False
 
         # Original flash attention initialization logic
-        x_o, self.indices_o, self.cu_seqlens_o, self.max_seqlen_in_batch_o = unpad_input(x, ~self.padding_mask)
+        x_o, self.indices_o, self.cu_seqlens_o, self.max_seqlen_in_batch_o, *_ = unpad_input(x, ~self.padding_mask)
 
         self.feature_mask_big = einops.repeat(self.feature_mask, 'b f -> b s f', s=n_obs)
-        self.feature_mask_big, _, _, _ = unpad_input(self.feature_mask_big, ~self.padding_mask)
-        x_of, self.indices_of, self.cu_seqlens_of, self.max_seqlen_in_batch_of = unpad_input(x_o, ~self.feature_mask_big)
+        self.feature_mask_big, _, _, _, *_ = unpad_input(self.feature_mask_big, ~self.padding_mask)
+        x_of, self.indices_of, self.cu_seqlens_of, self.max_seqlen_in_batch_of, *_ = unpad_input(x_o, ~self.feature_mask_big)
 
         x_rearranged = einx.rearrange('b s f d -> b f s d', x)
-        x_f, self.indices_f, self.cu_seqlens_f, self.max_seqlen_in_batch_f = unpad_input(x_rearranged, ~self.feature_mask)
+        x_f, self.indices_f, self.cu_seqlens_f, self.max_seqlen_in_batch_f, *_ = unpad_input(x_rearranged, ~self.feature_mask)
 
         self.padding_mask_big = einops.repeat(self.padding_mask, 'b s -> b f s', f=n_feat)
-        self.padding_mask_big, _, _, _ = unpad_input(self.padding_mask_big, ~self.feature_mask)
-        x_fo, self.indices_fo, self.cu_seqlens_fo, self.max_seqlen_in_batch_fo = unpad_input(x_f, ~self.padding_mask_big)
+        self.padding_mask_big, _, _, _, *_ = unpad_input(self.padding_mask_big, ~self.feature_mask)
+        x_fo, self.indices_fo, self.cu_seqlens_fo, self.max_seqlen_in_batch_fo, *_ = unpad_input(x_f, ~self.padding_mask_big)
 
         self.batch_size_f = x_f.shape[0]
         self.batch_size_o = x_o.shape[0]
@@ -307,8 +307,8 @@ class Padder(torch.nn.Module):
 
         # GPU path with flash attention
         x = einx.rearrange('b s f d -> b f s d', x)
-        x, _, _, _ = unpad_input(x, ~self.feature_mask)
-        x, _, _, _ = unpad_input(x, ~self.padding_mask_big)
+        x, _, _, _, *_ = unpad_input(x, ~self.feature_mask)
+        x, _, _, _, *_ = unpad_input(x, ~self.padding_mask_big)
         return x
 
     def base_to_feat(self, x: torch.Tensor) -> torch.Tensor:
@@ -319,8 +319,8 @@ class Padder(torch.nn.Module):
             return x.view(b * f, s * d)
 
         # GPU path with flash attention
-        x, _, _, _ = unpad_input(x, ~self.padding_mask)
-        x, _, _, _ = unpad_input(x, ~self.feature_mask_big)
+        x, _, _, _, *_ = unpad_input(x, ~self.padding_mask)
+        x, _, _, _, *_ = unpad_input(x, ~self.feature_mask_big)
         return x
 
     def obs_to_base(self, x: torch.Tensor) -> torch.Tensor:

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)
@@ -113,6 +114,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"
@@ -138,9 +155,7 @@ class MitraModel(AbstractModel):
         if "verbose" not in hyp:
             hyp["verbose"] = verbosity >= 3
 
-        self.model = model_cls(
-            **hyp,
-        )
+        self.model = model_cls(**hyp)
 
         X = self.preprocess(X, is_train=True)
         if X_val is not None:
@@ -214,6 +229,31 @@ class MitraModel(AbstractModel):
             model._weights_saved = False
         return model
 
+    @classmethod
+    def download_weights(cls, repo_id: str):
+        """
+        Download weights for Mitra from HuggingFace from `repo_id`.
+        Requires an internet connection.
+        """
+        from huggingface_hub import hf_hub_download
+        hf_hub_download(repo_id=repo_id, filename="config.json")
+        hf_hub_download(repo_id=repo_id, filename="model.safetensors")
+
+    @classmethod
+    def download_default_weights(cls):
+        """
+        Download default weights for Mitra from HuggingFace.
+        Includes both classifier and regressor weights.
+
+        This is useful to call when building a docker image to avoid having to download Mitra weights for each instance.
+        This is also useful for benchmarking as a first sanity check
+        to avoid HuggingFace potentially blocking the download.
+
+        Requires an internet connection.
+        """
+        cls.download_weights(repo_id="autogluon/mitra-classifier")
+        cls.download_weights(repo_id="autogluon/mitra-regressor")
+
     @classmethod
     def supported_problem_types(cls) -> Optional[List[str]]:
         return ["binary", "multiclass", "regression"]

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/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)
@@ -243,8 +244,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,
@@ -359,4 +358,3 @@ class RealMLPModel(AbstractModel):
         #  How to mirror RealMLP learning rate scheduler while forcing stopping at a specific epoch?
         tags = {"can_refit_full": False}
         return tags
-        return tags

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)
@@ -97,7 +98,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.
@@ -368,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
@@ -96,13 +97,6 @@ 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_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,
@@ -141,12 +143,80 @@ 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 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)
+        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,7 +244,7 @@ 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, 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,

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)
@@ -198,12 +199,6 @@ class TabPFNV2Model(AbstractModel):
             # logs "Built with PriorLabs-TabPFN"
             self._log_license(device=device)
 
-        if num_gpus == 0:
-            logger.log(
-                30,
-                f"\tWARNING: Running TabPFNv2 on CPU. This can be very slow. We recommend using a GPU instead."
-            )
-
         X = self.preprocess(X, is_train=True)
 
         hps = self._get_model_params()
@@ -306,7 +301,6 @@ 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():

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