SuperModelingFactory 0.3.9__tar.gz → 0.3.10__tar.gz

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

@@ -10,8 +10,6 @@ from typing import Any, Mapping
 import numpy as np
 import pandas as pd
 
-from Modeling_Tool.Pipeline._common import apply_woe_fit_query, as_list
-
 from .Weighted_Screen import (
     WeightedScreenResult,
     _legacy_unweighted_screen,
@@ -123,6 +121,8 @@ def fit_screening_woe_engine(
     categorical_features: list[str] | None = None,
 ) -> Any:
     """Fit a WOE engine on INS for screening steps that reuse bin boundaries."""
+    from Modeling_Tool.Pipeline._common import apply_woe_fit_query
+
     fit_ins, _ = apply_woe_fit_query(train, woe_fit_query, target=target_col)
     if woe_engine.lower() == "monotone":
         from Modeling_Tool import MonotoneWOEBinner
@@ -130,6 +130,8 @@ def fit_screening_woe_engine(
         params = dict(monotone_woe_params or {})
         init_params = {k: v for k, v in params.items() if k in _MONOTONE_INIT_KEYS}
         fit_params = {k: v for k, v in params.items() if k in _MONOTONE_FIT_KEYS}
+        from Modeling_Tool.Pipeline._common import as_list
+
         categorical = [col for col in as_list(categorical_features) if col in features]
         numeric = [col for col in features if col not in set(categorical)]
         binner = MonotoneWOEBinner(

{supermodelingfactory-0.3.9 → supermodelingfactory-0.3.10}/Modeling_Tool/Pipeline/__init__.py

@@ -29,6 +29,7 @@ from .feature_validation import (
     FeatureValidationPipelineConfig,
     FeatureValidationPipelineResult,
 )
+from .screening_artifact import FeatureScreeningArtifact, screen_result_to_summary
 
 __all__ = [
     "RejectInferencePipeline",
@@ -52,4 +53,6 @@ __all__ = [
     "FeatureValidationPipeline",
     "FeatureValidationPipelineConfig",
     "FeatureValidationPipelineResult",
+    "FeatureScreeningArtifact",
+    "screen_result_to_summary",
 ]

{supermodelingfactory-0.3.9 → supermodelingfactory-0.3.10}/Modeling_Tool/Pipeline/feature_validation.py

@@ -97,6 +97,10 @@ class FeatureValidationPipelineConfig:
         }
     )
 
+    selection_enabled: bool = False
+    selection_params: dict[str, Any] = field(default_factory=dict)
+    weight_col: str | None = None
+
     write_outputs: bool = True
     write_excel: bool = True
 
@@ -117,6 +121,9 @@ class FeatureValidationPipelineResult:
     report_path: str | None = None
     batch_metadata: pd.DataFrame | None = None
     batch_results: dict[str, Any] = field(default_factory=dict)
+    selected_features: list[str] = field(default_factory=list)
+    selection_summary: dict[str, Any] = field(default_factory=dict)
+    screening_artifact: Any | None = None
 
 
 class FeatureValidationPipeline:
@@ -190,6 +197,17 @@ class FeatureValidationPipeline:
             if cfg.corr_enabled
             else (pd.DataFrame(), pd.DataFrame(), pd.DataFrame())
         )
+        selected_features: list[str] = []
+        selection_summary: dict[str, Any] = {}
+        screening_artifact = None
+        if cfg.selection_enabled and target_cols:
+            selected_features, selection_summary, screening_artifact = self._run_selection(
+                splits=splits,
+                new_features=new_features,
+                incumbent_features=incumbent_features,
+                target_cols=target_cols,
+                woe_artifacts=woe_artifacts,
+            )
         validation_summary = self._build_validation_summary(
             data=combined,
             new_features=new_features,
@@ -201,6 +219,7 @@ class FeatureValidationPipeline:
             ivks_summary=ivks_summary,
             high_corr_pairs=high_corr_pairs,
             woe_artifacts=woe_artifacts,
+            selected_features=selected_features,
         )
 
         tables = self._collect_tables(
@@ -213,6 +232,8 @@ class FeatureValidationPipeline:
             high_corr_pairs,
             correlated_detail,
             validation_summary,
+            selected_features=selected_features,
+            selection_summary=selection_summary,
         )
         output_paths, report_path = self._write_outputs(tables)
 
@@ -229,6 +250,9 @@ class FeatureValidationPipeline:
             validation_summary=validation_summary,
             output_paths=output_paths,
             report_path=report_path,
+            selected_features=selected_features,
+            selection_summary=selection_summary,
+            screening_artifact=screening_artifact,
         )
 
     def _resolve_input_type(self, data: pd.DataFrame | str | Path) -> str:
@@ -354,6 +378,9 @@ class FeatureValidationPipeline:
             report_path=result.report_path,
             batch_metadata=result.batch_metadata,
             batch_results=result.batch_results,
+            selected_features=list(result.selected_features),
+            selection_summary=dict(result.selection_summary or {}),
+            screening_artifact=result.screening_artifact,
         )
 
     def _validate_batch_config(self, new_features: list[str]) -> None:
@@ -498,6 +525,35 @@ class FeatureValidationPipeline:
             woe_artifacts=woe_artifacts,
             batch_metadata=batch_metadata,
         )
+        selected_features = self._dedupe(
+            [feat for res in batch_results for feat in as_list(res.selected_features)]
+        )
+        selection_summary: dict[str, Any] = {}
+        screening_artifact = None
+        if self.config.selection_enabled and target_cols:
+            selection_summary = {
+                "initial_features": list(new_features),
+                "final_features": selected_features,
+                "target_col": target_cols[0],
+                "config_snapshot": {
+                    "selection_enabled": True,
+                    "selection_params": dict(self.config.selection_params or {}),
+                    "weight_col": self.config.weight_col,
+                    "batch_mode": True,
+                },
+            }
+            if selected_features:
+                from .screening_artifact import FeatureScreeningArtifact
+
+                screening_artifact = FeatureScreeningArtifact(
+                    selected_features=selected_features,
+                    selection_summary=selection_summary,
+                    woe_artifacts=woe_artifacts,
+                    source="fvp",
+                    target_col=target_cols[0],
+                    weight_col=self.config.weight_col,
+                    config_snapshot=selection_summary["config_snapshot"],
+                )
         tables = self._collect_tables(
             feature_sources,
             distribution_summary,
@@ -508,6 +564,8 @@ class FeatureValidationPipeline:
             high_corr_pairs,
             correlated_detail,
             validation_summary,
+            selected_features=selected_features,
+            selection_summary=selection_summary,
         )
         tables["batch_metadata"] = batch_metadata
         output_paths, report_path = self._write_outputs(tables)
@@ -532,6 +590,9 @@ class FeatureValidationPipeline:
                 }
                 for idx, res in enumerate(batch_results)
             },
+            selected_features=selected_features,
+            selection_summary=selection_summary,
+            screening_artifact=screening_artifact,
         )
 
     @staticmethod
@@ -1106,6 +1167,102 @@ class FeatureValidationPipeline:
         except Exception:
             return
 
+    def _build_selection_config(self) -> Any:
+        from Modeling_Tool.Feature.Feature_Screen import screen_config_from_mapping
+
+        cfg = self.config
+        params = dict(cfg.selection_params or {})
+        corr_params = dict(cfg.corr_params or {})
+        psi_params = dict(cfg.psi_params or {})
+        mapping = {
+            "psi_enabled": params.get("psi_enabled", cfg.psi_enabled),
+            "psi_threshold": params.get("psi_threshold", 0.2),
+            "psi_compare_splits": params.get("psi_compare_splits", ["oos"]),
+            "psi_buckets": params.get("psi_buckets", psi_params.get("buckets", 10)),
+            "psi_use_woe_bins": params.get("psi_use_woe_bins", cfg.psi_use_woe_bins),
+            "iv_enabled": params.get("iv_enabled", cfg.ivks_enabled),
+            "iv_threshold": params.get("iv_threshold", 0.02),
+            "iv_nbins": params.get("iv_nbins", psi_params.get("buckets", 10)),
+            "iv_min_bin_prop": params.get("iv_min_bin_prop", psi_params.get("min_bin_prop", 0.05)),
+            "iv_equal_freq": params.get("iv_equal_freq", psi_params.get("equal_freq", True)),
+            "iv_use_woe_bins": params.get("iv_use_woe_bins", cfg.ivks_use_woe_bins),
+            "corr_enabled": params.get("corr_enabled", cfg.corr_enabled),
+            "corr_threshold": params.get(
+                "corr_threshold",
+                params.get("corr_cutpoint", corr_params.get("corr_cutpoint", 0.75)),
+            ),
+            "corr_max_iterations": params.get(
+                "corr_max_iterations",
+                corr_params.get("max_iterations", 10),
+            ),
+            "corr_use_woe_bins": params.get("corr_use_woe_bins", cfg.corr_use_woe_bins),
+        }
+        return screen_config_from_mapping(
+            mapping,
+            woe_engine=cfg.woe_engine,
+            woe_fit_query=cfg.woe_fit_query,
+            woe_params=cfg.woe_params,
+            monotone_woe_params=cfg.monotone_woe_params,
+        )
+
+    def _run_selection(
+        self,
+        splits: dict[str, pd.DataFrame],
+        new_features: list[str],
+        incumbent_features: list[str],
+        target_cols: list[str],
+        woe_artifacts: dict[str, Any],
+    ) -> tuple[list[str], dict[str, Any], Any | None]:
+        from Modeling_Tool.Feature.Feature_Screen import feature_screen
+        from .screening_artifact import FeatureScreeningArtifact, screen_result_to_summary
+
+        cfg = self.config
+        target = target_cols[0]
+        screen_cfg = self._build_selection_config()
+        engine = None
+        if woe_artifacts:
+            engine = woe_artifacts.get("by_target", {}).get(target, {}).get("engine")
+
+        screen_features = list(new_features)
+        if cfg.weight_col and cfg.weight_col not in splits["ins"].columns:
+            raise KeyError(f"Missing weight_col {cfg.weight_col!r} for weighted selection.")
+
+        result = feature_screen(
+            splits,
+            screen_features,
+            target,
+            weight_col=cfg.weight_col,
+            config=screen_cfg,
+            prefit_woe_engine=engine,
+        )
+        config_snapshot = {
+            "selection_enabled": True,
+            "selection_params": dict(cfg.selection_params or {}),
+            "weight_col": cfg.weight_col,
+            "psi_use_woe_bins": screen_cfg.psi_use_woe_bins,
+            "iv_use_woe_bins": screen_cfg.iv_use_woe_bins,
+            "corr_use_woe_bins": screen_cfg.corr_use_woe_bins,
+            "n_incumbent_features": len(incumbent_features),
+        }
+        selection_summary = {
+            "initial_features": list(new_features),
+            "final_features": list(result.selected_features),
+            "target_col": target,
+            "config_snapshot": config_snapshot,
+        }
+        selection_summary.update(screen_result_to_summary(result, new_features))
+        selection_summary["config_snapshot"] = config_snapshot
+        artifact = FeatureScreeningArtifact.from_screen_result(
+            result,
+            initial_features=list(new_features),
+            target_col=target,
+            weight_col=cfg.weight_col,
+            woe_artifacts=woe_artifacts,
+            source="fvp",
+            config_snapshot=config_snapshot,
+        )
+        return list(result.selected_features), selection_summary, artifact
+
     def _run_psi(
         self,
         combined: pd.DataFrame,
@@ -1469,6 +1626,7 @@ class FeatureValidationPipeline:
         ivks_summary: pd.DataFrame,
         high_corr_pairs: pd.DataFrame,
         woe_artifacts: dict[str, Any],
+        selected_features: list[str] | None = None,
     ) -> pd.DataFrame:
         rows = [
             {"metric": "n_rows", "value": len(data)},
@@ -1483,6 +1641,9 @@ class FeatureValidationPipeline:
             {"metric": "woe_targets", "value": len(woe_artifacts.get("by_target", {})) if woe_artifacts else 0},
             {"metric": "feature_sources", "value": feature_sources["feature_source"].value_counts().to_dict()},
         ]
+        if self.config.selection_enabled:
+            rows.append({"metric": "selection_enabled", "value": True})
+            rows.append({"metric": "n_selected_features", "value": len(selected_features or [])})
         return pd.DataFrame(rows)
 
     def _collect_tables(
@@ -1496,6 +1657,8 @@ class FeatureValidationPipeline:
         high_corr_pairs: pd.DataFrame,
         correlated_detail: pd.DataFrame,
         validation_summary: pd.DataFrame,
+        selected_features: list[str] | None = None,
+        selection_summary: dict[str, Any] | None = None,
     ) -> dict[str, pd.DataFrame]:
         tables = {
             "validation_summary": validation_summary,
@@ -1508,6 +1671,11 @@ class FeatureValidationPipeline:
             "high_corr_pairs": high_corr_pairs,
             "correlated_detail": correlated_detail,
         }
+        if selected_features:
+            tables["selected_features"] = pd.DataFrame({"feature": selected_features})
+        screen_summary = (selection_summary or {}).get("screen_summary")
+        if isinstance(screen_summary, pd.DataFrame) and not screen_summary.empty:
+            tables["selection_screen_summary"] = screen_summary
         for name, df in distribution_summary.items():
             tables[f"distribution_{name}"] = df
         return tables

supermodelingfactory-0.3.10/Modeling_Tool/Pipeline/screening_artifact.py

@@ -0,0 +1,123 @@
+"""Handoff contract between feature validation and credit modeling pipelines."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Literal
+
+import pandas as pd
+
+from Modeling_Tool.Feature.Weighted_Screen import WeightedScreenResult
+
+
+def screen_result_to_summary(
+    result: WeightedScreenResult,
+    initial_features: list[str],
+) -> dict[str, Any]:
+    """Convert a screening result into CM-compatible ``feature_selection_summary``."""
+    summary: dict[str, Any] = {"initial_features": list(initial_features)}
+    if not result.psi_table.empty:
+        psi = result.psi_table.copy()
+        if "psi_ins_oos" in psi.columns:
+            psi["psi"] = psi["psi_ins_oos"]
+        elif "psi_max" in psi.columns:
+            psi["psi"] = psi["psi_max"]
+        summary["psi"] = psi
+    if not result.iv_table.empty:
+        iv = result.iv_table.copy()
+        if "iv_weighted" in iv.columns:
+            iv = iv.rename(columns={"iv_weighted": "iv"})
+        summary["iv"] = iv
+    if not result.corr_dropped.empty:
+        summary["corr_dropped"] = result.corr_dropped
+    summary["corr_features"] = list(result.selected_features)
+    summary["screen_summary"] = result.summary
+    summary["final_features"] = list(result.selected_features)
+    return summary
+
+
+@dataclass
+class FeatureScreeningArtifact:
+    selected_features: list[str]
+    selection_summary: dict[str, Any]
+    woe_artifacts: dict[str, Any] | None
+    source: Literal["fvp", "cm", "standalone"]
+    target_col: str
+    weight_col: str | None
+    config_snapshot: dict[str, Any] = field(default_factory=dict)
+    created_at: str | None = None
+
+    @classmethod
+    def from_screen_result(
+        cls,
+        result: WeightedScreenResult,
+        *,
+        initial_features: list[str],
+        target_col: str,
+        weight_col: str | None,
+        woe_artifacts: dict[str, Any] | None,
+        source: Literal["fvp", "cm", "standalone"],
+        config_snapshot: dict[str, Any] | None = None,
+    ) -> FeatureScreeningArtifact:
+        return cls(
+            selected_features=list(result.selected_features),
+            selection_summary=screen_result_to_summary(result, initial_features),
+            woe_artifacts=woe_artifacts,
+            source=source,
+            target_col=target_col,
+            weight_col=weight_col,
+            config_snapshot=dict(config_snapshot or {}),
+            created_at=datetime.now(timezone.utc).isoformat(),
+        )
+
+    @classmethod
+    def from_fvp_result(
+        cls,
+        result: Any,
+        *,
+        target_col: str | None = None,
+    ) -> FeatureScreeningArtifact:
+        if getattr(result, "screening_artifact", None) is not None:
+            return result.screening_artifact
+        resolved_target = target_col
+        if not resolved_target:
+            summary = getattr(result, "selection_summary", {}) or {}
+            resolved_target = summary.get("target_col")
+        if not resolved_target:
+            raise ValueError("target_col is required when building artifact from FVP result.")
+        summary = dict(getattr(result, "selection_summary", {}) or {})
+        config_snapshot = dict(summary.get("config_snapshot", {}) or {})
+        return cls(
+            selected_features=list(getattr(result, "selected_features", []) or []),
+            selection_summary=summary,
+            woe_artifacts=getattr(result, "woe_artifacts", None),
+            source="fvp",
+            target_col=str(resolved_target),
+            weight_col=config_snapshot.get("weight_col"),
+            config_snapshot=config_snapshot,
+            created_at=datetime.now(timezone.utc).isoformat(),
+        )
+
+    def validate_for_cm(self, *, target_col: str, weight_col: str | None = None) -> None:
+        if self.target_col != target_col:
+            raise ValueError(
+                f"screening artifact target_col {self.target_col!r} does not match CM target_col {target_col!r}"
+            )
+        if self.weight_col != weight_col:
+            raise ValueError(
+                f"screening artifact weight_col {self.weight_col!r} does not match CM weight_col {weight_col!r}"
+            )
+
+    def to_dict(self) -> dict[str, Any]:
+        payload = asdict(self)
+        for key, value in list(payload.items()):
+            if isinstance(value, pd.DataFrame):
+                payload[key] = value.to_dict(orient="records")
+        return payload
+
+
+__all__ = [
+    "FeatureScreeningArtifact",
+    "screen_result_to_summary",
+]

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 __author__ = "Jingkai Sun"
-__version__ = "0.3.9"
+__version__ = "0.3.10"
 
 # Core module - base data structures
 from .Core import (
@@ -116,6 +116,7 @@ _PIPELINE_EXPORTS = frozenset({
     'SampleAnalysisPipeline', 'SampleAnalysisPipelineConfig', 'SampleAnalysisPipelineResult',
     'MockSamplePipeline', 'MockSamplePipelineConfig', 'MockSamplePipelineResult',
     'FeatureValidationPipeline', 'FeatureValidationPipelineConfig', 'FeatureValidationPipelineResult',
+    'FeatureScreeningArtifact', 'screen_result_to_summary',
 })
 
 def __getattr__(name):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SuperModelingFactory
-Version: 0.3.9
+Version: 0.3.10
 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.9 → supermodelingfactory-0.3.10}/SuperModelingFactory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SuperModelingFactory
-Version: 0.3.9
+Version: 0.3.10
 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.9 → supermodelingfactory-0.3.10}/SuperModelingFactory.egg-info/SOURCES.txt

@@ -66,6 +66,7 @@ Modeling_Tool/Pipeline/reject_inference.py
 Modeling_Tool/Pipeline/sample_analysis.py
 Modeling_Tool/Pipeline/score_comparison.py
 Modeling_Tool/Pipeline/score_consistency_uat.py
+Modeling_Tool/Pipeline/screening_artifact.py
 Modeling_Tool/Sample/Distribution_Adaptation.py
 Modeling_Tool/Sample/Distribution_Adaptation.pyi
 Modeling_Tool/Sample/Reject_Infer.py

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

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

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

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