autogluon.tabular 1.5.1b20260105__py3-none-any.whl → 1.5.1b20260117__py3-none-any.whl

autogluon/tabular/models/lgb/lgb_model.py

@@ -25,7 +25,9 @@ from .hyperparameters.parameters import DEFAULT_NUM_BOOST_ROUND, get_lgb_objecti
 from .hyperparameters.searchspaces import get_default_searchspace
 from .lgb_utils import construct_dataset, train_lgb_model
 
-warnings.filterwarnings("ignore", category=UserWarning, message="Starting from version")  # lightGBM brew libomp warning
+warnings.filterwarnings(
+    "ignore", category=UserWarning, message="Starting from version"
+)  # lightGBM brew libomp warning
 warnings.filterwarnings("ignore", category=FutureWarning, message="Dask dataframe query")  # lightGBM dask-expr warning
 logger = logging.getLogger(__name__)
 
@@ -40,12 +42,11 @@ class LGBModel(AbstractModel):
     Extra hyperparameter options:
         ag.early_stop : int, specifies the early stopping rounds. Defaults to an adaptive strategy. Recommended to keep default.
     """
+
     ag_key = "GBM"
     ag_name = "LightGBM"
     ag_priority = 90
-    ag_priority_by_problem_type = MappingProxyType({
-        SOFTCLASS: 100
-    })
+    ag_priority_by_problem_type = MappingProxyType({SOFTCLASS: 100})
     seed_name = "seed"
     seed_name_alt = ["seed_value", "random_seed", "random_state"]
 
@@ -53,8 +54,8 @@ class LGBModel(AbstractModel):
         super().__init__(**kwargs)
 
         self._features_internal_map = None
-        self._features_internal_list = None
         self._requires_remap = None
+        self._features_internal_lgbm = None
 
     def _set_default_params(self):
         default_params = get_param_baseline(problem_type=self.problem_type)
@@ -66,10 +67,15 @@ class LGBModel(AbstractModel):
 
     # Use specialized LightGBM metric if available (fast), otherwise use custom func generator
     def _get_stopping_metric_internal(self):
-        stopping_metric = lgb_utils.convert_ag_metric_to_lgbm(ag_metric_name=self.stopping_metric.name, problem_type=self.problem_type)
+        stopping_metric = lgb_utils.convert_ag_metric_to_lgbm(
+            ag_metric_name=self.stopping_metric.name, problem_type=self.problem_type
+        )
         if stopping_metric is None:
             stopping_metric = lgb_utils.func_generator(
-                metric=self.stopping_metric, is_higher_better=True, needs_pred_proba=not self.stopping_metric.needs_pred, problem_type=self.problem_type
+                metric=self.stopping_metric,
+                is_higher_better=True,
+                needs_pred_proba=not self.stopping_metric.needs_pred,
+                problem_type=self.problem_type,
             )
             stopping_metric_name = self.stopping_metric.name
         else:
@@ -78,7 +84,13 @@ class LGBModel(AbstractModel):
 
     def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:
         hyperparameters = self._get_model_params()
-        return self.estimate_memory_usage_static(X=X, problem_type=self.problem_type, num_classes=self.num_classes, hyperparameters=hyperparameters, **kwargs)
+        return self.estimate_memory_usage_static(
+            X=X,
+            problem_type=self.problem_type,
+            num_classes=self.num_classes,
+            hyperparameters=hyperparameters,
+            **kwargs,
+        )
 
     # FIXME: Don't use `hyperparameters.get("max_bins", 255)`, instead get the defaults all at once!
     @classmethod
@@ -142,8 +154,12 @@ class LGBModel(AbstractModel):
         """
         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_bytes = data_mem_usage * 5 + data_mem_usage / 4 * num_classes  # TODO: Extremely crude approximation, can be vastly improved
+        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_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
 
@@ -161,12 +177,27 @@ 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, 5000)
-        mem_size_estimators = n_estimators_min * mem_size_per_estimator  # memory estimate after fitting up to 5000 estimators
+        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 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):
+    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()
         ag_params = self._get_ag_params()
@@ -192,14 +223,19 @@ class LGBModel(AbstractModel):
         stopping_metric, stopping_metric_name = self._get_stopping_metric_internal()
 
         num_boost_round = params.pop("num_boost_round", DEFAULT_NUM_BOOST_ROUND)
-        dart_retrain = params.pop("dart_retrain", False)  # Whether to retrain the model to get optimal iteration if model is trained in 'dart' mode.
+        dart_retrain = params.pop(
+            "dart_retrain", False
+        )  # Whether to retrain the model to get optimal iteration if model is trained in 'dart' mode.
         if num_gpus != 0:
             if "device" not in params:
                 # TODO: lightgbm must have a special install to support GPU: https://github.com/Microsoft/LightGBM/tree/master/python-package#build-gpu-version
                 #  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"\tWarning: Training LightGBM with GPU. 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:
@@ -213,7 +249,15 @@ class LGBModel(AbstractModel):
 
         num_rows_train = len(X)
         dataset_train, dataset_val, dataset_test = self.generate_datasets(
-            X=X, y=y, params=params, X_val=X_val, y_val=y_val, X_test=X_test, y_test=y_test, sample_weight=sample_weight, sample_weight_val=sample_weight_val
+            X=X,
+            y=y,
+            params=params,
+            X_val=X_val,
+            y_val=y_val,
+            X_test=X_test,
+            y_test=y_test,
+            sample_weight=sample_weight,
+            sample_weight_val=sample_weight_val,
         )
         gc.collect()
 
@@ -226,7 +270,9 @@ class LGBModel(AbstractModel):
             # TODO: Better solution: Track trend to early stop when score is far worse than best score, or score is trending worse over time
             early_stopping_rounds = ag_params.get("early_stop", "adaptive")
             if isinstance(early_stopping_rounds, (str, tuple, list)):
-                early_stopping_rounds = self._get_early_stopping_rounds(num_rows_train=num_rows_train, strategy=early_stopping_rounds)
+                early_stopping_rounds = self._get_early_stopping_rounds(
+                    num_rows_train=num_rows_train, strategy=early_stopping_rounds
+                )
             if early_stopping_rounds is None:
                 early_stopping_rounds = 999999
             reporter = kwargs.get("reporter", None)
@@ -235,7 +281,7 @@ class LGBModel(AbstractModel):
                 if "metric" not in params or params["metric"] == "":
                     params["metric"] = train_loss_name
                 elif train_loss_name not in params["metric"]:
-                    params["metric"] = f'{params["metric"]},{train_loss_name}'
+                    params["metric"] = f"{params['metric']},{train_loss_name}"
             # early stopping callback will be added later by QuantileBooster if problem_type==QUANTILE
             early_stopping_callback_kwargs = dict(
                 stopping_rounds=early_stopping_rounds,
@@ -315,7 +361,7 @@ class LGBModel(AbstractModel):
             if "metric" not in train_params["params"] or train_params["params"]["metric"] == "":
                 train_params["params"]["metric"] = stopping_metric
             elif stopping_metric not in train_params["params"]["metric"]:
-                train_params["params"]["metric"] = f'{stopping_metric},{train_params["params"]["metric"]}'
+                train_params["params"]["metric"] = f"{stopping_metric},{train_params['params']['metric']}"
 
         if self.problem_type == SOFTCLASS:
             train_params["params"]["objective"] = lgb_utils.softclass_lgbobj
@@ -332,7 +378,9 @@ class LGBModel(AbstractModel):
             warnings.filterwarnings("ignore", message="Overriding the parameters from Reference Dataset.")
             warnings.filterwarnings("ignore", message="categorical_column in param dict is overridden.")
             try:
-                self.model = train_lgb_model(early_stopping_callback_kwargs=early_stopping_callback_kwargs, **train_params)
+                self.model = train_lgb_model(
+                    early_stopping_callback_kwargs=early_stopping_callback_kwargs, **train_params
+                )
             except LightGBMError:
                 if train_params["params"].get("device", "cpu") not in ["gpu", "cuda"]:
                     raise
@@ -357,7 +405,9 @@ class LGBModel(AbstractModel):
                             "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)
+                    self.model = train_lgb_model(
+                        early_stopping_callback_kwargs=early_stopping_callback_kwargs, **train_params
+                    )
             retrain = False
             if train_params["params"].get("boosting_type", "") == "dart":
                 if dataset_val is not None and dart_retrain and (self.model.best_iteration != num_boost_round):
@@ -434,7 +484,73 @@ class LGBModel(AbstractModel):
             else:  # Should this ever happen?
                 return y_pred_proba[:, 1]
 
-    def _preprocess_nonadaptive(self, X, is_train=False, **kwargs):
+    @staticmethod
+    def _clean_column_name_for_lgb(column_name):
+        """Clean column names while keeping most semantic meaning."""
+        if not isinstance(column_name, str):
+            return column_name
+        for symbol in ['"', ",", ":", "{", "}", "[", "]"]:
+            column_name = column_name.replace(symbol, "_")
+        return column_name
+
+    @classmethod
+    def _rename_columns(cls, features: list) -> dict:
+        """
+        Generate a deterministic, one-to-one mapping from original feature names to
+        LightGBM-safe, unique column names.
+
+        This method:
+        - Cleans feature names using `_clean_column_name_for_lgb`
+        - Resolves naming collisions by appending numeric suffixes (`_2`, `_3`, ...)
+        - Guarantees that all output column names are unique
+        - Guarantees a strict 1-to-1 mapping between input features and output names
+
+        The mapping is deterministic with respect to input order. If two or more
+        features clean to the same base name, the first occurrence keeps the base
+        name and subsequent occurrences receive incrementing suffixes.
+
+        Parameters
+        ----------
+        features : list
+            List of feature names. All entries must be unique under Python equality
+            semantics (e.g., `"a"` and `"a"` or `1` and `True` are considered duplicates).
+
+        Returns
+        -------
+        dict
+            Mapping from original feature name to a unique, cleaned column name
+            suitable for use in LightGBM.
+
+        Raises
+        ------
+        ValueError
+            If `features` contains duplicate entries, since a dictionary cannot
+            represent a one-to-one mapping in that case.
+
+        """
+        if len(features) != len(set(features)):
+            raise ValueError("features contains duplicates; cannot create 1-to-1 mapping with a dict.")
+
+        unique_features = set()
+        features_map = {}
+        for feature in features:
+            cleaned_feature = cls._clean_column_name_for_lgb(feature)
+
+            unique_feature = cleaned_feature
+            if unique_feature in unique_features:
+                is_unique = False
+                count = 2
+                while not is_unique:
+                    unique_feature = f"{cleaned_feature}_{count}"
+                    if unique_feature not in unique_features:
+                        is_unique = True
+                    else:
+                        count += 1
+            unique_features.add(unique_feature)
+            features_map[feature] = unique_feature
+        return features_map
+
+    def _preprocess_nonadaptive(self, X: pd.DataFrame, is_train: bool = False, **kwargs):
         X = super()._preprocess_nonadaptive(X=X, **kwargs)
 
         if is_train:
@@ -443,21 +559,25 @@ class LGBModel(AbstractModel):
                 if isinstance(column, str):
                     new_column = re.sub(r'[",:{}[\]]', "", column)
                     if new_column != column:
-                        self._features_internal_map = {feature: i for i, feature in enumerate(list(X.columns))}
                         self._requires_remap = True
                         break
             if self._requires_remap:
-                self._features_internal_list = np.array([self._features_internal_map[feature] for feature in list(X.columns)])
-            else:
-                self._features_internal_list = self._features_internal
+                self._features_internal_map = self._rename_columns(features=list(X.columns))
+                self._features_internal_lgbm = [self._features_internal_map[feature] for feature in list(X.columns)]
 
-        if self._requires_remap:
-            X_new = X.copy(deep=False)
-            X_new.columns = self._features_internal_list
-            return X_new
-        else:
+        if not self._requires_remap:
             return X
 
+        X_new = X.copy(deep=False)
+        X_new.columns = self._features_internal_lgbm
+
+        # Update feature metadata
+        if is_train:
+            new_feature_metadata = self._feature_metadata.rename_features(self._features_internal_map)
+            self._preprocess_set_features_internal(X=X_new, feature_metadata=new_feature_metadata)
+
+        return X_new
+
     def generate_datasets(
         self,
         X: DataFrame,
@@ -630,10 +750,6 @@ class LGBModel(AbstractModel):
     def supported_problem_types(cls) -> list[str] | None:
         return ["binary", "multiclass", "regression", "quantile", "softclass"]
 
-    @property
-    def _features(self):
-        return self._features_internal_list
-
     def _ag_params(self) -> set:
         return {"early_stop", "generate_curves", "curve_metrics", "use_error_for_curve_metrics"}
 

autogluon/tabular/models/lgb/lgb_utils.py

@@ -104,11 +104,15 @@ 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, init_score=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, init_score=init_score)
+    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
@@ -128,7 +132,9 @@ def train_lgb_model(early_stopping_callback_kwargs=None, **train_params):
 
     if train_params["params"]["objective"] == "quantile":
         quantile_levels = train_params["params"].pop("quantile_levels")
-        booster = QuantileBooster(quantile_levels=quantile_levels, early_stopping_callback_kwargs=early_stopping_callback_kwargs)
+        booster = QuantileBooster(
+            quantile_levels=quantile_levels, early_stopping_callback_kwargs=early_stopping_callback_kwargs
+        )
         return booster.fit(**train_params)
     else:
         return lgb.train(**train_params)
@@ -141,7 +147,9 @@ class QuantileBooster:
         if quantile_levels is None:
             raise AssertionError
         if not all(0 < q < 1 for q in quantile_levels):
-            raise AssertionError(f"quantile_levels must fulfill 0 < q < 1, provided quantile_levels: {quantile_levels}")
+            raise AssertionError(
+                f"quantile_levels must fulfill 0 < q < 1, provided quantile_levels: {quantile_levels}"
+            )
 
         self.quantile_levels = quantile_levels
 

autogluon/tabular/models/lr/hyperparameters/searchspaces.py

@@ -2,5 +2,9 @@ from autogluon.common.space import Categorical, Real
 
 
 def get_default_searchspace(problem_type, num_classes=None):
-    spaces = {"C": Real(lower=0.1, upper=1e3, default=1), "proc.skew_threshold": Categorical(0.99, None), "penalty": Categorical("L2", "L1")}
+    spaces = {
+        "C": Real(lower=0.1, upper=1e3, default=1),
+        "proc.skew_threshold": Categorical(0.99, None),
+        "penalty": Categorical("L2", "L1"),
+    }
     return spaces

autogluon/tabular/models/lr/lr_model.py

@@ -40,6 +40,7 @@ class LinearModel(AbstractModel):
 
         'regression': https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.Ridge.html#sklearn.linear_model.Ridge
     """
+
     ag_key = "LR"
     ag_name = "LinearModel"
     ag_priority = 30
@@ -87,7 +88,9 @@ class LinearModel(AbstractModel):
         """Returns dict with keys: : 'continuous', 'skewed', 'onehot', 'embed', 'language', values = ordered list of feature-names falling into each category.
         Each value is a list of feature-names corresponding to columns in original dataframe.
         """
-        continuous_featnames = self._feature_metadata.get_features(valid_raw_types=[R_INT, R_FLOAT], invalid_special_types=[S_BOOL])
+        continuous_featnames = self._feature_metadata.get_features(
+            valid_raw_types=[R_INT, R_FLOAT], invalid_special_types=[S_BOOL]
+        )
         categorical_featnames = self._feature_metadata.get_features(valid_raw_types=[R_CATEGORY, R_OBJECT])
         bool_featnames = self._feature_metadata.get_features(required_special_types=[S_BOOL])
         language_featnames = []  # TODO: Disabled currently, have to pass raw text data features here to function properly
@@ -125,7 +128,10 @@ class LinearModel(AbstractModel):
                     (
                         "vectorizer",
                         TfidfVectorizer(
-                            ngram_range=self.params["proc.ngram_range"], sublinear_tf=True, max_features=vect_max_features, tokenizer=self._tokenize
+                            ngram_range=self.params["proc.ngram_range"],
+                            sublinear_tf=True,
+                            max_features=vect_max_features,
+                            tokenizer=self._tokenize,
                         ),
                     ),
                 ]
@@ -139,7 +145,12 @@ class LinearModel(AbstractModel):
             )
             transformer_list.append(("cats", pipeline, feature_types["onehot"]))
         if feature_types.get("continuous", None):
-            pipeline = Pipeline(steps=[("imputer", SimpleImputer(strategy=self.params["proc.impute_strategy"])), ("scaler", StandardScaler())])
+            pipeline = Pipeline(
+                steps=[
+                    ("imputer", SimpleImputer(strategy=self.params["proc.impute_strategy"])),
+                    ("scaler", StandardScaler()),
+                ]
+            )
             transformer_list.append(("cont", pipeline, feature_types["continuous"]))
         if feature_types.get("bool", None):
             pipeline = Pipeline(steps=[("scaler", StandardScaler())])
@@ -148,7 +159,10 @@ class LinearModel(AbstractModel):
             pipeline = Pipeline(
                 steps=[
                     ("imputer", SimpleImputer(strategy=self.params["proc.impute_strategy"])),
-                    ("quantile", QuantileTransformer(output_distribution="normal")),  # Or output_distribution = 'uniform'
+                    (
+                        "quantile",
+                        QuantileTransformer(output_distribution="normal"),
+                    ),  # Or output_distribution = 'uniform'
                 ]
             )
             transformer_list.append(("skew", pipeline, feature_types["skewed"]))
@@ -227,7 +241,9 @@ class LinearModel(AbstractModel):
                 if time_to_train_cur_max_iter > time_left_train:
                     cur_max_iter = min(int(time_left_train / time_per_iter) - 1, cur_max_iter)
                     if cur_max_iter <= 0:
-                        logger.warning(f"\tEarly stopping due to lack of time remaining. Fit {total_iter}/{total_max_iter} iters...")
+                        logger.warning(
+                            f"\tEarly stopping due to lack of time remaining. Fit {total_iter}/{total_max_iter} iters..."
+                        )
                         break
                     early_stop = True
 
@@ -251,13 +267,17 @@ class LinearModel(AbstractModel):
                 total_iter_used += model.max_iter
             if early_stop:
                 if total_iter_used == total_iter:  # Not yet converged
-                    logger.warning(f"\tEarly stopping due to lack of time remaining. Fit {total_iter}/{total_max_iter} iters...")
+                    logger.warning(
+                        f"\tEarly stopping due to lack of time remaining. Fit {total_iter}/{total_max_iter} iters..."
+                    )
                 break
 
         self.model = model
         self.params_trained["max_iter"] = total_iter
 
-    def _select_features_handle_text_include(self, df, categorical_featnames, language_featnames, continuous_featnames, bool_featnames):
+    def _select_features_handle_text_include(
+        self, df, categorical_featnames, language_featnames, continuous_featnames, bool_featnames
+    ):
         types_of_features = dict()
         types_of_features.update(self._select_continuous(df, continuous_featnames))
         types_of_features.update(self._select_bool(df, bool_featnames))
@@ -265,12 +285,16 @@ class LinearModel(AbstractModel):
         types_of_features.update(self._select_text(df, language_featnames))
         return types_of_features
 
-    def _select_features_handle_text_only(self, df, categorical_featnames, language_featnames, continuous_featnames, bool_featnames):
+    def _select_features_handle_text_only(
+        self, df, categorical_featnames, language_featnames, continuous_featnames, bool_featnames
+    ):
         types_of_features = dict()
         types_of_features.update(self._select_text(df, language_featnames))
         return types_of_features
 
-    def _select_features_handle_text_ignore(self, df, categorical_featnames, language_featnames, continuous_featnames, bool_featnames):
+    def _select_features_handle_text_ignore(
+        self, df, categorical_featnames, language_featnames, continuous_featnames, bool_featnames
+    ):
         types_of_features = dict()
         types_of_features.update(self._select_continuous(df, continuous_featnames))
         types_of_features.update(self._select_bool(df, bool_featnames))
@@ -309,7 +333,13 @@ class LinearModel(AbstractModel):
 
     def _estimate_memory_usage(self, X: pd.DataFrame, **kwargs) -> int:
         hyperparameters = self._get_model_params()
-        return self.estimate_memory_usage_static(X=X, problem_type=self.problem_type, num_classes=self.num_classes, hyperparameters=hyperparameters, **kwargs)
+        return self.estimate_memory_usage_static(
+            X=X,
+            problem_type=self.problem_type,
+            num_classes=self.num_classes,
+            hyperparameters=hyperparameters,
+            **kwargs,
+        )
 
     @classmethod
     def _estimate_memory_usage_static(

autogluon/tabular/models/lr/lr_rapids_model.py

@@ -49,7 +49,7 @@ class LinearRapidsModel(RapidsModelMixin, LinearModel):
 
     def _preprocess(self, X, **kwargs):
         X = super()._preprocess(X=X, **kwargs)
-        if hasattr(X, 'toarray'):  # Check if it's a sparse matrix
+        if hasattr(X, "toarray"):  # Check if it's a sparse matrix
             X = X.toarray()
         return X
 
@@ -60,7 +60,7 @@ class LinearRapidsModel(RapidsModelMixin, LinearModel):
         """
         # Preprocess data
         X = self.preprocess(X, is_train=True)
-        if self.problem_type == 'binary':
+        if self.problem_type == "binary":
             y = y.astype(int).values
 
         # Create cuML model with filtered parameters
@@ -69,28 +69,37 @@ class LinearRapidsModel(RapidsModelMixin, LinearModel):
         # Comprehensive parameter filtering for cuML compatibility
         cuml_incompatible_params = {
             # AutoGluon-specific preprocessing parameters
-            'vectorizer_dict_size', 'proc.ngram_range', 'proc.skew_threshold',
-            'proc.impute_strategy', 'handle_text',
+            "vectorizer_dict_size",
+            "proc.ngram_range",
+            "proc.skew_threshold",
+            "proc.impute_strategy",
+            "handle_text",
             # sklearn-specific parameters not supported by cuML
-            'n_jobs', 'warm_start', 'multi_class', 'dual', 'intercept_scaling',
-            'class_weight', 'random_state', 'verbose',
+            "n_jobs",
+            "warm_start",
+            "multi_class",
+            "dual",
+            "intercept_scaling",
+            "class_weight",
+            "random_state",
+            "verbose",
             # Parameters that need conversion or special handling
-            'penalty', 'C'
+            "penalty",
+            "C",
         }
 
         # Filter out incompatible parameters
-        filtered_params = {k: v for k, v in self.params.items()
-                          if k not in cuml_incompatible_params}
+        filtered_params = {k: v for k, v in self.params.items() if k not in cuml_incompatible_params}
 
         # Handle parameter conversions for cuML
         if self.problem_type == REGRESSION:
             # Convert sklearn's C parameter to cuML's alpha
-            if 'C' in self.params:
-                filtered_params['alpha'] = 1.0 / self.params['C']
+            if "C" in self.params:
+                filtered_params["alpha"] = 1.0 / self.params["C"]
         else:
             # For classification, keep C parameter
-            if 'C' in self.params:
-                filtered_params['C'] = self.params['C']
+            if "C" in self.params:
+                filtered_params["C"] = self.params["C"]
 
         # Create and fit cuML model - let cuML handle its own error messages
         self.model = model_cls(**filtered_params)

autogluon/tabular/models/mitra/_internal/__init__.py

@@ -1 +1 @@
-# Internal modules for MitraModel 
+# Internal modules for MitraModel

autogluon/tabular/models/mitra/_internal/config/__init__.py

@@ -1 +1 @@
-# Configuration modules for MitraModel 
+# Configuration modules for MitraModel