SuperModelingFactory 0.6.7__tar.gz → 0.6.9__tar.gz

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

@@ -19,14 +19,16 @@ from .Weighted_Screen import (
     _apply_missing_rate_stage,
     _apply_stage_keep,
     _corr_dedup_weighted,
+    _gate_ranking_iv_map,
     _iv_band_keep,
     _legacy_unweighted_screen,
     _psi_from_distributions,
     _resolve_splits,
     _summary_row,
+    _unit_weight_floored_iv,
     _weighted_bin_distribution,
     _weighted_corr_for_screen,
-    _weighted_iv_from_assigned_bins,
+    _weighted_iv_detail,
     _weighted_screen_impl,
 )
 
@@ -322,6 +324,7 @@ def _woe_bins_unweighted_screen(
             summary_rows.append(_summary_row("psi", n_before, len(current), config.psi_threshold, None))
 
     iv_table = pd.DataFrame(columns=["var", "iv_weighted", "n_bins", "missing_rate"])
+    iv_floored_map: dict[str, float] = {}
     if config.iv_enabled:
         use_binner = config.iv_use_woe_bins and binner is not None
         vi = VarExtractionInsights(
@@ -348,7 +351,20 @@ 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_band_keep(iv, "iv", config.iv_threshold, config.iv_upper_threshold, dropped_rows)
+            if config.iv_upper_threshold is not None:
+                gate_frame = iv[["var", "iv"]].copy()
+                gate_frame["iv_floored"] = _unit_weight_floored_iv(
+                    ins, list(gate_frame["var"]), target_col,
+                    iv_bins=config.iv_bins, min_bin_prop=config.iv_min_bin_prop,
+                    content=config.content,
+                )
+                iv_floored_map = dict(zip(gate_frame["var"], gate_frame["iv_floored"]))
+                keep = _iv_band_keep(
+                    gate_frame, "iv", config.iv_threshold, config.iv_upper_threshold,
+                    dropped_rows, upper_col="iv_floored",
+                )
+            else:
+                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,
@@ -372,9 +388,7 @@ def _woe_bins_unweighted_screen(
 
     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 {}
-    )
+    gate_iv_map = _gate_ranking_iv_map(iv_table, iv_floored_map, config.iv_upper_threshold)
     current = apply_post_corr_gates(
         ins, current, config, selection_evidence, gate_iv_map,
         summary_rows, dropped_rows, stage_tables,
@@ -553,7 +567,9 @@ def _weighted_woe_bins_screen(
         psi_table = pd.DataFrame(columns=["var", "psi_ins_oos", "psi_ins_oot", "psi_max"])
 
     iv_records: list[dict] = []
+    iv_floored_map: dict[str, float] = {}
     if config.iv_enabled:
+        floor_content = config.content if config.iv_upper_threshold is not None else None
         for var in current:
             if var not in ins.columns or ins[var].nunique(dropna=False) <= 1:
                 continue
@@ -564,12 +580,16 @@ def _weighted_woe_bins_screen(
             else:
                 # Categorical/object feature: IV itself is computed from the
                 # already-assigned bins; ``x`` only feeds np.isfinite() inside
-                # _weighted_iv_from_assigned_bins to derive the weighted
+                # _weighted_iv_detail to derive the weighted
                 # missing rate. A hard float cast crashes on string levels
                 # (e.g. '4.高中'), so encode observed -> 1.0 / missing -> NaN,
                 # matching the notna semantics of _missing_rate_for_series.
                 x_ins = np.where(x_series.notna().to_numpy(), 1.0, np.nan)
-            iv_val, n_b, miss = _weighted_iv_from_assigned_bins(y_ins, w_ins, bins_ins, x_ins)
+            iv_val, n_b, miss, iv_floored = _weighted_iv_detail(
+                y_ins, w_ins, bins_ins, x_ins, content=floor_content,
+            )
+            if floor_content is not None:
+                iv_floored_map[var] = iv_floored
             iv_records.append({
                 "var": var,
                 "iv_weighted": iv_val,
@@ -580,7 +600,15 @@ def _weighted_woe_bins_screen(
             columns=["var", "iv_weighted", "n_bins", "missing_rate"],
         )
         if not iv_table.empty:
-            keep = _iv_band_keep(iv_table, "iv_weighted", config.iv_threshold, config.iv_upper_threshold, dropped_rows)
+            if config.iv_upper_threshold is not None:
+                gate_frame = iv_table[["var", "iv_weighted"]].copy()
+                gate_frame["iv_floored"] = gate_frame["var"].map(iv_floored_map)
+                keep = _iv_band_keep(
+                    gate_frame, "iv_weighted", config.iv_threshold,
+                    config.iv_upper_threshold, dropped_rows, upper_col="iv_floored",
+                )
+            else:
+                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,
@@ -614,9 +642,7 @@ def _weighted_woe_bins_screen(
 
     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 {}
-    )
+    gate_iv_map = _gate_ranking_iv_map(iv_table, iv_floored_map, config.iv_upper_threshold)
     current = apply_post_corr_gates(
         ins, current, config, selection_evidence, gate_iv_map,
         summary_rows, dropped_rows, stage_tables,
@@ -737,6 +763,7 @@ def feature_screen(
         missing_rate_ref=cfg.missing_rate_ref,
         gates_config=cfg,
         selection_evidence=selection_evidence,
+        content=cfg.content,
     )
 
 

{supermodelingfactory-0.6.7 → supermodelingfactory-0.6.9}/Modeling_Tool/Feature/Screen_Gates.py

@@ -27,20 +27,41 @@ import pandas as pd
 from .Weighted_Screen import _apply_stage_keep, _summary_row
 
 
-def point_biserial_direction(x: pd.Series, y: pd.Series) -> int:
+def point_biserial_direction(
+    x: pd.Series, y: pd.Series, sample_weight: np.ndarray | None = None
+) -> int:
     """Sign of the point-biserial association between a numeric feature and a
     binary target: +1 when higher x means higher bad rate (WOE increasing),
     -1 for the opposite, 0 when undefined. The single shared definition of
-    "direction" for G03/G04."""
+    "direction" for G03/G04.
+
+    ``sample_weight`` is positional-aligned with the passed ``x``/``y``
+    (before NaN masking). A class whose total weight is zero — like a class
+    with no rows — and a weighted tie both return 0, mirroring the
+    unweighted NaN/tie semantics."""
     xv = pd.to_numeric(x, errors="coerce")
     yv = pd.to_numeric(y, errors="coerce")
     mask = xv.notna() & yv.notna()
     if not bool(mask.any()):
         return 0
-    xv = xv[mask]
-    yv = yv[mask]
-    mean_bad = xv[yv == 1].mean()
-    mean_good = xv[yv == 0].mean()
+    if sample_weight is None:
+        xv = xv[mask]
+        yv = yv[mask]
+        mean_bad = xv[yv == 1].mean()
+        mean_good = xv[yv == 0].mean()
+    else:
+        mask_np = mask.to_numpy()
+        w = np.asarray(sample_weight, dtype=float)[mask_np]
+        xa = xv.to_numpy(dtype=float)[mask_np]
+        ya = yv.to_numpy(dtype=float)[mask_np]
+        w_bad = w[ya == 1]
+        w_good = w[ya == 0]
+        mean_bad = (
+            float(np.average(xa[ya == 1], weights=w_bad)) if w_bad.sum() > 0 else float("nan")
+        )
+        mean_good = (
+            float(np.average(xa[ya == 0], weights=w_good)) if w_good.sum() > 0 else float("nan")
+        )
     if pd.isna(mean_bad) or pd.isna(mean_good) or mean_bad == mean_good:
         return 0
     return 1 if mean_bad > mean_good else -1

{supermodelingfactory-0.6.7 → supermodelingfactory-0.6.9}/Modeling_Tool/Feature/Weighted_Screen.py

@@ -72,24 +72,94 @@ def _iv_band_keep(
     upper: float | None,
     dropped_rows: list | None = None,
     var_col: str = "var",
+    upper_col: str | None = None,
 ) -> list[str]:
     """IV band gate (G02): keep lower <= iv, and iv <= upper when an upper
     threshold is set. Upper-bound drops (suspiciously high IV — leakage /
-    look-ahead candidates) are recorded in dropped_rows."""
+    look-ahead candidates) are recorded in dropped_rows.
+
+    ``upper_col`` names an alternative column for the upper test only. The
+    degenerate-guarded IV excludes class-pure bins, so near-perfect
+    separators — the exact features the upper band targets — understate it;
+    callers pass a zero-cell-floored IV here while the lower band and the
+    reported table keep the legacy column. Rows with NaN in ``upper_col``
+    fall back to ``iv_col``."""
     keep_mask = iv_frame[iv_col] >= lower
     if upper is not None:
-        above = iv_frame[iv_frame[iv_col] > upper]
-        keep_mask &= iv_frame[iv_col] <= upper
+        if upper_col is not None and upper_col in iv_frame.columns:
+            gate = iv_frame[upper_col].where(iv_frame[upper_col].notna(), iv_frame[iv_col])
+            metric = upper_col
+        else:
+            gate = iv_frame[iv_col]
+            metric = "iv"
+        above = iv_frame[gate > upper]
+        keep_mask &= gate <= upper
         if dropped_rows is not None:
-            for _, row in above.iterrows():
+            for idx, row in above.iterrows():
                 dropped_rows.append({
-                    "var": row[var_col], "stage": "iv", "metric": "iv",
-                    "value": float(row[iv_col]), "threshold": upper,
+                    "var": row[var_col], "stage": "iv", "metric": metric,
+                    "value": float(gate.loc[idx]), "threshold": upper,
                     "reason": "iv_above_upper",
                 })
     return iv_frame.loc[keep_mask, var_col].tolist()
 
 
+def _unit_weight_floored_iv(
+    ins: pd.DataFrame,
+    varlist: list[str],
+    target_col: str,
+    *,
+    iv_bins: int,
+    min_bin_prop: float,
+    content: float,
+    precision: int = 5,
+) -> list[float]:
+    """Zero-cell-floored equal-freq IV with unit weights, for the G02 upper
+    band on the gains-table path: its filliv convention zeroes pure bins and
+    would otherwise understate hard leakage the same way the degenerate
+    guard does. Non-numeric columns return NaN so the gate falls back to
+    the reported IV. The remainder-IV warning is suppressed — only the
+    floored diagnostic is consumed here."""
+    y = ins[target_col].astype(float).to_numpy()
+    w = np.ones(len(ins), dtype=float)
+    out: list[float] = []
+    for var in varlist:
+        if var not in ins.columns or not pd.api.types.is_numeric_dtype(ins[var]):
+            out.append(float("nan"))
+            continue
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", UserWarning)
+            _, _, _, floored = _weighted_iv_for_var(
+                ins[var].to_numpy(dtype=float), y, w, iv_bins, min_bin_prop, precision,
+                var_name=var, on_null_edges="silent", content=content,
+            )
+        out.append(floored)
+    return out
+
+
+def _gate_ranking_iv_map(
+    iv_table: pd.DataFrame,
+    iv_floored_map: dict[str, float] | None,
+    iv_upper_threshold: float | None,
+) -> dict[str, float]:
+    """Ranking metric for the post-corr gates (G05 truncation, G06 VIF
+    tie-break). Legacy basis is the degenerate-GUARDED reported IV. When the
+    G02 upper band is armed, leaks are already dropped by the band, so
+    ranking survivors on the guarded IV would understate legit features with
+    class-pure bins; substitute the zero-cell-floored IV where finite (NaN
+    floored values — e.g. non-numeric columns on the unit-weight diagnostic —
+    keep the guarded value, matching _iv_band_keep's fallback). upper=None
+    returns the legacy map verbatim."""
+    gate_iv_map = (
+        dict(zip(iv_table["var"], iv_table["iv_weighted"])) if not iv_table.empty else {}
+    )
+    if iv_upper_threshold is not None:
+        for var, floored in (iv_floored_map or {}).items():
+            if var in gate_iv_map and np.isfinite(floored):
+                gate_iv_map[var] = float(floored)
+    return gate_iv_map
+
+
 def _resolve_splits(data: pd.DataFrame, split_col: str) -> dict[str, pd.DataFrame]:
     if split_col not in data.columns:
         raise KeyError(f"Missing split_col {split_col!r}")
@@ -209,7 +279,7 @@ 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(
+def _weighted_iv_detail(
     y: np.ndarray,
     w: np.ndarray,
     bins: np.ndarray,
@@ -217,7 +287,21 @@ def _weighted_iv_from_assigned_bins(
     *,
     var_name: str | None = None,
     include_missing_bin: bool = False,
-) -> tuple[float, int, float]:
+    content: float | None = None,
+) -> tuple[float, int, float, float]:
+    """Weighted IV plus an optional zero-cell-floored variant.
+
+    The reported IV (first element) excludes class-degenerate bins via
+    iv_guard. That is right for the *lower* informativeness bound, but it
+    understates IV for near-perfectly separating features: a pure bin
+    carries the strongest possible signal yet contributes nothing, so the
+    exact leakage candidates iv_upper_threshold (G02) exists to catch sail
+    under the band. When ``content`` is given, the fourth element floors
+    each bin's class shares at ``content`` (the same floor the PSI path
+    uses) so pure bins contribute a large finite term, matching the
+    WOE-engine convention; features with no degenerate bins get
+    iv_floored == iv. When ``content`` is None the fourth element is NaN.
+    """
     included = np.ones(len(bins), dtype=bool)
     if not include_missing_bin:
         included &= bins != _MISSING_BIN
@@ -225,9 +309,10 @@ def _weighted_iv_from_assigned_bins(
     total_good = float(np.sum(w[included] * (1.0 - y[included])))
     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
+        return 0.0, 0, missing_rate, (0.0 if content is not None else float("nan"))
 
     iv = 0.0
+    iv_floored = 0.0 if content is not None else float("nan")
     n_bins = 0
     n_contributing_bins = 0
     n_degenerate = 0
@@ -238,7 +323,13 @@ def _weighted_iv_from_assigned_bins(
         m = bins == b
         bad_w = float(np.sum(w[m] * y[m]))
         good_w = float(np.sum(w[m] * (1.0 - y[m])))
-        contrib, is_degenerate = iv_guard(bad_w / total_bad, good_w / total_good)
+        bad_share = bad_w / total_bad
+        good_share = good_w / total_good
+        contrib, is_degenerate = iv_guard(bad_share, good_share)
+        if content is not None:
+            floor_bad = max(bad_share, content)
+            floor_good = max(good_share, content)
+            iv_floored += float((floor_bad - floor_good) * np.log(floor_bad / floor_good))
         if is_degenerate:
             n_degenerate += 1
             continue
@@ -254,7 +345,7 @@ def _weighted_iv_from_assigned_bins(
                 stacklevel=2,
             )
         missing_rate = 1.0 - float(np.sum(w[np.isfinite(x)])) / float(np.sum(w) or 1.0)
-        return 0.0, 0, missing_rate
+        return 0.0, 0, missing_rate, iv_floored
 
     if n_degenerate:
         prefix = f"{var_name}: " if var_name else ""
@@ -265,7 +356,22 @@ def _weighted_iv_from_assigned_bins(
             stacklevel=2,
         )
     missing_rate = 1.0 - float(np.sum(w[np.isfinite(x)])) / float(np.sum(w) or 1.0)
-    return float(iv), n_bins, missing_rate
+    return float(iv), n_bins, missing_rate, iv_floored
+
+
+def _weighted_iv_from_assigned_bins(
+    y: np.ndarray,
+    w: np.ndarray,
+    bins: np.ndarray,
+    x: np.ndarray,
+    *,
+    var_name: str | None = None,
+    include_missing_bin: bool = False,
+) -> tuple[float, int, float]:
+    iv, n_bins, missing_rate, _ = _weighted_iv_detail(
+        y, w, bins, x, var_name=var_name, include_missing_bin=include_missing_bin,
+    )
+    return iv, n_bins, missing_rate
 
 
 def _weighted_iv_for_var(
@@ -279,16 +385,18 @@ def _weighted_iv_for_var(
     var_name: str | None = None,
     include_missing_bin: bool = False,
     on_null_edges: Literal["raise", "warn_and_zero", "silent"] = "raise",
-) -> tuple[float, int, float]:
+    content: float | None = None,
+) -> tuple[float, int, float, float]:
     edges = _weighted_equal_freq_edges(x, w, n_bins, min_bin_prop, precision=precision)
     bins = _assign_bins(x, edges, name=var_name, on_null_edges=on_null_edges)
-    return _weighted_iv_from_assigned_bins(
+    return _weighted_iv_detail(
         y,
         w,
         bins,
         x,
         var_name=var_name,
         include_missing_bin=include_missing_bin,
+        content=content,
     )
 
 
@@ -721,6 +829,7 @@ def _legacy_unweighted_screen(
     missing_rate_ref: Any = None,
     gates_config: Any | None = None,
     selection_evidence: Any | None = None,
+    content: float = 1e-6,
 ) -> WeightedScreenResult:
     from Modeling_Tool import CorrelationFilter, PSICalculator, VarExtractionInsights
 
@@ -772,6 +881,7 @@ def _legacy_unweighted_screen(
             summary_rows.append(_summary_row("psi", n_before, len(current), psi_threshold, None))
 
     iv_table = pd.DataFrame(columns=["var", "iv_weighted", "n_bins", "missing_rate"])
+    iv_floored_map: dict[str, float] = {}
     if iv_enabled:
         vi = VarExtractionInsights(
             data=ins,
@@ -794,7 +904,19 @@ def _legacy_unweighted_screen(
                 plot_path=plot_path,
             )
         iv_table = iv.rename(columns={"iv": "iv_weighted"})[["var", "iv_weighted", "n_bins", "missing_rate"]]
-        keep = _iv_band_keep(iv, "iv", iv_threshold, iv_upper_threshold, dropped_rows)
+        if iv_upper_threshold is not None:
+            gate_frame = iv[["var", "iv"]].copy()
+            gate_frame["iv_floored"] = _unit_weight_floored_iv(
+                ins, list(gate_frame["var"]), target_col,
+                iv_bins=iv_bins, min_bin_prop=iv_min_bin_prop, content=content,
+            )
+            iv_floored_map = dict(zip(gate_frame["var"], gate_frame["iv_floored"]))
+            keep = _iv_band_keep(
+                gate_frame, "iv", iv_threshold, iv_upper_threshold, dropped_rows,
+                upper_col="iv_floored",
+            )
+        else:
+            keep = _iv_band_keep(iv, "iv", iv_threshold, iv_upper_threshold, dropped_rows)
         n_before = len(current)
         current = _apply_stage_keep(
             current, keep, "iv", summary_rows,
@@ -816,9 +938,7 @@ def _legacy_unweighted_screen(
     if gates_config is not 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 {}
-        )
+        gate_iv_map = _gate_ranking_iv_map(iv_table, iv_floored_map, iv_upper_threshold)
         current = apply_post_corr_gates(
             ins, current, gates_config, selection_evidence, gate_iv_map,
             summary_rows, dropped_rows, stage_tables,
@@ -941,11 +1061,13 @@ def _weighted_screen_impl(
         psi_table = pd.DataFrame(columns=["var", "psi_ins_oos", "psi_ins_oot", "psi_max"])
 
     iv_records: list[dict] = []
+    iv_floored_map: dict[str, float] = {}
     if iv_enabled:
+        floor_content = content if iv_upper_threshold is not None else None
         for var in current:
             if var not in ins.columns or ins[var].nunique(dropna=False) <= 1:
                 continue
-            iv_val, n_b, miss = _weighted_iv_for_var(
+            iv_val, n_b, miss, iv_floored = _weighted_iv_for_var(
                 ins[var].to_numpy(dtype=float),
                 y_ins,
                 w_ins,
@@ -953,7 +1075,10 @@ def _weighted_screen_impl(
                 min_bin_prop,
                 precision,
                 var_name=var,
+                content=floor_content,
             )
+            if floor_content is not None:
+                iv_floored_map[var] = iv_floored
             iv_records.append({
                 "var": var,
                 "iv_weighted": iv_val,
@@ -964,7 +1089,15 @@ def _weighted_screen_impl(
             columns=["var", "iv_weighted", "n_bins", "missing_rate"],
         )
         if not iv_table.empty:
-            keep = _iv_band_keep(iv_table, "iv_weighted", iv_threshold, iv_upper_threshold, dropped_rows)
+            if iv_upper_threshold is not None:
+                gate_frame = iv_table[["var", "iv_weighted"]].copy()
+                gate_frame["iv_floored"] = gate_frame["var"].map(iv_floored_map)
+                keep = _iv_band_keep(
+                    gate_frame, "iv_weighted", iv_threshold, iv_upper_threshold,
+                    dropped_rows, upper_col="iv_floored",
+                )
+            else:
+                keep = _iv_band_keep(iv_table, "iv_weighted", iv_threshold, iv_upper_threshold, dropped_rows)
             n_before = len(current)
             current = _apply_stage_keep(
                 current, keep, "iv", summary_rows,
@@ -994,9 +1127,7 @@ def _weighted_screen_impl(
     if gates_config is not 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 {}
-        )
+        gate_iv_map = _gate_ranking_iv_map(iv_table, iv_floored_map, iv_upper_threshold)
         current = apply_post_corr_gates(
             ins, current, gates_config, selection_evidence, gate_iv_map,
             summary_rows, dropped_rows, stage_tables,

{supermodelingfactory-0.6.7 → supermodelingfactory-0.6.9}/Modeling_Tool/Pipeline/credit_model.py

@@ -892,8 +892,18 @@ class CreditModelPipeline:
                 },
                 cfg.monotone_woe_params,
             )
+            # fit()-only kwargs must not reach MonotoneWOEBinner.__init__ —
+            # n_jobs / chi2_p / chi2_init_size in monotone_woe_params used to
+            # raise TypeError on this self-fit path (the screening-side
+            # fit_screening_woe_engine already splits init vs fit keys).
+            fit_kwargs = {
+                key: params.pop(key)
+                for key in ("chi2_binning", "chi2_p", "chi2_init_size", "n_jobs")
+                if key in params
+            }
+            fit_kwargs["chi2_binning"] = bool(fit_kwargs.get("chi2_binning", False))
             binner = MonotoneWOEBinner(**params)
-            binner.fit(fit_ins, chi2_binning=bool(cfg.monotone_woe_params.get("chi2_binning", False)))
+            binner.fit(fit_ins, **fit_kwargs)
             if cfg.write_outputs and cfg.plot_outputs:
                 binner.plot_woe_graph(graph_path=str(Path(cfg.output_dir) / "figs" / "mono_woe"))
             adapter = as_woe_engine(binner, woe_suffix=woe_suffix)

{supermodelingfactory-0.6.7 → supermodelingfactory-0.6.9}/Modeling_Tool/Pipeline/feature_validation.py

@@ -1447,12 +1447,29 @@ class FeatureValidationPipeline:
         return adapter.assign_bins_frame(data, usable)
 
     @staticmethod
-    def _evidence_iv(bins: np.ndarray, target_values: np.ndarray) -> float:
+    def _evidence_iv(
+        bins: np.ndarray,
+        target_values: np.ndarray,
+        sample_weight: np.ndarray | None = None,
+    ) -> float:
         """Same WOE/IV formula as _ivks_from_assigned_bins_grouped, minus the
-        iv_cut/min_group_size report filters (gates need unfiltered evidence)."""
+        iv_cut/min_group_size report filters (gates need unfiltered evidence).
+
+        ``sample_weight`` (positional-aligned with ``bins``) switches counts
+        to weighted mass so gate evidence matches the weighted modeling
+        basis; None reproduces the unweighted arithmetic exactly. Weights are
+        expected on frequency scale (e.g. FT weights): the max(total, 1.0)
+        floors are kept verbatim, so a zero-mass class or slice degrades to
+        iv == 0.0 (never NaN) and sub-unit total mass is damped — both err
+        toward dropping under a lower IV floor."""
         bin_codes, _ = pd.factorize(bins, sort=False)
-        counts = np.bincount(bin_codes).astype(float)
-        bad = np.bincount(bin_codes, weights=target_values)
+        if sample_weight is None:
+            counts = np.bincount(bin_codes).astype(float)
+            bad = np.bincount(bin_codes, weights=target_values)
+        else:
+            w = np.asarray(sample_weight, dtype=float)
+            counts = np.bincount(bin_codes, weights=w)
+            bad = np.bincount(bin_codes, weights=w * np.asarray(target_values, dtype=float))
         good = counts - bad
         bad_pct = bad / max(float(bad.sum()), 1.0)
         good_pct = good / max(float(good.sum()), 1.0)
@@ -1467,7 +1484,12 @@ class FeatureValidationPipeline:
         screen_cfg: Any,
     ) -> Any | None:
         """Lazy G03/G04 evidence closures over INS, priced only on the
-        post-corr survivor set the gates hand them."""
+        post-corr survivor set the gates hand them.
+
+        Evidence IVs and directions respect ``cfg.weight_col`` so gate
+        decisions share the weighted modeling basis; the ``n`` column stays a
+        RAW observation count (min_group_n gauges statistical sufficiency,
+        which weights do not add to)."""
         cfg = self.config
         group_gates_on = any(
             getattr(screen_cfg, name, None) is not None
@@ -1483,6 +1505,13 @@ class FeatureValidationPipeline:
 
         ins = splits["ins"]
         primary = target_cols[0]
+        w_ins = None
+        if cfg.weight_col:
+            from Modeling_Tool.Core.sample_weight_utils import resolve_sample_weight
+
+            w_ins = resolve_sample_weight(
+                data=ins, weight_col=cfg.weight_col, expected_len=len(ins)
+            )
         group_dims = list(cfg.selection_group_dims or [])
         if group_gates_on:
             if not group_dims:
@@ -1498,7 +1527,9 @@ class FeatureValidationPipeline:
                 )
 
         def per_group_iv_fn(features: list[str]) -> pd.DataFrame:
-            data = ins[ins[primary].notna()]
+            obs_mask = ins[primary].notna()
+            data = ins[obs_mask]
+            w_data = w_ins[obs_mask.to_numpy()] if w_ins is not None else None
             bins_frame = self._evidence_bins_frame(data, features, primary, woe_artifacts)
             if bins_frame is None:
                 raise ValueError(
@@ -1514,6 +1545,7 @@ class FeatureValidationPipeline:
                     if isinstance(group_value, tuple) else str(group_value)
                 )
                 y_g = y[positions]
+                w_g = w_data[positions] if w_data is not None else None
                 sub = data.iloc[positions]
                 for var in features:
                     if var not in bins_frame.columns:
@@ -1524,15 +1556,18 @@ class FeatureValidationPipeline:
                         "var": var,
                         "group": label,
                         "n": int(len(positions)),
-                        "iv": self._evidence_iv(bins, y_g),
-                        "direction": point_biserial_direction(sub[var], sub[primary]),
+                        "iv": self._evidence_iv(bins, y_g, sample_weight=w_g),
+                        "direction": point_biserial_direction(
+                            sub[var], sub[primary], sample_weight=w_g
+                        ),
                     })
             return pd.DataFrame(rows, columns=["var", "group", "n", "iv", "direction"])
 
         def per_target_fn(features: list[str]) -> pd.DataFrame:
             rows: list[dict] = []
             for target in target_cols:
-                data = ins[ins[target].notna()]
+                obs_mask = ins[target].notna()
+                data = ins[obs_mask]
                 if not len(data):
                     rows.extend(
                         {"var": var, "target": target, "iv": np.nan,
@@ -1540,13 +1575,16 @@ class FeatureValidationPipeline:
                         for var in features
                     )
                     continue
+                w_t = w_ins[obs_mask.to_numpy()] if w_ins is not None else None
                 bins_frame = self._evidence_bins_frame(data, features, target, woe_artifacts)
                 y = data[target].astype(int).to_numpy()
                 for var in features:
                     if bins_frame is None or var not in bins_frame.columns:
                         rows.append({
                             "var": var, "target": target, "iv": np.nan,
-                            "direction": point_biserial_direction(data[var], data[target])
+                            "direction": point_biserial_direction(
+                                data[var], data[target], sample_weight=w_t
+                            )
                             if var in data.columns else 0,
                             "status": "engine_missing",
                         })
@@ -1556,8 +1594,10 @@ class FeatureValidationPipeline:
                     rows.append({
                         "var": var,
                         "target": target,
-                        "iv": self._evidence_iv(bins, y),
-                        "direction": point_biserial_direction(data[var], data[target]),
+                        "iv": self._evidence_iv(bins, y, sample_weight=w_t),
+                        "direction": point_biserial_direction(
+                            data[var], data[target], sample_weight=w_t
+                        ),
                         "status": "ok",
                     })
             return pd.DataFrame(rows, columns=["var", "target", "iv", "direction", "status"])
@@ -1627,6 +1667,7 @@ class FeatureValidationPipeline:
             "vif_enabled": screen_cfg.vif_enabled,
             "vif_threshold": screen_cfg.vif_threshold,
             "selection_group_dims": list(cfg.selection_group_dims or []),
+            "evidence_weight_col": cfg.weight_col,
         })
         selection_summary = {
             "initial_features": list(new_features),