SuperModelingFactory 0.3.10__tar.gz → 0.3.12__tar.gz

{supermodelingfactory-0.3.10 → supermodelingfactory-0.3.12}/Modeling_Tool/Feature/Feature_Screen.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import warnings
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Mapping
@@ -10,11 +9,18 @@ from typing import Any, Mapping
 import numpy as np
 import pandas as pd
 
+from Modeling_Tool.Core.sample_weight_utils import resolve_sample_weight
+
 from .Weighted_Screen import (
     WeightedScreenResult,
+    _corr_dedup_weighted,
     _legacy_unweighted_screen,
+    _psi_from_distributions,
     _resolve_splits,
     _summary_row,
+    _weighted_bin_distribution,
+    _weighted_iv_from_assigned_bins,
+    _weighted_pearson_corr_matrix,
     _weighted_screen_impl,
 )
 
@@ -289,6 +295,128 @@ def _woe_bins_unweighted_screen(
     )
 
 
+def _bins_to_numpy(bins: Any) -> np.ndarray:
+    if isinstance(bins, pd.Series):
+        return bins.to_numpy(dtype=object)
+    return np.asarray(bins, dtype=object)
+
+
+def _weighted_woe_bins_screen(
+    splits: dict[str, pd.DataFrame],
+    feature_cols: list[str],
+    target_col: str,
+    weight_col: str,
+    config: FeatureScreenConfig,
+    *,
+    prefit_woe_engine: Any | None = None,
+) -> FeatureScreenResult:
+    from Modeling_Tool.WOE.WOE_Adapter import as_woe_engine
+
+    ins, oos, oot = splits["ins"], splits["oos"], splits["oot"]
+    w_ins = resolve_sample_weight(data=ins, weight_col=weight_col, expected_len=len(ins))
+    y_ins = ins[target_col].astype(float).to_numpy()
+    current = list(feature_cols)
+    summary_rows = [_summary_row("initial", len(feature_cols), len(current), None, weight_col)]
+
+    binner = prefit_woe_engine
+    if binner is None:
+        binner = fit_screening_woe_engine(
+            ins,
+            feature_cols,
+            target_col,
+            woe_engine=config.woe_engine,
+            woe_fit_query=config.woe_fit_query,
+            woe_params=config.woe_params,
+            monotone_woe_params=config.monotone_woe_params,
+            categorical_features=config.categorical_features,
+        )
+    adapter = as_woe_engine(binner)
+
+    psi_records: list[dict] = []
+    if config.psi_enabled:
+        for var in feature_cols:
+            if var not in ins.columns or ins[var].nunique(dropna=False) <= 1:
+                continue
+            bins_ins = _bins_to_numpy(adapter.assign_bins(ins, var))
+            exp_dist = _weighted_bin_distribution(bins_ins, w_ins, config.content)
+            row: dict[str, Any] = {"var": var, "psi_ins_oos": np.nan, "psi_ins_oot": np.nan}
+            if "oos" in config.psi_compare_splits and len(oos) > 0:
+                w_oos = resolve_sample_weight(data=oos, weight_col=weight_col, expected_len=len(oos))
+                bins_oos = _bins_to_numpy(adapter.assign_bins(oos, var))
+                act = _weighted_bin_distribution(bins_oos, w_oos, config.content)
+                row["psi_ins_oos"] = _psi_from_distributions(exp_dist, act, config.content)
+            if "oot" in config.psi_compare_splits and len(oot) > 0:
+                w_oot = resolve_sample_weight(data=oot, weight_col=weight_col, expected_len=len(oot))
+                bins_oot = _bins_to_numpy(adapter.assign_bins(oot, var))
+                act = _weighted_bin_distribution(bins_oot, w_oot, config.content)
+                row["psi_ins_oot"] = _psi_from_distributions(exp_dist, act, config.content)
+            psi_records.append(row)
+
+        psi_table = pd.DataFrame(psi_records) if psi_records else pd.DataFrame(
+            columns=["var", "psi_ins_oos", "psi_ins_oot"],
+        )
+        if not psi_table.empty:
+            compare_cols = [c for c in ("psi_ins_oos", "psi_ins_oot") if c in psi_table.columns]
+            psi_table["psi_max"] = psi_table[compare_cols].max(axis=1, skipna=True)
+            keep = psi_table.loc[psi_table["psi_max"] < config.psi_threshold, "var"].tolist()
+            n_before = len(current)
+            current = [v for v in current if v in keep] or current
+            summary_rows.append(_summary_row("psi", n_before, len(current), config.psi_threshold, weight_col))
+        else:
+            psi_table["psi_max"] = pd.Series(dtype=float)
+    else:
+        psi_table = pd.DataFrame(columns=["var", "psi_ins_oos", "psi_ins_oot", "psi_max"])
+
+    iv_records: list[dict] = []
+    if config.iv_enabled:
+        for var in current:
+            if var not in ins.columns or ins[var].nunique(dropna=False) <= 1:
+                continue
+            bins_ins = _bins_to_numpy(adapter.assign_bins(ins, var))
+            x_ins = ins[var].to_numpy(dtype=float)
+            iv_val, n_b, miss = _weighted_iv_from_assigned_bins(y_ins, w_ins, bins_ins, x_ins)
+            iv_records.append({
+                "var": var,
+                "iv_weighted": iv_val,
+                "n_bins": n_b,
+                "missing_rate": miss,
+            })
+        iv_table = pd.DataFrame(iv_records) if iv_records else pd.DataFrame(
+            columns=["var", "iv_weighted", "n_bins", "missing_rate"],
+        )
+        if not iv_table.empty:
+            keep = iv_table.loc[iv_table["iv_weighted"] >= config.iv_threshold, "var"].tolist()
+            n_before = len(current)
+            current = [v for v in current if v in keep] or current
+            summary_rows.append(_summary_row("iv", n_before, len(current), config.iv_threshold, weight_col))
+    else:
+        iv_table = pd.DataFrame(columns=["var", "iv_weighted", "n_bins", "missing_rate"])
+
+    corr_dropped = pd.DataFrame(columns=["var_a", "var_b", "corr", "iv_a", "iv_b", "kept", "dropped"])
+    if config.corr_enabled and len(current) > 1:
+        X = ins[current].astype(float).to_numpy()
+        corr = _weighted_pearson_corr_matrix(X, w_ins)
+        iv_map = dict(zip(iv_table["var"], iv_table["iv_weighted"])) if not iv_table.empty else {}
+        n_before = len(current)
+        current, corr_dropped = _corr_dedup_weighted(
+            current,
+            corr,
+            iv_map,
+            config.corr_threshold,
+            config.corr_max_iterations,
+        )
+        summary_rows.append(_summary_row("corr", n_before, len(current), config.corr_threshold, weight_col))
+
+    summary_rows.append(_summary_row("final", len(feature_cols), len(current), None, weight_col))
+    return FeatureScreenResult(
+        selected_features=list(current),
+        iv_table=iv_table,
+        psi_table=psi_table,
+        corr_dropped=corr_dropped,
+        summary=pd.DataFrame(summary_rows),
+    )
+
+
 def feature_screen(
     splits: dict[str, pd.DataFrame],
     feature_cols: list[str],
@@ -303,11 +431,14 @@ def feature_screen(
     use_woe_bins = _needs_woe_bins(cfg)
 
     if weight_col is not None:
-        if use_woe_bins:
-            warnings.warn(
-                "Weighted feature screening with psi/iv/corr_use_woe_bins is not fully "
-                "supported yet; falling back to weighted equal-frequency bins.",
-                stacklevel=2,
+        if use_woe_bins or prefit_woe_engine is not None:
+            return _weighted_woe_bins_screen(
+                splits,
+                feature_cols,
+                target_col,
+                weight_col,
+                cfg,
+                prefit_woe_engine=prefit_woe_engine,
             )
         return _weighted_screen_impl(
             splits,

{supermodelingfactory-0.3.10 → supermodelingfactory-0.3.12}/Modeling_Tool/Feature/Weighted_Screen.py

@@ -119,6 +119,37 @@ def _psi_from_distributions(expected: pd.Series, actual: pd.Series, content: flo
     return float(((a - e) * np.log(a / e)).sum())
 
 
+def _weighted_iv_from_assigned_bins(
+    y: np.ndarray,
+    w: np.ndarray,
+    bins: np.ndarray,
+    x: np.ndarray,
+) -> tuple[float, int, float]:
+    total_bad = float(np.sum(w * y))
+    total_good = float(np.sum(w * (1.0 - y)))
+    if total_bad <= 0 or total_good <= 0:
+        missing_rate = 1.0 - float(np.sum(w[np.isfinite(x)])) / float(np.sum(w) or 1.0)
+        return 0.0, 0, missing_rate
+
+    rows = []
+    for b in pd.unique(bins):
+        m = bins == b
+        bad_w = float(np.sum(w[m] * y[m]))
+        good_w = float(np.sum(w[m] * (1.0 - y[m])))
+        rows.append({
+            "bad_pct": bad_w / total_bad,
+            "good_pct": good_w / total_good,
+        })
+    if not rows:
+        missing_rate = 1.0 - float(np.sum(w[np.isfinite(x)])) / float(np.sum(w) or 1.0)
+        return 0.0, 0, missing_rate
+
+    stats = pd.DataFrame(rows)
+    iv = float(calc_iv(stats, "bad_pct", "good_pct").sum())
+    missing_rate = 1.0 - float(np.sum(w[np.isfinite(x)])) / float(np.sum(w) or 1.0)
+    return iv, len(rows), missing_rate
+
+
 def _weighted_iv_for_var(
     x: np.ndarray,
     y: np.ndarray,

{supermodelingfactory-0.3.10 → supermodelingfactory-0.3.12}/Modeling_Tool/Pipeline/credit_model.py

@@ -97,6 +97,11 @@ class CreditModelPipelineConfig:
     perf_pct_bins: int = 10
     perf_min_bin_prop: float = 0.03
 
+    screening_artifact: Any | None = None
+    feature_validation_result: Any | None = None
+    feature_selection_mode: Literal["run", "from_artifact", "skip"] = "run"
+    reuse_screening_woe: bool = True
+
 
 @dataclass
 class CreditModelPipelineResult:
@@ -190,8 +195,12 @@ class CreditModelPipeline:
             make_dirs(self._model_output_dir(), output_dir / "artifacts")
 
         splits = self._split_data(data)
-        fs_summary, final_features = self._feature_selection(splits, feature_cols)
-        woe_artifacts = self._fit_woe(splits, final_features)
+        fs_summary, final_features, screening_artifact = self._resolve_feature_selection(
+            splits,
+            feature_cols,
+        )
+        prefit_woe = screening_artifact.woe_artifacts if screening_artifact and cfg.reuse_screening_woe else None
+        woe_artifacts = self._fit_woe(splits, final_features, prefit_woe_artifacts=prefit_woe)
         woe_features = woe_artifacts["woe_features"]
         woe_splits = woe_artifacts["splits"]
         woe_suffix = woe_artifacts.get("woe_suffix", cfg.woe_params.get("woe_suffix", "_woe"))
@@ -424,6 +433,48 @@ class CreditModelPipeline:
             oot = oos.copy()
         return {"ins": ins.copy(), "oos": oos.copy(), "oot": oot.copy()}
 
+    def _resolve_screening_artifact(self) -> Any | None:
+        cfg = self.config
+        if cfg.screening_artifact is not None:
+            return cfg.screening_artifact
+        if cfg.feature_validation_result is not None:
+            from .screening_artifact import FeatureScreeningArtifact
+
+            return FeatureScreeningArtifact.from_fvp_result(
+                cfg.feature_validation_result,
+                target_col=cfg.target_col,
+            )
+        return None
+
+    def _resolve_feature_selection(
+        self,
+        splits: dict[str, pd.DataFrame],
+        feature_cols: list[str],
+    ) -> tuple[dict[str, Any], list[str], Any | None]:
+        cfg = self.config
+        artifact = self._resolve_screening_artifact()
+        mode = cfg.feature_selection_mode
+        if artifact is not None:
+            mode = "from_artifact"
+        if mode == "from_artifact":
+            if artifact is None:
+                raise ValueError("feature_selection_mode='from_artifact' requires screening_artifact.")
+            artifact.validate_for_cm(target_col=cfg.target_col, weight_col=cfg.weight_col)
+            summary = dict(artifact.selection_summary or {})
+            summary["from_artifact"] = True
+            summary["artifact_source"] = artifact.source
+            selected = list(artifact.selected_features) or list(feature_cols)
+            return summary, selected, artifact
+        if mode == "skip":
+            summary = {
+                "skipped": True,
+                "initial_features": list(feature_cols),
+                "final_features": list(feature_cols),
+            }
+            return summary, list(feature_cols), None
+        summary, selected = self._feature_selection(splits, feature_cols)
+        return summary, selected, None
+
     def _feature_selection(
         self,
         splits: dict[str, pd.DataFrame],
@@ -509,12 +560,80 @@ class CreditModelPipeline:
                 transformed[name] = transform_fn(df)
         return transformed
 
-    def _fit_woe(self, splits: dict[str, pd.DataFrame], feature_cols: list[str]) -> dict[str, Any]:
+    def _reuse_screening_woe(
+        self,
+        splits: dict[str, pd.DataFrame],
+        feature_cols: list[str],
+        prefit_woe_artifacts: dict[str, Any],
+    ) -> dict[str, Any] | None:
+        from Modeling_Tool.WOE.WOE_Adapter import as_woe_engine
+
+        cfg = self.config
+        by_target = prefit_woe_artifacts.get("by_target", {}) if prefit_woe_artifacts else {}
+        item = by_target.get(cfg.target_col)
+        if not item:
+            return None
+
+        adapter = item.get("adapter")
+        if adapter is None and item.get("engine") is not None:
+            woe_suffix = cfg.woe_params.get("woe_suffix", "_woe")
+            adapter = as_woe_engine(item["engine"], woe_suffix=woe_suffix)
+        if adapter is None:
+            return None
+
+        fitted = set(item.get("features") or [])
+        usable = [col for col in feature_cols if col in fitted]
+        if not usable:
+            return None
+
+        woe_suffix = cfg.woe_params.get("woe_suffix", "_woe")
+        woe_features = [f"{col}{woe_suffix}" for col in usable]
+        woe_splits = {
+            name: adapter.transform(df, varlist=usable, suffix=woe_suffix)
+            for name, df in splits.items()
+        }
+        extra_eval = self._transform_extra_eval_datasets(
+            adapter.transform,
+            usable,
+            woe_suffix=woe_suffix,
+        )
+        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()
+            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()
+
+        return {
+            "engine": adapter,
+            "engine_name": adapter.get_engine_name() if hasattr(adapter, "get_engine_name") else cfg.woe_engine,
+            "features": list(usable),
+            "woe_features": woe_features,
+            "woe_suffix": woe_suffix,
+            "splits": woe_splits,
+            "extra_eval": extra_eval,
+            "woe_table": adapter.get_woe_table(varlist=usable),
+            "reused_from_screening": True,
+        }
+
+    def _fit_woe(
+        self,
+        splits: dict[str, pd.DataFrame],
+        feature_cols: list[str],
+        *,
+        prefit_woe_artifacts: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
         from Modeling_Tool import MonotoneWOEBinner, WOE_Master
         from Modeling_Tool.WOE.WOE_Adapter import as_woe_engine
         from Modeling_Tool.WOE.WOE_Master import get_overall_woe_table
 
         cfg = self.config
+        if prefit_woe_artifacts and cfg.reuse_screening_woe:
+            reused = self._reuse_screening_woe(splits, feature_cols, prefit_woe_artifacts)
+            if reused is not None:
+                return reused
+
         woe_suffix = cfg.woe_params.get("woe_suffix", "_woe")
         graph_dir = str(Path(cfg.output_dir) / "figs" / "woe")
         woe_features = [f"{col}{woe_suffix}" for col in feature_cols]

{supermodelingfactory-0.3.10 → supermodelingfactory-0.3.12}/Modeling_Tool/__init__.py

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 __author__ = "Jingkai Sun"
-__version__ = "0.3.10"
+__version__ = "0.3.12"
 
 # Core module - base data structures
 from .Core import (

{supermodelingfactory-0.3.10 → supermodelingfactory-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SuperModelingFactory
-Version: 0.3.10
+Version: 0.3.12
 Summary: Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting.
 Home-page: https://github.com/Kyle-J-Sun/SuperModelingFactory
 Author: Kyle Sun

{supermodelingfactory-0.3.10 → supermodelingfactory-0.3.12}/SuperModelingFactory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SuperModelingFactory
-Version: 0.3.10
+Version: 0.3.12
 Summary: Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting.
 Home-page: https://github.com/Kyle-J-Sun/SuperModelingFactory
 Author: Kyle Sun

{supermodelingfactory-0.3.10 → supermodelingfactory-0.3.12}/pyproject.toml

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

{supermodelingfactory-0.3.10 → supermodelingfactory-0.3.12}/setup.py

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