SuperModelingFactory 0.3.15__tar.gz → 0.4.2__tar.gz

{supermodelingfactory-0.3.15 → supermodelingfactory-0.4.2}/Modeling_Tool/Core/ODPS_Tool.py

@@ -247,7 +247,7 @@ class ODPSRunner(object):
 
         return table_schema
 
-    def upload_df(self, df, table_name, table_schema=None, partition=None):
+    def upload_df(self, df, table_name, table_schema=None, partition=None, atomic=True):
         """上传数据集至mc中创建新表
 
         Parameters
@@ -260,20 +260,113 @@ class ODPSRunner(object):
             数据集
         partition: string
             保存分区
+        atomic: bool, default True
+            When ``True`` (recommended, default from 0.4.2), the target table is
+            replaced through a temp-table + rename swap so that a failure between
+            ``delete_table`` and the completed write never leaves the caller
+            with a dropped-and-empty table. When ``False``, the pre-0.4.2
+            behaviour is used: the existing table is dropped first and then
+            recreated, so any exception during write leaves the target table
+            missing. Only set ``atomic=False`` if you deliberately want the
+            legacy behaviour, e.g. for tables whose downstream readers expect
+            a specific object identity.
         """
         if table_schema is None:
             df.loc[:, "py_inserttime"] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
             table_schema = self.cre_table_schema(df=df, partition_name=None)
 
-        self.o.delete_table(table_name, if_exists=True)
-        t = self.o.create_table(table_name, table_schema)
+        if not atomic:
+            # Legacy pre-0.4.2 non-atomic path — retained under an explicit
+            # opt-out for callers that need the old identity semantics.
+            self.o.delete_table(table_name, if_exists=True)
+            t = self.o.create_table(table_name, table_schema)
+            if bool(partition):
+                with t.open_writer(partition=partition, create_partition=True) as writer:
+                    writer.write(df.values.tolist())
+            else:
+                with t.open_writer() as writer:
+                    writer.write(df.values.tolist())
+            logger.info(f'<<<< 完成数据入表{table_name}: shape={df.shape} >>>>')
+            return
+
+        # Atomic swap path (default from 0.4.2). If any step before the final
+        # swap fails, the original table is untouched.
+        ts = datetime.now().strftime('%Y%m%d%H%M%S%f')
+        tmp_name = f"{table_name}__tmp_{ts}"
+        old_name = f"{table_name}__old_{ts}"
+
+        # Step 1: write data into the temp table. If this fails, drop the
+        # partial temp table and re-raise; the target table is untouched.
+        self.o.delete_table(tmp_name, if_exists=True)
+        tmp_table = self.o.create_table(tmp_name, table_schema)
+        try:
+            if bool(partition):
+                with tmp_table.open_writer(partition=partition, create_partition=True) as writer:
+                    writer.write(df.values.tolist())
+            else:
+                with tmp_table.open_writer() as writer:
+                    writer.write(df.values.tolist())
+        except Exception:
+            try:
+                self.o.delete_table(tmp_name, if_exists=True)
+            except Exception as cleanup_exc:  # noqa: BLE001
+                logger.warning(
+                    f"upload_df: failed to drop temp table {tmp_name} after write error: {cleanup_exc!r}"
+                )
+            raise
+
+        # Step 2: swap. If the original table exists, rename it aside first so
+        # that the rename of tmp -> target is guaranteed to succeed. Then drop
+        # the old copy (best-effort, warn on failure).
+        target_exists = self.o.exist_table(table_name)
+        if target_exists:
+            try:
+                self.o.run_sql(f"ALTER TABLE {table_name} RENAME TO {old_name};")
+            except Exception:
+                # Rename of the live target failed — do not touch it. Drop the
+                # tmp table so we don't leak it, then re-raise.
+                try:
+                    self.o.delete_table(tmp_name, if_exists=True)
+                except Exception as cleanup_exc:  # noqa: BLE001
+                    logger.warning(
+                        f"upload_df: failed to drop temp table {tmp_name} after rename-target failure: {cleanup_exc!r}"
+                    )
+                raise
+
+        try:
+            self.o.run_sql(f"ALTER TABLE {tmp_name} RENAME TO {table_name};")
+        except Exception:
+            # tmp -> target rename failed. If we already moved the original,
+            # try to restore it so the caller is not left with a missing table.
+            if target_exists:
+                try:
+                    self.o.run_sql(f"ALTER TABLE {old_name} RENAME TO {table_name};")
+                    logger.warning(
+                        f"upload_df: swap of {tmp_name} -> {table_name} failed; restored original from {old_name}"
+                    )
+                except Exception as restore_exc:  # noqa: BLE001
+                    logger.error(
+                        f"upload_df: swap of {tmp_name} -> {table_name} failed AND restore of "
+                        f"{old_name} -> {table_name} failed: {restore_exc!r}. "
+                        f"Manual recovery required — original data is in {old_name}."
+                    )
+            try:
+                self.o.delete_table(tmp_name, if_exists=True)
+            except Exception:  # noqa: BLE001
+                pass
+            raise
+
+        # Step 3: drop the moved-aside original — best-effort, do not fail the
+        # call if this cleanup errors, since the swap already succeeded.
+        if target_exists:
+            try:
+                self.o.delete_table(old_name, if_exists=True)
+            except Exception as cleanup_exc:  # noqa: BLE001
+                logger.warning(
+                    f"upload_df: swap succeeded but failed to drop old copy {old_name}: {cleanup_exc!r}. "
+                    f"Safe to delete manually."
+                )
 
-        if bool(partition):
-            with t.open_writer(partition=partition, create_partition=True) as writer:
-                writer.write(df.values.tolist())
-        else:
-            with t.open_writer() as writer:
-                writer.write(df.values.tolist())
         logger.info(f'<<<< 完成数据入表{table_name}: shape={df.shape} >>>>')
 
     def insert_df(self, df, table_name, overwrite=True, partition=None):

{supermodelingfactory-0.3.15 → supermodelingfactory-0.4.2}/Modeling_Tool/Feature/PSI_Tool.py

@@ -7,12 +7,20 @@ to measure the distribution drift between expected and actual datasets.
 Author: Matrix Agent
 """
 
+import warnings
+
 import numpy as np
 import pandas as pd
 from typing import Union, List, Dict, Optional, Tuple, Callable, Any
 from tqdm import tqdm
 from Modeling_Tool.Core.Binning_Tool import quick_binning
 
+# Missing bucket label used across PSI helpers when ``missing_policy="include"``
+# (the 0.4.2 default). Kept identical to the sentinel already used by
+# ``Feature.Weighted_Screen`` and ``WOE_Adapter`` so downstream aggregators can
+# recognise it without special-casing.
+_MISSING_BIN = "__MISSING__"
+
 # ============================================================================
 # Classes
 # ============================================================================
@@ -460,14 +468,29 @@ def _calculate_single_psi(
     return_details: bool = False,
     min_bin_prop: float = 0.05,
     content: float = 1e-6,
-    precision: int = 5
+    precision: int = 5,
+    missing_policy: str = "drop",
 ) -> Union[float, Tuple[float, pd.DataFrame]]:
     """
     Calculate Population Stability Index (PSI) for a single variable.
-    
+
     This function bins both expected and actual series using the same breakpoints,
     then calculates PSI based on the distribution difference between them.
-    
+
+    Missing handling (0.4.2, N29)
+    ------------------------------
+    Before 0.4.2, both series were unconditionally passed through ``.dropna()``
+    before binning. Any drift in the *missing rate itself* — the single most
+    common early signal of a data-pipeline break — was silently invisible in
+    the returned PSI. 0.4.2 adds the ``missing_policy`` parameter so callers
+    can opt in to the corrected behaviour. The default remains ``"drop"`` for
+    strict backward compatibility with the pre-0.4.2 numeric output; the next
+    minor release will flip the default to ``"include"``. Pass
+    ``missing_policy="include"`` to route NaN rows through a dedicated
+    ``"__MISSING__"`` bin on both sides so missing-rate drift contributes to
+    the PSI. Pass ``missing_policy="warn_and_drop"`` to keep the old numbers
+    but at least surface a ``RuntimeWarning`` naming the two NaN counts.
+
     Parameters
     ----------
     expected_series : pandas.Series
@@ -486,62 +509,112 @@ def _calculate_single_psi(
         Small value to avoid division by zero. Default is 1e-6.
     precision : int, optional
         Decimal precision. Default is 5.
-        
+    missing_policy : {"drop", "include", "warn_and_drop"}, optional
+        How NaN rows are handled. ``"drop"`` (default in 0.4.2) reproduces the
+        pre-0.4.2 behaviour and silently excludes NaN rows from both sides
+        before binning. ``"include"`` treats NaN as its own ``"__MISSING__"``
+        bin so missing-rate drift shows up in the PSI — recommended for any
+        production drift monitor, and will become the default in the next
+        minor release. ``"warn_and_drop"`` behaves like ``"drop"`` but emits
+        a ``RuntimeWarning`` naming the two NaN counts so the caller sees what
+        was dropped.
+
     Returns
     -------
     float or tuple
         If return_details is False: Returns total PSI value.
         If return_details is True: Returns tuple of (PSI value, details DataFrame).
-        
+
     Notes
     -----
     PSI Formula: Σ (Actual% - Expected%) * ln(Actual% / Expected%)
     A PSI < 0.1 indicates stable population, 0.1-0.25 suggests some change,
     and > 0.25 indicates significant drift.
     """
-    # Drop NA
+    if missing_policy not in {"include", "drop", "warn_and_drop"}:
+        raise ValueError(
+            f"_calculate_single_psi: missing_policy must be one of "
+            f"'include', 'drop', 'warn_and_drop'; got {missing_policy!r}."
+        )
+
+    # Record NaN counts before splitting so we can (a) re-attach the missing
+    # bin under "include" and (b) warn under "warn_and_drop".
+    n_expected = int(len(expected_series))
+    n_actual = int(len(actual_series))
+    n_expected_na = int(expected_series.isna().sum())
+    n_actual_na = int(actual_series.isna().sum())
+
+    if missing_policy == "warn_and_drop" and (n_expected_na or n_actual_na):
+        warnings.warn(
+            f"_calculate_single_psi: dropping NaN rows before binning. "
+            f"expected: {n_expected_na}/{n_expected} NaN, "
+            f"actual: {n_actual_na}/{n_actual} NaN. "
+            f"Pass missing_policy='include' to treat NaN as its own bin so "
+            f"missing-rate drift is captured.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+
     expected_clean = expected_series.dropna()
     actual_clean = actual_series.dropna()
-    
+
     # Bin the expected data to get breakpoints
     expected_bins, breakpoints = quick_binning(
-        pd.DataFrame(expected_clean), 
-        expected_clean.name, 
-        labels=None, 
-        nbins=buckets, 
-        precision=precision, 
-        equal_freq=equal_freq, 
-        right=True, 
+        pd.DataFrame(expected_clean),
+        expected_clean.name,
+        labels=None,
+        nbins=buckets,
+        precision=precision,
+        equal_freq=equal_freq,
+        right=True,
         include_lowest=False,
-        min_bin_prop=min_bin_prop, 
-        tree_binning=False, 
-        target=None, 
+        min_bin_prop=min_bin_prop,
+        tree_binning=False,
+        target=None,
         random_state=42
     )
-    
+
     # Bin the actual data using the same breakpoints
     actual_bins, _ = quick_binning(
-        pd.DataFrame(actual_clean), 
-        actual_clean.name, 
-        labels=None, 
-        nbins=list(breakpoints), 
-        precision=precision, 
-        equal_freq=equal_freq, 
-        right=True, 
+        pd.DataFrame(actual_clean),
+        actual_clean.name,
+        labels=None,
+        nbins=list(breakpoints),
+        precision=precision,
+        equal_freq=equal_freq,
+        right=True,
         include_lowest=False,
-        min_bin_prop=min_bin_prop, 
-        tree_binning=False, 
-        target=None, 
+        min_bin_prop=min_bin_prop,
+        tree_binning=False,
+        target=None,
         random_state=42
     )
-    
-    # Get bin counts
+
+    # Get bin counts (finite-value rows only, from quick_binning)
     expected_count = expected_bins.value_counts(normalize=False, sort=False)
     actual_count = actual_bins.value_counts(normalize=False, sort=False)
-    
-    # Get bin proportions
-    expected_percents = expected_bins.value_counts(normalize=True, sort=False)
-    actual_percents = actual_bins.value_counts(normalize=True, sort=False)
+
+    if missing_policy == "include":
+        # Re-attach the __MISSING__ bin so that missing-rate drift contributes
+        # to the PSI on both sides. The denominators use the *original* row
+        # counts (before dropna) so the fractions are directly comparable.
+        if n_expected_na > 0:
+            expected_count = pd.concat(
+                [expected_count, pd.Series({_MISSING_BIN: n_expected_na})]
+            )
+        if n_actual_na > 0:
+            actual_count = pd.concat(
+                [actual_count, pd.Series({_MISSING_BIN: n_actual_na})]
+            )
+        expected_denom = float(n_expected) if n_expected > 0 else 1.0
+        actual_denom = float(n_actual) if n_actual > 0 else 1.0
+        expected_percents = expected_count / expected_denom
+        actual_percents = actual_count / actual_denom
+    else:
+        # "drop" / "warn_and_drop": legacy behaviour, denominators are the
+        # NaN-dropped row counts, so missing-rate drift is invisible.
+        expected_percents = expected_bins.value_counts(normalize=True, sort=False)
+        actual_percents = actual_bins.value_counts(normalize=True, sort=False)
     
     # Ensure both series have the same bin indices
     all_bins = expected_percents.index.union(actual_percents.index)

{supermodelingfactory-0.3.15 → supermodelingfactory-0.4.2}/Modeling_Tool/Feature/Weighted_Screen.py

@@ -113,11 +113,25 @@ def _weighted_bin_distribution(
     w: np.ndarray,
     content: float,
 ) -> pd.Series:
+    """Return the weighted bin distribution as an observed-only frequency
+    Series.
+
+    Fix (0.4.2, N23): the pre-0.4.2 version unioned ``_MISSING_BIN`` into the
+    returned index and clipped every entry to ``content`` (a small positive
+    floor such as ``1e-5``). When only one side of a PSI comparison had missing
+    values, that forced a large synthetic mass on the missing bin of the side
+    that actually observed zero missings — which then propagated through
+    ``_psi_from_distributions`` as a large spurious PSI component. The fix is
+    to return only the bins actually observed in ``bins``; the alignment and
+    zero-safety are done exactly once, in ``_psi_from_distributions``, so both
+    sides are treated symmetrically. The ``content`` parameter is retained for
+    signature stability but is now unused in this helper.
+    """
+    del content  # retained for signature stability; alignment is elsewhere.
     df = pd.DataFrame({"bin": bins, "w": w})
     dist = df.groupby("bin", dropna=False)["w"].sum()
     total = float(dist.sum()) or 1.0
-    dist = dist / total
-    return dist.reindex(dist.index.union([_MISSING_BIN]), fill_value=0.0).clip(lower=content)
+    return dist / total
 
 
 def _psi_from_distributions(expected: pd.Series, actual: pd.Series, content: float) -> float:

{supermodelingfactory-0.3.15 → supermodelingfactory-0.4.2}/Modeling_Tool/Pipeline/_common.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import os
 import re
+import warnings
 from dataclasses import fields, is_dataclass
 from pathlib import Path
 from typing import Any, Iterable, Mapping
@@ -307,9 +308,45 @@ def predict_positive(model: Any, data: pd.DataFrame, feature_cols: list[str]) ->
         raise TypeError(f"Model {type(model)!r} does not expose predict/predict_proba")
 
     pred_arr = np.asarray(pred)
-    if pred_arr.ndim == 2 and pred_arr.shape[1] > 1:
-        return pred_arr[:, 1]
-    return pred_arr.reshape(-1)
+    n_rows = len(data)
+
+    if pred_arr.ndim == 2:
+        if pred_arr.shape[1] == 2:
+            # sklearn convention: column 1 is positive class
+            result = pred_arr[:, 1]
+        elif pred_arr.shape[1] == 1:
+            result = pred_arr[:, 0]
+        else:
+            raise ValueError(
+                f"predict_proba returned unexpected shape {pred_arr.shape}; "
+                f"expected 1-D or 2-D with 1-2 columns."
+            )
+    elif pred_arr.ndim == 1:
+        result = pred_arr
+    else:
+        raise ValueError(
+            f"predict_proba returned unexpected ndim={pred_arr.ndim} "
+            f"(shape={pred_arr.shape}); expected 1-D or 2-D."
+        )
+
+    result = result.reshape(-1)
+    if len(result) != n_rows:
+        raise ValueError(
+            f"predict_positive length mismatch: got {len(result)} predictions "
+            f"for {n_rows} input rows. Model {type(model).__name__} may have "
+            f"dropped rows silently."
+        )
+
+    finite_mask = np.isfinite(result)
+    if not finite_mask.all():
+        n_bad = int((~finite_mask).sum())
+        warnings.warn(
+            f"predict_positive: {n_bad}/{n_rows} predictions are NaN/Inf "
+            f"from model {type(model).__name__}. Downstream scoring may be affected.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+    return result
 
 
 def add_dataset_with_optional_weight(
@@ -364,3 +401,72 @@ def write_basic_excel(
 
     em.close_workbook()
     return report_path
+
+
+def copy_column_length_checked(
+    dst: pd.DataFrame,
+    src: pd.DataFrame,
+    col: str,
+    *,
+    dst_name: str,
+    src_name: str,
+) -> None:
+    """Positionally copy ``src[col]`` into ``dst[col]`` with a length guard.
+
+    ``warm_start_score_col`` in credit_model relies on WOE-transformed splits
+    lining up row-for-row with the raw splits they were transformed from. That
+    assumption held in practice, but the historical implementation used a bare
+    ``dst[col] = src[col].to_numpy()`` which would corrupt the join whenever the
+    two frames drifted in length (fit-query filtering, prior ``.dropna``, etc.)
+    with no error. This helper enforces the invariant explicitly.
+
+    Values are copied by position (``.to_numpy()``) — not by index alignment —
+    which matches the way ``adapter.transform`` returns rows in the same order
+    they entered. Lengths must match exactly; otherwise raise ``ValueError``
+    with the frame names so the caller can debug.
+    """
+    if len(dst) != len(src):
+        raise ValueError(
+            f"Cannot copy column {col!r} from {src_name!r} (len={len(src)}) to "
+            f"{dst_name!r} (len={len(dst)}): row counts must match. This usually "
+            f"means WOE transformation dropped or reordered rows relative to the "
+            f"source frame — check woe_fit_query / dropna behavior."
+        )
+    dst[col] = src[col].to_numpy()
+
+
+def split_oot_by_flag(
+    data: pd.DataFrame,
+    oot_col: str | None,
+) -> tuple[pd.DataFrame, pd.DataFrame]:
+    """Split a frame into (ins_oos, oot) based on an OOT flag column.
+
+    Rows where ``oot_col`` equals 0 (after numeric coercion) are treated as
+    in-sample/out-of-sample, everything else is out-of-time.
+
+    The column is coerced with ``pd.to_numeric(errors="raise")`` so string /
+    boolean / mixed-dtype flags raise a clear error instead of silently routing
+    every row to ``oot`` (previous behavior: string ``"0"`` != integer ``0``,
+    so every row ended up in ``oot`` and ``ins_oos`` came out empty).
+
+    If ``oot_col`` is falsy or absent from ``data``, the full frame is returned
+    as ``ins_oos`` and an empty frame with matching columns as ``oot`` — same
+    as the historical fallback.
+    """
+    if not oot_col or oot_col not in data.columns:
+        empty = pd.DataFrame(columns=data.columns)
+        return data, empty
+
+    raw = data[oot_col]
+    try:
+        numeric = pd.to_numeric(raw, errors="raise")
+    except (ValueError, TypeError) as exc:
+        raise TypeError(
+            f"oot_col {oot_col!r} must be numeric (0 = ins_oos, non-zero = oot); "
+            f"got dtype={raw.dtype} with non-numeric values. Original error: {exc}"
+        ) from exc
+
+    mask_oot = numeric.fillna(0).astype(float) != 0.0
+    ins_oos = data.loc[~mask_oot].copy()
+    oot = data.loc[mask_oot].copy()
+    return ins_oos, oot

{supermodelingfactory-0.3.15 → supermodelingfactory-0.4.2}/Modeling_Tool/Pipeline/credit_model.py

@@ -11,11 +11,13 @@ from ._common import (
     add_dataset_with_optional_weight,
     apply_woe_fit_query,
     as_list,
+    copy_column_length_checked,
     make_dirs,
     merge_dict,
     persist_explain_outputs,
     predict_positive,
     safe_to_csv,
+    split_oot_by_flag,
     validate_woe_fit_query_columns,
     validate_woe_fit_query_syntax,
     write_basic_excel,
@@ -417,8 +419,7 @@ class CreditModelPipeline:
                 raise ValueError(f"split_col {cfg.split_col!r} must contain non-empty ins and oos samples")
 
         if cfg.oot_col and cfg.oot_col in work.columns:
-            ins_oos = work[work[cfg.oot_col] == 0].copy()
-            oot = work[work[cfg.oot_col] != 0].copy()
+            ins_oos, oot = split_oot_by_flag(work, cfg.oot_col)
         else:
             ins_oos = work
             oot = pd.DataFrame(columns=work.columns)
@@ -600,10 +601,22 @@ class CreditModelPipeline:
         if cfg.warm_start_enabled and cfg.warm_start_score_col:
             for name, df in woe_splits.items():
                 if cfg.warm_start_score_col not in df.columns and cfg.warm_start_score_col in splits[name].columns:
-                    df[cfg.warm_start_score_col] = splits[name][cfg.warm_start_score_col].to_numpy()
+                    copy_column_length_checked(
+                        df,
+                        splits[name],
+                        cfg.warm_start_score_col,
+                        dst_name=f"woe_splits[{name!r}]",
+                        src_name=f"splits[{name!r}]",
+                    )
             for name, df in extra_eval.items():
                 if cfg.warm_start_score_col not in df.columns and cfg.warm_start_score_col in cfg.extra_eval_datasets[name].columns:
-                    df[cfg.warm_start_score_col] = cfg.extra_eval_datasets[name][cfg.warm_start_score_col].to_numpy()
+                    copy_column_length_checked(
+                        df,
+                        cfg.extra_eval_datasets[name],
+                        cfg.warm_start_score_col,
+                        dst_name=f"extra_eval[{name!r}]",
+                        src_name=f"extra_eval_datasets[{name!r}]",
+                    )
 
         return {
             "engine": adapter,
@@ -697,11 +710,23 @@ class CreditModelPipeline:
         if cfg.warm_start_enabled and cfg.warm_start_score_col:
             for name, df in woe_splits.items():
                 if cfg.warm_start_score_col not in df.columns:
-                    df[cfg.warm_start_score_col] = splits[name][cfg.warm_start_score_col].to_numpy()
+                    copy_column_length_checked(
+                        df,
+                        splits[name],
+                        cfg.warm_start_score_col,
+                        dst_name=f"woe_splits[{name!r}]",
+                        src_name=f"splits[{name!r}]",
+                    )
             for name, df in extra_eval.items():
                 if cfg.warm_start_score_col not in df.columns:
                     source = cfg.extra_eval_datasets[name]
-                    df[cfg.warm_start_score_col] = source[cfg.warm_start_score_col].to_numpy()
+                    copy_column_length_checked(
+                        df,
+                        source,
+                        cfg.warm_start_score_col,
+                        dst_name=f"extra_eval[{name!r}]",
+                        src_name=f"extra_eval_datasets[{name!r}]",
+                    )
 
         return {
             "engine": engine,
@@ -808,7 +833,9 @@ class CreditModelPipeline:
             if name == "lr" and cfg.use_lr_search_params and hasattr(self, "_lr_best_params"):
                 params = merge_dict(params, getattr(self, "_lr_best_params", {}))
             if name == "lr":
-                lr = LRMaster(params=params or None, standardize=bool(params.pop("standardize", False)) if params else False)
+                lr_params = dict(params) if params else {}
+                standardize = bool(lr_params.pop("standardize", False))
+                lr = LRMaster(params=lr_params or None, standardize=standardize)
                 lr.fit(
                     data=train,
                     varlist=feature_cols,
@@ -999,7 +1026,8 @@ class CreditModelPipeline:
         results = {}
         if not as_list(cfg.optuna_models):
             return results
-        search_spaces = cfg.optuna_params.get("search_spaces") or self._default_search_spaces()
+        user_search_spaces = cfg.optuna_params.get("search_spaces")
+        search_spaces = self._default_search_spaces() if user_search_spaces is None else user_search_spaces
         for raw_name in as_list(cfg.optuna_models):
             name = str(raw_name).lower()
             if name not in {"lgb", "xgb", "cat"} or name not in search_spaces: