SuperModelingFactory 0.6.5__tar.gz → 0.6.7__tar.gz

{supermodelingfactory-0.6.5 → supermodelingfactory-0.6.7}/Modeling_Tool/Eval/Model_Eval_Tool.py

@@ -2169,7 +2169,7 @@ class PerformanceEvaluator:
                  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):
+                 weight_col = None, spec_values = None, ascending = None):
         """
         初始化性能评估器。
         
@@ -2225,9 +2225,29 @@ class PerformanceEvaluator:
         self.tree_binning = tree_binning
         self.random_state = random_state
         self.weight_col = weight_col
+        # spec_values: sentinel scores (e.g. -1 for all-missing overrides)
+        # that get their own evaluation bin and are excluded from quantile
+        # edges and ranking metrics. ascending: None keeps every underlying
+        # function's own legacy default; an explicit bool is threaded through
+        # summary/gains/plot and the weighted path uniformly.
+        self.spec_values = list(spec_values) if spec_values else []
+        self.ascending = ascending
         self.datasets = {}
         self.dataset_weight_cols = {}
         self.evaluate_status = None
+
+    def _governed_eval_kwargs(self):
+        """Kwargs to thread spec_values/ascending into underlying eval calls.
+
+        Nothing is passed when unset, so every legacy default stays intact
+        (unweighted summary False, comparison paths True, weighted False).
+        """
+        kwargs = {}
+        if self.spec_values:
+            kwargs["spec_values"] = list(self.spec_values)
+        if self.ascending is not None:
+            kwargs["ascending"] = bool(self.ascending)
+        return kwargs
     
     def add_dataset(self, name, data, weight_col = None, overwrite = False):
         """
@@ -2351,6 +2371,8 @@ class PerformanceEvaluator:
                         scr_name,
                         weight_col=wc,
                         nbins=self.pct_bins,
+                        ascending=bool(self.ascending) if self.ascending is not None else False,
+                        spec_values=self.spec_values or None,
                     )
                 )
             fnl_df = pd.DataFrame(rows)
@@ -2368,15 +2390,23 @@ class PerformanceEvaluator:
                     if scr_name is None:
                         scr_name = "_mdl_scr"
                         work_data[scr_name] = self.model.predict_proba(work_data.loc[:, self.feature_cols])[:, 1]
-                    payload = {
-                        "y_true": work_data[self.tgt_name],
-                        "y_score": work_data[scr_name],
-                    }
                     resolved_weight = _weighted_eval.resolve_weights(
                         work_data,
                         weight_col=wc,
                         expected_len=len(work_data),
                     )
+                    y_true = work_data[self.tgt_name].to_numpy()
+                    y_score = work_data[scr_name].to_numpy()
+                    if self.spec_values:
+                        keep = ~pd.Series(y_score).isin(self.spec_values).to_numpy()
+                        y_true = y_true[keep]
+                        y_score = y_score[keep]
+                        if resolved_weight is not None:
+                            resolved_weight = np.asarray(resolved_weight)[keep]
+                    payload = {
+                        "y_true": y_true,
+                        "y_score": y_score,
+                    }
                     if resolved_weight is not None:
                         payload["sample_weight"] = resolved_weight
                     eval_datasets[name] = payload
@@ -2445,6 +2475,21 @@ class PerformanceEvaluator:
                 return data[self.scr_name]
             return self.model.predict_proba(data.loc[:, self.feature_cols])[:, 1]
 
+        def _rank_payload(data):
+            """(y_true, y_score) with special sentinel scores removed.
+
+            Sentinels like the all-missing override -1 carry no ordering
+            information: AUC/KS/distribution figures are computed on the
+            non-special rows; their bin-level accounting lives in the gains
+            table via spec_values.
+            """
+            y_true = data[self.tgt_name]
+            y_score = _get_score(data)
+            if not self.spec_values:
+                return y_true, y_score
+            keep = ~pd.Series(np.asarray(y_score)).isin(self.spec_values).to_numpy()
+            return np.asarray(y_true)[keep], np.asarray(y_score)[keep]
+
         def _get_benchmark_bin_edges():
             if benchmark_dataset is None:
                 return None
@@ -2492,9 +2537,10 @@ class PerformanceEvaluator:
             for name, data in dataset_dict.items():
                 if data is None:
                     continue
+                y_true, y_score = _rank_payload(data)
                 eval_datasets[name] = {
-                    "y_true": data[self.tgt_name],
-                    "y_score": _get_score(data)
+                    "y_true": y_true,
+                    "y_score": y_score
                 }
 
             if len(eval_datasets) == 0:
@@ -2553,7 +2599,8 @@ class PerformanceEvaluator:
                         chi2_p = self.chi2_p,
                         retSummary = True,
                         tree_binning = False if benchmark_bin_edges is not None else self.tree_binning,
-                        random_state = self.random_state
+                        random_state = self.random_state,
+                        **self._governed_eval_kwargs(),
                     )
                 gains_res['index'] = name
                 gains_summ_list.append(gains_res)

{supermodelingfactory-0.6.5 → supermodelingfactory-0.6.7}/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, weight_col = 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, spec_values = None, ascending = 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.6.5 → supermodelingfactory-0.6.7}/Modeling_Tool/Eval/weighted_eval_utils.py

@@ -95,10 +95,18 @@ def calc_pr(y_true, y_score, sample_weight=None):
     )
 
 
-def rank_bins(score, weight, nbins):
+def rank_bins(score, weight, nbins, ascending=False):
+    """Weighted equal-frequency rank bins.
+
+    ``ascending=False`` (default, legacy) sorts scores descending — bin 1 is
+    the highest-score bucket. ``ascending=True`` sorts scores ascending so
+    bin 1 is the lowest-score bucket, matching the unweighted
+    ``gains_ascending=True`` convention.
+    """
     score = np.asarray(score, dtype=float)
     weight = np.ones(len(score), dtype=float) if weight is None else np.asarray(weight, dtype=float)
-    order = np.lexsort((np.arange(len(score)), -score))
+    sort_key = score if ascending else -score
+    order = np.lexsort((np.arange(len(score)), sort_key))
     bins = np.empty(len(score), dtype=int)
     total = float(weight.sum()) or float(len(score)) or 1.0
     cum_weight = np.cumsum(weight[order])
@@ -108,18 +116,35 @@ def rank_bins(score, weight, nbins):
     return bins
 
 
-def get_gains_table(data, dep, score, nbins=10, weight_col=None, weighted_binning=None, **kwargs):
+def _split_special_scores(df, score, spec_values):
+    """Split a frame into (normal, special) rows by exact score membership.
+
+    Special score values (e.g. the all-missing override ``-1``) are business
+    sentinels, not model outputs: they must not participate in quantile
+    binning or ranking metrics.
+    """
+    if not spec_values:
+        return df, None
+    spec_mask = df[score].isin(list(spec_values))
+    if not bool(spec_mask.any()):
+        return df, None
+    return df[~spec_mask], df[spec_mask]
+
+
+def get_gains_table(data, dep, score, nbins=10, weight_col=None, weighted_binning=None,
+                    ascending=False, spec_values=None, **kwargs):
     cols = [dep, score]
     if weight_col is not None and weight_col in data.columns:
         cols.append(weight_col)
     df = data[cols].copy()
+    df, special_df = _split_special_scores(df, score, spec_values)
     weight = resolve_weights(df, weight_col=weight_col, expected_len=len(df))
     if weight is None:
         weight = np.ones(len(df), dtype=float)
 
     y = df[dep].astype(float).to_numpy()
     s = df[score].astype(float).to_numpy()
-    df["_bin_num"] = rank_bins(s, weight, nbins)
+    df["_bin_num"] = rank_bins(s, weight, nbins, ascending=ascending)
     df["_bin_range"] = df["_bin_num"]
     df["_w"] = weight
     df["_bad_w"] = weight * y
@@ -165,13 +190,56 @@ def get_gains_table(data, dep, score, nbins=10, weight_col=None, weighted_binnin
     out["KS_PER_BIN"] = (out["CUM_BAD_PCT"] - out["CUM_GOOD_PCT"]).abs()
     out["KS"] = out["KS_PER_BIN"]
     out["LIFT"] = out["AVG_BAD"] / overall_bad_rate if overall_bad_rate else np.nan
-    out["TRUE_BAD_SHIFT"] = out["AVG_BAD"].shift(1) / out["AVG_BAD"] - 1
+    out["TRUE_BAD_SHIFT"] = (
+        (out["AVG_BAD"].shift(1) / out["AVG_BAD"] - 1)
+        if not ascending
+        else (out["AVG_BAD"] / out["AVG_BAD"].shift(1) - 1)
+    )
     out["RANK_ORDER_BUMP"] = out["TRUE_BAD_SHIFT"].lt(0).astype(int)
     with np.errstate(divide="ignore", invalid="ignore"):
         out["WOE"] = np.log(out["BAD_PCT_IN_EACH_BIN"] / out["GOOD_PCT_IN_EACH_BIN"])
     out["WOE"] = out["WOE"].replace([np.inf, -np.inf], 0).fillna(0)
     out["IV"] = (out["BAD_PCT_IN_EACH_BIN"] - out["GOOD_PCT_IN_EACH_BIN"]) * out["WOE"]
     out["AUC"] = safe_auc(y, s, sample_weight=weight)
+
+    if special_df is not None and len(special_df):
+        # Special sentinel scores (e.g. -1 for all-missing rows) get their own
+        # descriptive rows: never part of quantile edges, cumulative columns,
+        # or ranking metrics (those stay NaN by construction).
+        spec_weight = resolve_weights(special_df, weight_col=weight_col, expected_len=len(special_df))
+        if spec_weight is None:
+            spec_weight = np.ones(len(special_df), dtype=float)
+        grand_total = total_weight + float(np.sum(spec_weight))
+        spec_rows = []
+        for value, part in special_df.groupby(score, sort=True):
+            part_w = resolve_weights(part, weight_col=weight_col, expected_len=len(part))
+            if part_w is None:
+                part_w = np.ones(len(part), dtype=float)
+            part_y = part[dep].astype(float).to_numpy()
+            n_w = float(np.sum(part_w))
+            n_bad = float(np.sum(part_w * part_y))
+            label = f"special:{value}"
+            spec_rows.append(
+                pd.DataFrame(
+                    {
+                        "MIN": [value],
+                        "MAX": [value],
+                        "N": [n_w],
+                        "N_RAW": [int(len(part))],
+                        "PERF_CNT": [n_w],
+                        "N_BAD": [n_bad],
+                        "N_GOOD": [n_w - n_bad],
+                        "AVG_SCORE": [float(value)],
+                        "UNIQUE_SCORE": [1],
+                        "PROP": [n_w / grand_total if grand_total else np.nan],
+                        "AVG_BAD": [n_bad / n_w if n_w else np.nan],
+                        "AVG_GOOD": [(n_w - n_bad) / n_w if n_w else np.nan],
+                    },
+                    index=pd.MultiIndex.from_tuples([(label, label)], names=out.index.names),
+                )
+            )
+        out = pd.concat([out] + spec_rows)
+        out["AUC"] = out["AUC"].iloc[0]
     return out
 
 
@@ -212,32 +280,53 @@ def calc_fixed_pct(y_true, y_score, sample_weight=None, **kwargs):
     return calc_equid_dist(y_true, y_score, sample_weight=sample_weight, **kwargs)
 
 
-def dataset_summary(name, data, tgt_name, scr_name, weight_col=None, nbins=10):
+def dataset_summary(name, data, tgt_name, scr_name, weight_col=None, nbins=10,
+                    ascending=False, spec_values=None):
     weight = resolve_weights(data, weight_col=weight_col, expected_len=len(data))
     y_true = data[tgt_name].to_numpy()
     y_score = data[scr_name].to_numpy()
-    roc_df = calc_roc(y_true, y_score, sample_weight=weight)
-    gains = get_gains_table(data, tgt_name, scr_name, nbins=nbins, weight_col=weight_col)
-    return {
+    # Ranking metrics (AUC/KS/avgScore) are computed on non-special rows only:
+    # sentinel scores like -1 carry no ordering information.
+    rank_data, special_part = _split_special_scores(data, scr_name, spec_values)
+    rank_weight = resolve_weights(rank_data, weight_col=weight_col, expected_len=len(rank_data))
+    rank_true = rank_data[tgt_name].to_numpy()
+    rank_score = rank_data[scr_name].to_numpy()
+    roc_df = calc_roc(rank_true, rank_score, sample_weight=rank_weight)
+    gains = get_gains_table(
+        data, tgt_name, scr_name, nbins=nbins, weight_col=weight_col,
+        ascending=ascending, spec_values=spec_values,
+    )
+    summary = {
         "index": name,
         "dataset": name,
         "DATASET": name,
-        "AUC": safe_auc(y_true, y_score, sample_weight=weight),
+        "AUC": safe_auc(rank_true, rank_score, sample_weight=rank_weight),
         "KS": float(roc_df["KS"].max()) if "KS" in roc_df else np.nan,
         "LIFT": float(gains["LIFT"].max()) if "LIFT" in gains else np.nan,
         "IV": float(gains["IV"].sum()) if "IV" in gains else np.nan,
         "N": float(np.sum(weight)) if weight is not None else float(len(data)),
         "N_RAW": int(len(data)),
         "avgTrue": safe_weighted_average(y_true, weight),
-        "avgScore": safe_weighted_average(y_score, weight),
+        "avgScore": safe_weighted_average(rank_score, rank_weight),
     }
+    if special_part is not None:
+        spec_weight = resolve_weights(special_part, weight_col=weight_col, expected_len=len(special_part))
+        summary["N_SPECIAL"] = (
+            float(np.sum(spec_weight)) if spec_weight is not None else float(len(special_part))
+        )
+        summary["N_SPECIAL_RAW"] = int(len(special_part))
+    return summary
 
 
-def get_perf_summary(train=None, validation=None, oot=None, tgt_name=None, scr_name=None, weight_col=None, nbins=10, **kwargs):
+def get_perf_summary(train=None, validation=None, oot=None, tgt_name=None, scr_name=None, weight_col=None, nbins=10,
+                     ascending=False, spec_values=None, **kwargs):
     rows = []
     for name, data in (("ins", train), ("oos", validation), ("oot", oot)):
         if data is not None:
-            rows.append(dataset_summary(name, data, tgt_name, scr_name, weight_col=weight_col, nbins=nbins))
+            rows.append(dataset_summary(
+                name, data, tgt_name, scr_name, weight_col=weight_col, nbins=nbins,
+                ascending=ascending, spec_values=spec_values,
+            ))
     return pd.DataFrame(rows)
 
 

{supermodelingfactory-0.6.5 → supermodelingfactory-0.6.7}/Modeling_Tool/Feature/Feature_Screen.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import warnings
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Literal, Mapping
@@ -14,9 +15,11 @@ from Modeling_Tool._utils.sentinels import SMF_MISSING_BIN
 
 from .Weighted_Screen import (
     WeightedScreenResult,
+    _DROPPED_DETAIL_COLS,
     _apply_missing_rate_stage,
     _apply_stage_keep,
     _corr_dedup_weighted,
+    _iv_band_keep,
     _legacy_unweighted_screen,
     _psi_from_distributions,
     _resolve_splits,
@@ -37,6 +40,14 @@ _MONOTONE_INIT_KEYS = frozenset({
     "missing_woe",
     "special_values",
     "bin_label_decimals",
+    "min_bad_count",
+    "min_good_count",
+    "small_bin_policy",
+    "monotone_direction",
+    "reference_target",
+    "direction_conflict_policy",
+    "missing_bin_strategy",
+    "refine_min_n_bins_policy",
 })
 _MONOTONE_FIT_KEYS = frozenset({"chi2_binning", "chi2_p", "chi2_init_size", "n_jobs"})
 
@@ -50,6 +61,7 @@ class FeatureScreenConfig:
     psi_use_woe_bins: bool = False
     iv_enabled: bool = True
     iv_threshold: float = 0.02
+    iv_upper_threshold: float | None = None
     iv_bins: int = 10
     iv_min_bin_prop: float = 0.05
     iv_equal_freq: bool = True
@@ -77,6 +89,28 @@ class FeatureScreenConfig:
     content: float = 1e-6
     precision: int = 5
     min_bin_prop: float = 0.05
+    # --- Post-corr selection gates (G03/G04/G05/G06); all legacy-off ------
+    # G03 group stability (requires SelectionEvidence — FVP only)
+    monthly_iv_min: float | None = None
+    monthly_iv_cv_max: float | None = None
+    direction_consistency_min: float | None = None
+    min_group_n: int | None = None
+    insufficient_group_policy: Literal["keep_warn", "drop", "raise"] = "keep_warn"
+    # G04 multi-target joint gate (requires SelectionEvidence — FVP only)
+    target_rules: Literal["all", "any", "min_pass_count"] | None = None
+    min_pass_count: int | None = None
+    per_target_iv_range: Any = None  # (low, high) or {target: (low, high)}
+    direction_reference_target: str | None = None
+    # G05 hard top-N truncation
+    max_selected_features: int | None = None
+    min_selected_features: int | None = None
+    ranking_metric: str = "iv"
+    tie_breaker: str = "name"
+    # G06 VIF gate (needs the optional statsmodels extra)
+    vif_enabled: bool = False
+    vif_threshold: float = 10.0
+    vif_min_features: int = 2
+    vif_tie_break_metric: str = "iv"
 
 
 def screen_config_from_mapping(
@@ -100,6 +134,9 @@ def screen_config_from_mapping(
         psi_use_woe_bins=bool(cfg.get("psi_use_woe_bins", False)),
         iv_enabled=bool(cfg.get("iv_enabled", True)),
         iv_threshold=float(cfg.get("iv_threshold", 0.02)),
+        iv_upper_threshold=(
+            float(cfg["iv_upper_threshold"]) if cfg.get("iv_upper_threshold") is not None else None
+        ),
         iv_bins=iv_nbins,
         iv_min_bin_prop=float(cfg.get("iv_min_bin_prop", 0.05)),
         iv_equal_freq=bool(cfg.get("iv_equal_freq", True)),
@@ -125,6 +162,23 @@ def screen_config_from_mapping(
         content=float(cfg.get("content", 1e-6)),
         precision=int(cfg.get("precision", 5)),
         min_bin_prop=float(cfg.get("min_bin_prop", cfg.get("iv_min_bin_prop", 0.05))),
+        monthly_iv_min=cfg.get("monthly_iv_min"),
+        monthly_iv_cv_max=cfg.get("monthly_iv_cv_max"),
+        direction_consistency_min=cfg.get("direction_consistency_min"),
+        min_group_n=cfg.get("min_group_n"),
+        insufficient_group_policy=str(cfg.get("insufficient_group_policy", "keep_warn")),  # type: ignore[arg-type]
+        target_rules=cfg.get("target_rules"),
+        min_pass_count=cfg.get("min_pass_count"),
+        per_target_iv_range=cfg.get("per_target_iv_range"),
+        direction_reference_target=cfg.get("direction_reference_target"),
+        max_selected_features=cfg.get("max_selected_features"),
+        min_selected_features=cfg.get("min_selected_features"),
+        ranking_metric=str(cfg.get("ranking_metric", "iv")),
+        tie_breaker=str(cfg.get("tie_breaker", "name")),
+        vif_enabled=bool(cfg.get("vif_enabled", False)),
+        vif_threshold=float(cfg.get("vif_threshold", 10.0)),
+        vif_min_features=int(cfg.get("vif_min_features", 2)),
+        vif_tie_break_metric=str(cfg.get("vif_tie_break_metric", "iv")),
     )
 
 
@@ -213,12 +267,15 @@ def _woe_bins_unweighted_screen(
     config: FeatureScreenConfig,
     *,
     prefit_woe_engine: Any | None = None,
+    selection_evidence: Any | None = None,
 ) -> FeatureScreenResult:
     from Modeling_Tool import CorrelationFilter, PSICalculator, VarExtractionInsights
 
     ins, oos, oot = splits["ins"], splits["oos"], splits["oot"]
     current = list(feature_cols)
     summary_rows = [_summary_row("initial", len(feature_cols), len(current), None, None)]
+    dropped_rows: list[dict] = []
+    stage_tables: dict[str, pd.DataFrame] = {}
     current, missing_rate_table, missing_rate_dropped = _apply_missing_rate_stage(
         ins,
         current,
@@ -228,6 +285,7 @@ def _woe_bins_unweighted_screen(
         on_empty_stage=config.on_empty_stage,
     )
     binner = _resolve_screening_binner(splits, current, target_col, config, prefit_woe_engine)
+    engine_fit_features = list(current)
 
     psi_table = pd.DataFrame(columns=["var", "psi_ins_oos", "psi_ins_oot", "psi_max"])
     if config.psi_enabled:
@@ -290,7 +348,7 @@ def _woe_bins_unweighted_screen(
             )
         if iv is not None and not iv.empty:
             iv_table = iv.rename(columns={"iv": "iv_weighted"})[["var", "iv_weighted", "n_bins", "missing_rate"]]
-            keep = iv.loc[iv["iv"] >= config.iv_threshold, "var"].tolist()
+            keep = _iv_band_keep(iv, "iv", config.iv_threshold, config.iv_upper_threshold, dropped_rows)
             n_before = len(current)
             current = _apply_stage_keep(
                 current, keep, "iv", summary_rows,
@@ -312,7 +370,25 @@ def _woe_bins_unweighted_screen(
         current = cf.remove_highly_correlated(current, max_iterations=config.corr_max_iterations)
         summary_rows.append(_summary_row("corr", n_before, len(current), config.corr_threshold, None))
 
+    from .Screen_Gates import apply_post_corr_gates
+
+    gate_iv_map = (
+        dict(zip(iv_table["var"], iv_table["iv_weighted"])) if not iv_table.empty else {}
+    )
+    current = apply_post_corr_gates(
+        ins, current, config, selection_evidence, gate_iv_map,
+        summary_rows, dropped_rows, stage_tables,
+        weight_col=None, on_empty_stage=config.on_empty_stage,
+    )
+
     summary_rows.append(_summary_row("final", len(feature_cols), len(current), None, None))
+    engine_obj, engine_meta = _screen_engine_payload(
+        binner,
+        fit_features=engine_fit_features,
+        target_col=target_col,
+        weight_col=None,
+        summary_rows=summary_rows,
+    )
     return FeatureScreenResult(
         selected_features=list(current),
         iv_table=iv_table,
@@ -321,6 +397,13 @@ def _woe_bins_unweighted_screen(
         summary=pd.DataFrame(summary_rows),
         missing_rate_table=missing_rate_table,
         missing_rate_dropped=missing_rate_dropped,
+        woe_engine=engine_obj,
+        woe_engine_meta=engine_meta,
+        dropped_detail=(
+            pd.DataFrame(dropped_rows, columns=_DROPPED_DETAIL_COLS)
+            if dropped_rows else pd.DataFrame(columns=_DROPPED_DETAIL_COLS)
+        ),
+        stage_tables=stage_tables,
     )
 
 
@@ -330,6 +413,52 @@ def _bins_to_numpy(bins: Any) -> np.ndarray:
     return np.asarray(bins, dtype=object)
 
 
+def _screen_engine_payload(
+    binner: Any | None,
+    *,
+    fit_features: list[str],
+    target_col: str,
+    weight_col: str | None,
+    summary_rows: list[dict],
+) -> tuple[Any | None, dict[str, Any]]:
+    """Build the (woe_engine, woe_engine_meta) result payload (G00).
+
+    Monotone engines attach as-is — they hold only per-feature bin tables.
+    WOE_Master engines are never attached (they retain the full training
+    frame at ``self.train_data``); their woe_table + metadata travel instead.
+    """
+    if binner is None:
+        return None, {}
+    engine_name = type(binner).__name__
+    meta: dict[str, Any] = {
+        "engine_name": engine_name,
+        "fit_features": list(fit_features),
+        "target_col": target_col,
+        "weight_col": weight_col,
+        "screen_stages": [row.get("stage") for row in summary_rows],
+    }
+    if engine_name == "WOE_Master":
+        from Modeling_Tool.WOE.WOE_Adapter import as_woe_engine
+
+        try:
+            meta["woe_table"] = as_woe_engine(binner).get_woe_table(varlist=list(fit_features))
+        except Exception as exc:
+            meta["woe_table"] = None
+            meta["woe_table_error"] = repr(exc)
+        meta["engine_attached"] = False
+        warnings.warn(
+            "screening WOE engine is a WOE_Master, which retains the full "
+            "training frame — attaching its woe_table and metadata only. "
+            "Use woe_engine='monotone' to get a reusable, serializable "
+            "screening engine on the result.",
+            UserWarning,
+            stacklevel=3,
+        )
+        return None, meta
+    meta["engine_attached"] = True
+    return binner, meta
+
+
 def _weighted_woe_bins_screen(
     splits: dict[str, pd.DataFrame],
     feature_cols: list[str],
@@ -338,6 +467,7 @@ def _weighted_woe_bins_screen(
     config: FeatureScreenConfig,
     *,
     prefit_woe_engine: Any | None = None,
+    selection_evidence: Any | None = None,
 ) -> FeatureScreenResult:
     from Modeling_Tool.WOE.WOE_Adapter import as_woe_engine
 
@@ -346,6 +476,8 @@ def _weighted_woe_bins_screen(
     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)]
+    dropped_rows: list[dict] = []
+    stage_tables: dict[str, pd.DataFrame] = {}
     current, missing_rate_table, missing_rate_dropped = _apply_missing_rate_stage(
         ins,
         current,
@@ -369,6 +501,7 @@ def _weighted_woe_bins_screen(
             categorical_features=config.categorical_features,
         )
     adapter = as_woe_engine(binner)
+    engine_fit_features = list(current)
 
     # Assign fitted bins once per split. PSI and IV both consume these labels;
     # doing it here avoids a full WOE transform for every feature and stage.
@@ -447,7 +580,7 @@ def _weighted_woe_bins_screen(
             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()
+            keep = _iv_band_keep(iv_table, "iv_weighted", config.iv_threshold, config.iv_upper_threshold, dropped_rows)
             n_before = len(current)
             current = _apply_stage_keep(
                 current, keep, "iv", summary_rows,
@@ -479,7 +612,25 @@ def _weighted_woe_bins_screen(
         )
         summary_rows.append(_summary_row("corr", n_before, len(current), config.corr_threshold, weight_col))
 
+    from .Screen_Gates import apply_post_corr_gates
+
+    gate_iv_map = (
+        dict(zip(iv_table["var"], iv_table["iv_weighted"])) if not iv_table.empty else {}
+    )
+    current = apply_post_corr_gates(
+        ins, current, config, selection_evidence, gate_iv_map,
+        summary_rows, dropped_rows, stage_tables,
+        weight_col=weight_col, on_empty_stage=config.on_empty_stage,
+    )
+
     summary_rows.append(_summary_row("final", len(feature_cols), len(current), None, weight_col))
+    engine_obj, engine_meta = _screen_engine_payload(
+        binner,
+        fit_features=engine_fit_features,
+        target_col=target_col,
+        weight_col=weight_col,
+        summary_rows=summary_rows,
+    )
     return FeatureScreenResult(
         selected_features=list(current),
         iv_table=iv_table,
@@ -488,6 +639,13 @@ def _weighted_woe_bins_screen(
         summary=pd.DataFrame(summary_rows),
         missing_rate_table=missing_rate_table,
         missing_rate_dropped=missing_rate_dropped,
+        woe_engine=engine_obj,
+        woe_engine_meta=engine_meta,
+        dropped_detail=(
+            pd.DataFrame(dropped_rows, columns=_DROPPED_DETAIL_COLS)
+            if dropped_rows else pd.DataFrame(columns=_DROPPED_DETAIL_COLS)
+        ),
+        stage_tables=stage_tables,
     )
 
 
@@ -499,6 +657,7 @@ def feature_screen(
     weight_col: str | None = None,
     config: FeatureScreenConfig | None = None,
     prefit_woe_engine: Any | None = None,
+    selection_evidence: Any | None = None,
 ) -> FeatureScreenResult:
     """Run PSI -> IV -> correlation screening on pre-split INS/OOS/OOT frames."""
     cfg = config or FeatureScreenConfig()
@@ -513,6 +672,7 @@ def feature_screen(
                 weight_col,
                 cfg,
                 prefit_woe_engine=prefit_woe_engine,
+                selection_evidence=selection_evidence,
             )
         return _weighted_screen_impl(
             splits,
@@ -524,6 +684,7 @@ def feature_screen(
             psi_compare_splits=list(cfg.psi_compare_splits),
             iv_enabled=cfg.iv_enabled,
             iv_threshold=cfg.iv_threshold,
+            iv_upper_threshold=cfg.iv_upper_threshold,
             iv_bins=cfg.iv_bins,
             min_bin_prop=cfg.min_bin_prop,
             corr_enabled=cfg.corr_enabled,
@@ -538,6 +699,8 @@ def feature_screen(
             prefit_woe_engine=prefit_woe_engine,
             missing_rate_threshold=cfg.missing_rate_threshold,
             missing_rate_ref=cfg.missing_rate_ref,
+            gates_config=cfg,
+            selection_evidence=selection_evidence,
         )
 
     if use_woe_bins or prefit_woe_engine is not None:
@@ -547,6 +710,7 @@ def feature_screen(
             target_col,
             cfg,
             prefit_woe_engine=prefit_woe_engine,
+            selection_evidence=selection_evidence,
         )
 
     return _legacy_unweighted_screen(
@@ -558,6 +722,7 @@ def feature_screen(
         psi_compare_splits=list(cfg.psi_compare_splits),
         iv_enabled=cfg.iv_enabled,
         iv_threshold=cfg.iv_threshold,
+        iv_upper_threshold=cfg.iv_upper_threshold,
         iv_bins=cfg.iv_bins,
         iv_min_bin_prop=cfg.iv_min_bin_prop,
         corr_enabled=cfg.corr_enabled,
@@ -570,6 +735,8 @@ def feature_screen(
         on_empty_stage=cfg.on_empty_stage,
         missing_rate_threshold=cfg.missing_rate_threshold,
         missing_rate_ref=cfg.missing_rate_ref,
+        gates_config=cfg,
+        selection_evidence=selection_evidence,
     )