SuperModelingFactory 0.5.1__tar.gz → 0.5.3__tar.gz

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Core/Binning_Tool.py

@@ -367,8 +367,7 @@ class NumVarBinning:
         if modify:
             self.cut_points = self.modify_cutpoints(df, points)
         else:
-            points.sort()
-            self.cut_points = points
+            self.cut_points = sorted(points)
         self.bins = len(self.cut_points) - 1
 
         binning_series = pd.cut(df[self.var_name], self.cut_points, right=False)

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Core/ODPS_Tool.py

@@ -17,6 +17,63 @@ pd.options.mode.chained_assignment = None  # default='warn'
 
 logging.basicConfig(level=logging.INFO, format="%(message)s")
 
+
+def _split_odps_table_name(table_name):
+    """Return (qualifier, bare table name) for ODPS table identifiers.
+
+    MaxCompute accepts a project-qualified source in ``ALTER TABLE`` but the
+    ``RENAME TO`` target must be the bare table name within the same project.
+    """
+    table_name = str(table_name)
+    if "." not in table_name:
+        return "", table_name
+    qualifier, bare_name = table_name.rsplit(".", 1)
+    return qualifier, bare_name
+
+
+def _make_related_odps_table_name(table_name, suffix):
+    qualifier, bare_name = _split_odps_table_name(table_name)
+    related_bare = f"{bare_name}{suffix}"
+    if qualifier:
+        return f"{qualifier}.{related_bare}", related_bare
+    return related_bare, related_bare
+
+
+def _parse_odps_partition_spec(partition):
+    if isinstance(partition, dict):
+        return [(str(k).strip(), str(v).strip().strip("'\"")) for k, v in partition.items()]
+    pairs = []
+    for item in str(partition).split(","):
+        if not item.strip():
+            continue
+        if "=" not in item:
+            raise ValueError(f"Invalid ODPS partition spec item {item!r}; expected key=value.")
+        key, value = item.split("=", 1)
+        pairs.append((key.strip(), value.strip().strip("'\"")))
+    if not pairs:
+        raise ValueError("partition must contain at least one key=value pair.")
+    return pairs
+
+
+def _format_odps_partition_spec(pairs, quoted=False):
+    parts = []
+    for key, value in pairs:
+        safe_value = str(value).replace("'", "''")
+        if quoted:
+            parts.append(f"{key}='{safe_value}'")
+        else:
+            parts.append(f"{key}={safe_value}")
+    return ",".join(parts)
+
+
+def _make_related_odps_partition_spec(partition, suffix):
+    pairs = _parse_odps_partition_spec(partition)
+    related = list(pairs)
+    key, value = related[-1]
+    related[-1] = (key, f"{value}{suffix}")
+    return _format_odps_partition_spec(related, quoted=False)
+
+
 class ODPSRunner(object):
     _wide_schema_patch_lock = threading.RLock()
     _wide_schema_patch_ref_count = 0
@@ -292,8 +349,9 @@ class ODPSRunner(object):
         # 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}"
+        _, target_rename_name = _split_odps_table_name(table_name)
+        tmp_name, _ = _make_related_odps_table_name(table_name, f"__tmp_{ts}")
+        old_name, old_rename_name = _make_related_odps_table_name(table_name, f"__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.
@@ -321,7 +379,7 @@ class ODPSRunner(object):
         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};")
+                self.o.run_sql(f"ALTER TABLE {table_name} RENAME TO {old_rename_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.
@@ -334,13 +392,13 @@ class ODPSRunner(object):
                 raise
 
         try:
-            self.o.run_sql(f"ALTER TABLE {tmp_name} RENAME TO {table_name};")
+            self.o.run_sql(f"ALTER TABLE {tmp_name} RENAME TO {target_rename_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};")
+                    self.o.run_sql(f"ALTER TABLE {old_name} RENAME TO {target_rename_name};")
                     logger.warning(
                         f"upload_df: swap of {tmp_name} -> {table_name} failed; restored original from {old_name}"
                     )
@@ -369,7 +427,21 @@ class ODPSRunner(object):
 
         logger.info(f'<<<< 完成数据入表{table_name}: shape={df.shape} >>>>')
 
-    def insert_df(self, df, table_name, overwrite=True, partition=None):
+    def _partition_exists(self, table, partition):
+        if hasattr(table, "exist_partition"):
+            return bool(table.exist_partition(partition))
+        try:
+            table.get_partition(partition)
+            return True
+        except Exception:
+            return False
+
+    def _rename_partition(self, table_name, source_partition, target_partition):
+        src = _format_odps_partition_spec(_parse_odps_partition_spec(source_partition), quoted=True)
+        dst = _format_odps_partition_spec(_parse_odps_partition_spec(target_partition), quoted=True)
+        self.o.run_sql(f"ALTER TABLE {table_name} PARTITION ({src}) RENAME TO PARTITION ({dst});")
+
+    def insert_df(self, df, table_name, overwrite=True, partition=None, atomic=True):
         """将数据集插入至mc已存在的表中.
 
         Parameters
@@ -388,6 +460,53 @@ class ODPSRunner(object):
             df.loc[:, "py_inserttime"] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
 
         if bool(partition):
+            if overwrite and atomic:
+                ts = datetime.now().strftime('%Y%m%d%H%M%S%f')
+                staging_partition = _make_related_odps_partition_spec(partition, f"__staging_{ts}")
+                backup_partition = _make_related_odps_partition_spec(partition, f"__old_{ts}")
+                target_exists = self._partition_exists(t, partition)
+
+                for stale in (staging_partition, backup_partition):
+                    try:
+                        t.delete_partition(stale, if_exists=True)
+                    except Exception as cleanup_exc:  # noqa: BLE001
+                        logger.warning(
+                            f"insert_df: failed to cleanup partition {stale} before atomic write: {cleanup_exc!r}"
+                        )
+
+                try:
+                    with t.open_writer(partition=staging_partition, create_partition=True) as writer:
+                        writer.write(df.values.tolist())
+                    if target_exists:
+                        self._rename_partition(table_name, partition, backup_partition)
+                    self._rename_partition(table_name, staging_partition, partition)
+                except Exception:
+                    if target_exists:
+                        try:
+                            if not self._partition_exists(t, partition) and self._partition_exists(t, backup_partition):
+                                self._rename_partition(table_name, backup_partition, partition)
+                        except Exception as restore_exc:  # noqa: BLE001
+                            logger.error(
+                                f"insert_df: failed to restore original partition {partition} "
+                                f"from {backup_partition}: {restore_exc!r}. Manual recovery may be required."
+                            )
+                    try:
+                        t.delete_partition(staging_partition, if_exists=True)
+                    except Exception:  # noqa: BLE001
+                        pass
+                    raise
+
+                if target_exists:
+                    try:
+                        t.delete_partition(backup_partition, if_exists=True)
+                    except Exception as cleanup_exc:  # noqa: BLE001
+                        logger.warning(
+                            f"insert_df: atomic swap succeeded but failed to drop backup partition "
+                            f"{backup_partition}: {cleanup_exc!r}. Safe to delete manually."
+                        )
+                logger.info('<<<< insert_df atomic partition write done: shape={0} >>>>'.format(df.shape))
+                return
+
             if overwrite:
                 t.delete_partition(partition, if_exists=True)
             with t.open_writer(partition=partition, create_partition=True) as writer:

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Core/sample_weight_utils.py

@@ -52,6 +52,12 @@ def validate_sample_weight(weights, expected_len=None):
         raise ValueError("sample_weight must be finite (no NaN/inf).")
     if np.any(w < 0):
         raise ValueError("sample_weight must be non-negative.")
+    total = float(np.sum(w))
+    if total <= 0:
+        raise ValueError(
+            "sample_weight sum must be > 0; got sum={0}. "
+            "All-zero weights make weighted metrics undefined.".format(total)
+        )
     return w
 
 

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Eval/Model_Eval_Tool.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import warnings
 import numpy as np
 import pandas as pd
 from Modeling_Tool.Core.Binning_Tool import get_bin_range_list, super_binning
@@ -2246,8 +2247,9 @@ class PerformanceEvaluator:
         self.weight_col = weight_col
         self.datasets = {}
         self.dataset_weight_cols = {}
+        self.evaluate_status = None
     
-    def add_dataset(self, name, data, weight_col = None):
+    def add_dataset(self, name, data, weight_col = None, overwrite = False):
         """
         添加数据集。
         
@@ -2263,6 +2265,17 @@ class PerformanceEvaluator:
         self
             返回自身以便链式调用
         """
+        if name in self.datasets and not overwrite:
+            raise KeyError(
+                f"Dataset name {name!r} already exists. Use overwrite=True to replace it, "
+                "or pass a different dataset name."
+            )
+        if name in self.datasets and overwrite:
+            warnings.warn(
+                f"PerformanceEvaluator.add_dataset overwriting existing dataset {name!r}.",
+                RuntimeWarning,
+                stacklevel=2,
+            )
         self.datasets[name] = data
         self.dataset_weight_cols[name] = weight_col
         return self
@@ -2304,16 +2317,38 @@ class PerformanceEvaluator:
             ``fig_save_path`` 自动按标签加后缀 (如 ``perf.png`` → ``perf_<label>.png``)。
         """
         if len(self.datasets) == 0:
+            self.evaluate_status = "no_datasets"
             return pd.DataFrame([])
 
         if self.scr_name is None and self.model is None and self.feature_cols is None:
-            return -1
+            self.evaluate_status = "compute_failed"
+            warnings.warn(
+                "PerformanceEvaluator.evaluate() now returns an empty DataFrame instead of -1; "
+                "inspect .evaluate_status for the failure reason.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return pd.DataFrame([])
         
         if self.scr_name is None and self.model is None:
-            return -2
+            self.evaluate_status = "compute_failed"
+            warnings.warn(
+                "PerformanceEvaluator.evaluate() now returns an empty DataFrame instead of -2; "
+                "inspect .evaluate_status for the failure reason.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return pd.DataFrame([])
         
         if self.scr_name is None and self.feature_cols is None:
-            return -3
+            self.evaluate_status = "compute_failed"
+            warnings.warn(
+                "PerformanceEvaluator.evaluate() now returns an empty DataFrame instead of -3; "
+                "inspect .evaluate_status for the failure reason.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            return pd.DataFrame([])
 
         active_weight_col = weight_col or self.weight_col
         has_dataset_weight = any(v is not None for v in self.dataset_weight_cols.values())
@@ -2369,6 +2404,7 @@ class PerformanceEvaluator:
                     )
             if rpt_save_path:
                 fnl_df.to_csv(rpt_save_path, index=False)
+            self.evaluate_status = "ok" if not fnl_df.empty else "empty_input"
             return fnl_df
 
         # ── 多 y 标签支持: tgt_name 为 list/tuple 时, 逐标签评估后纵向拼接 ──
@@ -2412,6 +2448,7 @@ class PerformanceEvaluator:
                 _ipy_display(fnl_df)
             if rpt_save_path:
                 fnl_df.to_csv(rpt_save_path, index = False)
+            self.evaluate_status = "ok" if not fnl_df.empty else "empty_input"
             return fnl_df
 
         def _get_score(data):
@@ -2472,6 +2509,7 @@ class PerformanceEvaluator:
                 }
 
             if len(eval_datasets) == 0:
+                self.evaluate_status = "empty_input"
                 return pd.DataFrame([])
 
             model_eval_result_df = evaluate_performance(
@@ -2570,4 +2608,5 @@ class PerformanceEvaluator:
         if rpt_save_path:
             fnl_df.to_csv(rpt_save_path, index = False)
 
+        self.evaluate_status = "ok" if isinstance(fnl_df, pd.DataFrame) and not fnl_df.empty else "empty_input"
         return fnl_df

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Eval/Model_Eval_Tool.pyi

@@ -32,6 +32,6 @@ class GainsTableCalculator:
     def calculate(self, grp_name = None, min_data_size = 100, grp_colname = None, sync_range = True, retSummary = False, withSummary = False, wholeGroup = False, add_func = None): ...
 
 class PerformanceEvaluator:
-    def __init__(self, tgt_name, scr_name = None, model = None, feature_cols = None, dist_bins = 20, pct_bins = 10, precision = 5, min_bin_prop = 0.05, include_missing = False, equal_freq = True, chi2_method = False, init_equi_bins = 1000, chi2_p = 0.9, tree_binning = False, random_state = 42): ...
-    def add_dataset(self, name, data): ...
-    def evaluate(self, oot_grp_name = None, min_data_size = 100, grp_colname = None, fig_save_path = None, rpt_save_path = None, to_show = False, display = True, gains_table = False, benchmark_dataset = None): ...
+    def __init__(self, tgt_name, scr_name = None, model = None, feature_cols = None, dist_bins = 20, pct_bins = 10, precision = 5, min_bin_prop = 0.05, include_missing = False, equal_freq = True, chi2_method = False, init_equi_bins = 1000, chi2_p = 0.9, tree_binning = False, random_state = 42, weight_col = None): ...
+    def add_dataset(self, name, data, weight_col = None, overwrite = False): ...
+    def evaluate(self, oot_grp_name = None, min_data_size = 100, grp_colname = None, fig_save_path = None, rpt_save_path = None, to_show = False, display = True, gains_table = False, benchmark_dataset = None, weight_col = None): ...

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Eval/weighted_eval_utils.py

@@ -14,6 +14,7 @@ import pandas as pd
 from sklearn.metrics import precision_recall_curve, roc_auc_score, roc_curve
 
 from Modeling_Tool.Core.sample_weight_utils import resolve_sample_weight
+from Modeling_Tool._utils.robust import smf_logger
 
 
 def resolve_weights(data=None, weight_col=None, sample_weight=None, expected_len=None, wgt=None, wgt_col=None):
@@ -43,7 +44,8 @@ def safe_weighted_average(values, weights=None):
 def safe_auc(y_true, y_score, sample_weight=None):
     try:
         return float(roc_auc_score(y_true, y_score, sample_weight=sample_weight))
-    except Exception:
+    except (ValueError, ZeroDivisionError) as exc:
+        smf_logger.record_and_continue("auc", exc, stage="weighted_eval.safe_auc")
         return np.nan
 
 

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Model/LRM_Tool.py

@@ -6,6 +6,7 @@ import pandas as pd
 from sklearn.linear_model import LogisticRegression
 import logging
 from Modeling_Tool.Core.sample_weight_utils import resolve_sample_weight
+from Modeling_Tool._utils.nan_guard import warn_if_nan_ratio_exceeds
 
 logger = logging.getLogger(__name__)
 
@@ -252,6 +253,33 @@ def compute_bic(model, x, y, sample_weight=None):
     return bic
 
 
+def _prepare_nan_handled_frame(data, nan_handling="fillna_median", warn_threshold=0.05, context=""):
+    """Return a numeric frame with explicit NaN handling for selection stats."""
+    allowed = {"fillna_0", "fillna_mean", "fillna_median", "drop_rows", "raise"}
+    if nan_handling not in allowed:
+        raise ValueError(f"nan_handling must be one of {sorted(allowed)}; got {nan_handling!r}")
+
+    frame = data.copy()
+    for col in frame.columns:
+        warn_if_nan_ratio_exceeds(frame[col], threshold=warn_threshold, context=f"{context}.{col}")
+
+    if nan_handling == "raise":
+        if frame.isna().any().any():
+            missing_cols = frame.columns[frame.isna().any()].tolist()
+            raise ValueError(f"{context}: NaN values present in columns {missing_cols}")
+        return frame
+    if nan_handling == "drop_rows":
+        return frame.dropna(axis=0)
+    if nan_handling == "fillna_0":
+        return frame.fillna(0)
+
+    if nan_handling == "fillna_mean":
+        fill_values = frame.mean(numeric_only=True).fillna(0)
+    else:
+        fill_values = frame.median(numeric_only=True).fillna(0)
+    return frame.fillna(fill_values).fillna(0)
+
+
 class FeatureSelectionAnalyzer:
     """
     Feature selection analyzer using statistical tests.
@@ -284,7 +312,7 @@ class FeatureSelectionAnalyzer:
         self.selected_features_ = None
         self.chi2_results_ = None
 
-    def chi2_selection(self, data, feature_cols, target_col):
+    def chi2_selection(self, data, feature_cols, target_col, nan_handling="fillna_median", nan_warn_threshold=0.05):
         """
         Select features using chi-squared test.
 
@@ -305,8 +333,13 @@ class FeatureSelectionAnalyzer:
         from sklearn.feature_selection import chi2
         from sklearn.preprocessing import MinMaxScaler
 
-        x = data[feature_cols].fillna(0)
-        y = data[target_col]
+        x = _prepare_nan_handled_frame(
+            data[feature_cols],
+            nan_handling=nan_handling,
+            warn_threshold=nan_warn_threshold,
+            context="FeatureSelectionAnalyzer.chi2_selection",
+        )
+        y = data.loc[x.index, target_col]
 
         scaler = MinMaxScaler()
         x_scaled = scaler.fit_transform(x)
@@ -324,7 +357,7 @@ class FeatureSelectionAnalyzer:
         self.selected_features_ = results.loc[results['selected'], 'feature'].tolist()
         return results
 
-    def compute_vif(self, data):
+    def compute_vif(self, data, nan_handling="fillna_median", nan_warn_threshold=0.05):
         """
         Compute Variance Inflation Factor (VIF) for multicollinearity detection.
 
@@ -340,9 +373,15 @@ class FeatureSelectionAnalyzer:
         """
         from statsmodels.stats.outliers_influence import variance_inflation_factor
 
-        x = data.fillna(0).values
+        work = _prepare_nan_handled_frame(
+            data,
+            nan_handling=nan_handling,
+            warn_threshold=nan_warn_threshold,
+            context="FeatureSelectionAnalyzer.compute_vif",
+        )
+        x = work.values
         vif_data = pd.DataFrame({
-            'feature': data.columns,
+            'feature': work.columns,
             'VIF': [variance_inflation_factor(x, i) for i in range(x.shape[1])]
         }).sort_values('VIF', ascending=False).reset_index(drop=True)
 

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Model/LRM_Tool.pyi

@@ -26,8 +26,8 @@ def compute_bic(model, x, y): ...
 
 class FeatureSelectionAnalyzer:
     def __init__(self, significance_level = 0.05): ...
-    def chi2_selection(self, data, feature_cols, target_col): ...
-    def compute_vif(self, data): ...
+    def chi2_selection(self, data, feature_cols, target_col, nan_handling = "fillna_median", nan_warn_threshold = 0.05): ...
+    def compute_vif(self, data, nan_handling = "fillna_median", nan_warn_threshold = 0.05): ...
     def correlation_filter(self, data, threshold = 0.8): ...
 
 class LRMaster:

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Pipeline/_common.py

@@ -285,7 +285,12 @@ def get_raw_model(model: Any) -> Any:
     return model
 
 
-def predict_positive(model: Any, data: pd.DataFrame, feature_cols: list[str]) -> np.ndarray:
+def predict_positive(
+    model: Any,
+    data: pd.DataFrame,
+    feature_cols: list[str],
+    warn_nan: bool = True,
+) -> np.ndarray:
     raw_model = get_raw_model(model)
     x = data[feature_cols]
 
@@ -338,7 +343,7 @@ def predict_positive(model: Any, data: pd.DataFrame, feature_cols: list[str]) ->
         )
 
     finite_mask = np.isfinite(result)
-    if not finite_mask.all():
+    if warn_nan and not finite_mask.all():
         n_bad = int((~finite_mask).sum())
         warnings.warn(
             f"predict_positive: {n_bad}/{n_rows} predictions are NaN/Inf "
@@ -349,6 +354,35 @@ def predict_positive(model: Any, data: pd.DataFrame, feature_cols: list[str]) ->
     return result
 
 
+def predict_positive_many(
+    model: Any,
+    datasets: Mapping[str, pd.DataFrame],
+    feature_cols: list[str],
+) -> tuple[dict[str, np.ndarray], dict[str, int]]:
+    """Predict multiple datasets and emit one aggregate NaN/Inf warning."""
+    preds: dict[str, np.ndarray] = {}
+    stats: dict[str, int] = {}
+    total_bad = 0
+    total_rows = 0
+    for name, data in datasets.items():
+        pred = predict_positive(model, data, feature_cols, warn_nan=False)
+        bad = int((~np.isfinite(pred)).sum())
+        stats[str(name)] = bad
+        total_bad += bad
+        total_rows += len(pred)
+        preds[str(name)] = pred
+
+    if total_bad:
+        detail = ", ".join(f"{name}={count}" for name, count in stats.items() if count)
+        warnings.warn(
+            f"NaN/Inf predictions coerced or returned: {detail}; "
+            f"total {total_bad}/{total_rows}.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+    return preds, stats
+
+
 def add_dataset_with_optional_weight(
     evaluator: Any,
     name: str,

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Pipeline/credit_model.py

@@ -6,6 +6,7 @@ from typing import Any, Literal
 
 import numpy as np
 import pandas as pd
+import warnings
 
 from ._common import (
     add_dataset_with_optional_weight,
@@ -175,6 +176,7 @@ class CreditModelPipeline:
 
     def __init__(self, config: CreditModelPipelineConfig | None = None):
         self.config = config or CreditModelPipelineConfig()
+        self.predict_positive_nan_stats: dict[str, dict[str, int]] = {}
         self._validate_gbm_feature_source_config()
 
     def run(self, data: pd.DataFrame) -> CreditModelPipelineResult:
@@ -1101,10 +1103,23 @@ class CreditModelPipeline:
                 equal_freq=True,
             )
             eval_splits = {**splits, **model_extra}
+            nan_stats: dict[str, int] = {}
             for ds_name, df in eval_splits.items():
                 scored = df.copy()
                 scored[f"pred_{name}"] = self._predict_model_positive(name, wrapper, scored, feature_cols)
+                nan_stats[str(ds_name)] = int((~np.isfinite(scored[f"pred_{name}"].to_numpy(dtype=float))).sum())
                 add_dataset_with_optional_weight(evaluator, ds_name, scored, weight_col=cfg.weight_col)
+            self.predict_positive_nan_stats[str(name)] = nan_stats
+            total_bad = sum(nan_stats.values())
+            if total_bad:
+                total_rows = sum(len(df) for df in eval_splits.values())
+                detail = ", ".join(f"{k}={v}" for k, v in nan_stats.items() if v)
+                warnings.warn(
+                    f"{name}: NaN/Inf predictions detected across evaluation datasets: "
+                    f"{detail}; total {total_bad}/{total_rows}.",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
             fig_save_path = None
             if cfg.write_outputs and cfg.plot_outputs:
                 fig_save_path = str(Path(cfg.output_dir) / "figs" / "perf" / f"perf_{name}.png")
@@ -1121,7 +1136,7 @@ class CreditModelPipeline:
         if self._warm_start_requested_for(model_name) and model_name in {"lgb", "xgb"}:
             init_score = self._get_warm_start_init_score(model_name, data)
             return wrapper.predict_with_base_margin(data[feature_cols], init_score, return_prob=True)
-        return predict_positive(wrapper, data, feature_cols)
+        return predict_positive(wrapper, data, feature_cols, warn_nan=False)
 
     def _will_run_explainability(self) -> bool:
         cfg = self.config

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Pipeline/reject_inference.py

@@ -128,6 +128,7 @@ class RejectInferencePipeline:
 
     def __init__(self, config: RejectInferencePipelineConfig | None = None):
         self.config = config or RejectInferencePipelineConfig()
+        self.predict_positive_nan_stats: dict[str, dict[str, int]] = {}
 
     def run(self, data: pd.DataFrame) -> RejectInferencePipelineResult:
         cfg = self.config
@@ -718,8 +719,22 @@ class RejectInferencePipeline:
 
             train_eval = train[train[cfg.approved_col] == 1].copy()
             eval_sets = {"train": train_eval, "validation": val.copy(), "oot": oot.copy()}
+            nan_stats: dict[str, int] = {}
             for ds in eval_sets.values():
-                ds["pred_prob"] = predict_positive(model, ds, feature_cols)
+                ds["pred_prob"] = predict_positive(model, ds, feature_cols, warn_nan=False)
+            for ds_name, ds in eval_sets.items():
+                nan_stats[ds_name] = int((~np.isfinite(ds["pred_prob"].to_numpy(dtype=float))).sum())
+            self.predict_positive_nan_stats[str(method)] = nan_stats
+            total_bad = sum(nan_stats.values())
+            if total_bad:
+                total_rows = sum(len(ds) for ds in eval_sets.values())
+                detail = ", ".join(f"{k}={v}" for k, v in nan_stats.items() if v)
+                warnings.warn(
+                    f"{method}: NaN/Inf predictions detected across RI evaluation datasets: "
+                    f"{detail}; total {total_bad}/{total_rows}.",
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
 
             evaluator = PerformanceEvaluator(
                 tgt_name=cfg.target_col,

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Pipeline/score_consistency_uat.py

@@ -242,8 +242,6 @@ class ScoreConsistencyUATPipeline:
                 coerced_count = int((as_num.notna() & original_notna).sum())
                 parse_ratio = coerced_count / original_count
                 if mode == "aggressive":
-                    if coerced_count == 0:
-                        continue
                     lost = original_count - coerced_count
                     if lost > 0:
                         _logger.warning(

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Sample/Reject_Infer.py

@@ -28,6 +28,8 @@ import numpy as np
 from typing import Union, Optional, List, Dict, Any, Tuple
 from abc import ABC, abstractmethod
 
+from Modeling_Tool._utils.nan_guard import warn_if_nan_ratio_exceeds
+
 
 class RejectInferrer(ABC):
     """
@@ -81,6 +83,45 @@ class RejectInferrer(ABC):
 
     def _rng(self) -> np.random.Generator:
         return np.random.default_rng(self.random_state)
+
+    def _filter_nan_bad_probability(
+        self,
+        df_rejected: pd.DataFrame,
+        p_bad: pd.Series,
+        score_col: str,
+        nan_score_policy: str,
+    ) -> Tuple[pd.DataFrame, pd.Series]:
+        if nan_score_policy not in {"drop", "raise", "fill_0.5"}:
+            raise ValueError("nan_score_policy must be one of 'drop', 'raise', or 'fill_0.5'")
+
+        stats = warn_if_nan_ratio_exceeds(
+            p_bad,
+            threshold=0.01,
+            context="reject inference bad probability",
+        )
+        n_nan = int(stats["n_nan"])
+        if n_nan == 0:
+            return df_rejected, p_bad
+
+        n_total = int(stats["n_total"])
+        if nan_score_policy == "raise":
+            raise ValueError(
+                f"Reject inference bad probability contains {n_nan}/{n_total} NaN values "
+                f"from score_col={score_col!r}."
+            )
+        if nan_score_policy == "fill_0.5":
+            return df_rejected, p_bad.fillna(0.5)
+
+        keep = p_bad.notna()
+        dropped = int((~keep).sum())
+        warnings.warn(
+            f"Reject inference dropped {dropped}/{n_total} rejected rows with NaN bad probability "
+            f"from score_col={score_col!r}. Set nan_score_policy='fill_0.5' to reproduce "
+            f"the legacy 50/50 behaviour.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+        return df_rejected.loc[keep].copy(), p_bad.loc[keep]
     
     @abstractmethod
     def infer(self, df_approved: pd.DataFrame,
@@ -315,12 +356,14 @@ class FuzzyAugmentInferrer(RejectInferrer):
         weight_factor: float = 1.0,
         score_direction: str = 'high_good',
         random_state: Optional[int] = None,
+        nan_score_policy: str = "drop",
     ):
         """
         Initialize FuzzyAugmentInferrer.
         """
         super().__init__(target_col, score_col, score_direction=score_direction, random_state=random_state)
         self.weight_factor = weight_factor
+        self.nan_score_policy = nan_score_policy
     
     def infer(self, df_approved: pd.DataFrame,
               df_rejected: pd.DataFrame,
@@ -347,7 +390,13 @@ class FuzzyAugmentInferrer(RejectInferrer):
         df_approved_copy = df_approved.copy()
         df_approved_copy['_weight'] = 1.0
 
-        p_bad = self._bad_probability(df_rejected[score_col]).fillna(0.5)
+        p_bad = self._bad_probability(df_rejected[score_col])
+        df_rejected, p_bad = self._filter_nan_bad_probability(
+            df_rejected,
+            p_bad,
+            score_col=score_col,
+            nan_score_policy=self.nan_score_policy,
+        )
         bad_copy = df_rejected.copy()
         bad_copy[self.target_col] = 1
         bad_copy['_weight'] = p_bad.to_numpy(dtype=float) * float(self.weight_factor)

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/Sample/Reject_Infer.pyi

@@ -31,7 +31,7 @@ class HardCutoffInferrer(RejectInferrer):
     def infer(self, df_approved: pd.DataFrame, df_rejected: pd.DataFrame, score_col: Optional[str] = None) -> pd.DataFrame: ...
 
 class FuzzyAugmentInferrer(RejectInferrer):
-    def __init__(self, target_col: str = 'target', score_col: str = 'score', weight_factor: float = 1.0, score_direction: str = 'high_good', random_state: Optional[int] = None): ...
+    def __init__(self, target_col: str = 'target', score_col: str = 'score', weight_factor: float = 1.0, score_direction: str = 'high_good', random_state: Optional[int] = None, nan_score_policy: str = "drop"): ...
     def infer(self, df_approved: pd.DataFrame, df_rejected: pd.DataFrame, score_col: Optional[str] = None) -> pd.DataFrame: ...
 
 class ParcelingInferrer(RejectInferrer):

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/__init__.py

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 __author__ = "Jingkai Sun"
-__version__ = "0.5.1"
+__version__ = "0.5.3"
 
 from ._utils import SMF_MISSING_BIN
 

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/Modeling_Tool/_utils/__init__.py

@@ -2,5 +2,6 @@
 
 from .robust import smf_logger, iv_guard
 from .sentinels import SMF_MISSING_BIN
+from .nan_guard import warn_if_nan_ratio_exceeds
 
-__all__ = ["smf_logger", "iv_guard", "SMF_MISSING_BIN"]
+__all__ = ["smf_logger", "iv_guard", "SMF_MISSING_BIN", "warn_if_nan_ratio_exceeds"]

supermodelingfactory-0.5.3/Modeling_Tool/_utils/nan_guard.py

@@ -0,0 +1,31 @@
+# encoding: utf-8
+"""Shared NaN warning helpers."""
+from __future__ import annotations
+
+import warnings
+
+import numpy as np
+import pandas as pd
+
+
+def warn_if_nan_ratio_exceeds(values, threshold: float = 0.05, context: str = "") -> dict:
+    """Warn when the NaN/Inf share in ``values`` exceeds ``threshold``.
+
+    Returns a small stats dict so callers can surface the same information in
+    reports without recomputing it.
+    """
+    arr = pd.to_numeric(pd.Series(values), errors="coerce")
+    n_total = int(len(arr))
+    n_nan = int((~np.isfinite(arr.to_numpy(dtype=float))).sum()) if n_total else 0
+    ratio = n_nan / n_total if n_total else 0.0
+    if n_total and ratio > float(threshold):
+        label = f"{context}: " if context else ""
+        warnings.warn(
+            f"{label}{n_nan}/{n_total} ({ratio:.1%}) values are NaN/Inf.",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+    return {"n_total": n_total, "n_nan": n_nan, "nan_ratio": ratio}
+
+
+__all__ = ["warn_if_nan_ratio_exceeds"]

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SuperModelingFactory
-Version: 0.5.1
+Version: 0.5.3
 Summary: Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting.
 Home-page: https://github.com/Kyle-J-Sun/SuperModelingFactory
 Author: Kyle Sun
@@ -265,7 +265,7 @@ em.close_workbook()
 
 ## 版本
 
-- **Version**: 0.4.1
+- **Version**: 0.5.3
 - **Author**: Jingkai Sun
 
 ## 许可证

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/README.md

@@ -208,7 +208,7 @@ em.close_workbook()
 
 ## 版本
 
-- **Version**: 0.4.1
+- **Version**: 0.5.3
 - **Author**: Jingkai Sun
 
 ## 许可证

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/SuperModelingFactory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SuperModelingFactory
-Version: 0.5.1
+Version: 0.5.3
 Summary: Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting.
 Home-page: https://github.com/Kyle-J-Sun/SuperModelingFactory
 Author: Kyle Sun
@@ -265,7 +265,7 @@ em.close_workbook()
 
 ## 版本
 
-- **Version**: 0.4.1
+- **Version**: 0.5.3
 - **Author**: Jingkai Sun
 
 ## 许可证

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/SuperModelingFactory.egg-info/SOURCES.txt

@@ -93,6 +93,7 @@ Modeling_Tool/WOE/__init__.py
 Modeling_Tool/WOE/plot_woe_tool.py
 Modeling_Tool/WOE/plot_woe_tool.pyi
 Modeling_Tool/_utils/__init__.py
+Modeling_Tool/_utils/nan_guard.py
 Modeling_Tool/_utils/robust.py
 Modeling_Tool/_utils/sentinels.py
 Modeling_Tool/ref_font/KaiTi.ttf

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "SuperModelingFactory"
-version = "0.5.1"
+version = "0.5.3"
 description = "Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting."
 readme = "README.md"
 requires-python = ">=3.10"

{supermodelingfactory-0.5.1 → supermodelingfactory-0.5.3}/setup.py

@@ -15,7 +15,7 @@ def _read(path: str) -> str:
 
 setup(
     name="SuperModelingFactory",
-    version=os.environ.get("SMF_VERSION", "0.5.1"),
+    version=os.environ.get("SMF_VERSION", "0.5.3"),
     description="Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting.",
     long_description=_read("README.md"),
     long_description_content_type="text/markdown",