SuperModelingFactory 0.7.0__tar.gz → 0.7.2__tar.gz

{supermodelingfactory-0.7.0 → supermodelingfactory-0.7.2}/Modeling_Tool/Feature/Feature_Insights.py

@@ -417,14 +417,39 @@ class CorrelationFilter:
         self.correlated_dict = {}
         self.filtered_varlist = []
         self._corr_matrix_cache = None
+        self._corr_matrix_excluded = set()
         self._metric_summary_cache = None
+        self._correlation_decision_trace = []
+
+    def _corr_matrix_frame(self, varlist):
+        # 0.7.0-R1: numeric-subset correlation base. A pure-numeric varlist is
+        # byte-identical to the legacy self.data[varlist].corr() path. Non-numeric
+        # cols (raw Pearson is undefined) are excluded and tracked in
+        # self._corr_matrix_excluded; _high_corr_pairs reindexes them back as NaN
+        # rows/cols so they survive the corr stage instead of crashing the float
+        # cast. At most one raw-value UserWarning per matrix build (no WOE binner).
+        non_numeric = [c for c in varlist if not pd.api.types.is_numeric_dtype(self.data[c])]
+        if not non_numeric:
+            self._corr_matrix_excluded = set()
+            return self.data[varlist]
+        self._corr_matrix_excluded = set(non_numeric)
+        warnings.warn(
+            f"raw-value correlation skips {len(non_numeric)} non-numeric "
+            f"feature(s) {non_numeric[:5]}; they are kept through the corr "
+            f"stage. Set corr_use_woe_bins=True to correlate categorical "
+            f"features via their WOE encoding.",
+            UserWarning,
+            stacklevel=2,
+        )
+        selected = [c for c in varlist if c not in self._corr_matrix_excluded]
+        return self.data[selected]
 
     def _high_corr_pairs(self, varlist):
         if (
             self._corr_matrix_cache is None
-            or not set(varlist).issubset(self._corr_matrix_cache.columns)
+            or not (set(varlist) <= set(self._corr_matrix_cache.columns) | self._corr_matrix_excluded)
         ):
-            self._corr_matrix_cache = self.data[varlist].corr(method=self.method)
+            self._corr_matrix_cache = self._corr_matrix_frame(varlist).corr(method=self.method)
         matrix = self._corr_matrix_cache.reindex(index=varlist, columns=varlist)
         values = matrix.to_numpy(dtype=float)
         row_idx, col_idx = np.triu_indices(len(varlist), k=1)
@@ -522,7 +547,27 @@ class CorrelationFilter:
                 if fnl_selected_var not in selected_varlist:
                     selected_varlist.append(fnl_selected_var)
 
-                removed_varlist += [x for x in correlated_list if x != fnl_selected_var and x not in removed_varlist]
+                newly_removed = [
+                    x for x in correlated_list
+                    if x != fnl_selected_var and x not in removed_varlist
+                ]
+                metric_map = fnl_summary.set_index("var")[name_mapping[base_metric]].to_dict()
+                positions = {name: idx for idx, name in enumerate(varlist)}
+                for dropped_var in newly_removed:
+                    decision_pair = [fnl_selected_var, dropped_var]
+                    decision_pair.sort(key=positions.__getitem__)
+                    var_a, var_b = decision_pair
+                    corr_value = self._corr_matrix_cache.loc[var_a, var_b]
+                    self._correlation_decision_trace.append({
+                        "var_a": var_a,
+                        "var_b": var_b,
+                        "corr": float(corr_value),
+                        "iv_a": float(metric_map.get(var_a, 0.0)),
+                        "iv_b": float(metric_map.get(var_b, 0.0)),
+                        "kept": fnl_selected_var,
+                        "dropped": dropped_var,
+                    })
+                removed_varlist += newly_removed
                 
                 if var not in correlated_dict:
                     correlated_dict[var] = {}
@@ -561,7 +606,8 @@ class CorrelationFilter:
         >>> filter_analyzer = CorrelationFilter(df, 'target')
         >>> keep_vars = filter_analyzer.remove_highly_correlated(['var1', 'var2', 'var3'])
         """
-        self._corr_matrix_cache = self.data[varlist].corr(method=self.method)
+        self._correlation_decision_trace = []
+        self._corr_matrix_cache = self._corr_matrix_frame(varlist).corr(method=self.method)
         self._metric_summary_cache = None
         self._metric_summary(varlist)
         last_keep_list = self.filter_single_iteration(varlist)

{supermodelingfactory-0.7.0 → supermodelingfactory-0.7.2}/Modeling_Tool/Feature/Feature_Screen.py

@@ -19,6 +19,7 @@ from .Weighted_Screen import (
     _apply_missing_rate_stage,
     _apply_stage_keep,
     _corr_dedup_weighted,
+    _corr_filter_dropped_audit,
     _gate_ranking_iv_map,
     _iv_band_keep,
     _legacy_unweighted_screen,
@@ -701,23 +702,42 @@ def _weighted_woe_bins_screen(
 
     corr_dropped = pd.DataFrame(columns=["var_a", "var_b", "corr", "iv_a", "iv_b", "kept", "dropped"])
     if config.corr_enabled and len(current) > 1:
-        corr = _weighted_corr_for_screen(
-            ins, current, w_ins,
-            corr_use_woe_bins=config.corr_use_woe_bins,
-            corr_nan_policy=config.corr_nan_policy,
-            corr_block_size=config.corr_block_size,
-            adapter=adapter,
-            binner=binner,
-        )
-        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,
-        )
+        if bool(np.all(w_ins == w_ins[0])) and config.corr_nan_policy == "pairwise":
+            # Match the unweighted WOE/mixed-basis decision exactly for
+            # constant positive weights, while retaining weighted audit rows.
+            from Modeling_Tool import CorrelationFilter
+
+            corr_input = list(current)
+            use_binner = config.corr_use_woe_bins and binner is not None
+            cf = CorrelationFilter(
+                data=ins[current + [target_col]],
+                dep=target_col,
+                corr_cutpoint=config.corr_threshold,
+                woe_binner=binner if use_binner else None,
+                woe_engine="monotone" if use_binner else "master",
+            )
+            current = cf.remove_highly_correlated(
+                current, max_iterations=config.corr_max_iterations
+            )
+            corr_dropped = _corr_filter_dropped_audit(cf, corr_input, current)
+        else:
+            corr = _weighted_corr_for_screen(
+                ins, current, w_ins,
+                corr_use_woe_bins=config.corr_use_woe_bins,
+                corr_nan_policy=config.corr_nan_policy,
+                corr_block_size=config.corr_block_size,
+                adapter=adapter,
+                binner=binner,
+            )
+            iv_map = dict(zip(iv_table["var"], iv_table["iv_weighted"])) if not iv_table.empty else {}
+            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))
 
     from .Screen_Gates import apply_post_corr_gates

{supermodelingfactory-0.7.0 → supermodelingfactory-0.7.2}/Modeling_Tool/Feature/Screen_Gates.py

@@ -24,6 +24,8 @@ from typing import Any, Callable
 import numpy as np
 import pandas as pd
 
+from Modeling_Tool.Core.sample_weight_utils import resolve_sample_weight
+
 from .Weighted_Screen import _apply_stage_keep, _summary_row
 
 
@@ -118,8 +120,18 @@ def apply_vif_stage(
     basis excludes non-numeric survivors from the matrix — raw string columns
     used to crash statsmodels — keeping them in the selection untouched.
     """
-    if not getattr(config, "vif_enabled", False) or len(current) <= max(2, int(config.vif_min_features)):
-        if getattr(config, "vif_enabled", False) and len(current) <= int(config.vif_min_features):
+    if not getattr(config, "vif_enabled", False):
+        return current
+
+    tie_metric = str(getattr(config, "vif_tie_break_metric", "iv"))
+    if tie_metric != "iv":
+        raise ValueError(
+            "vif_tie_break_metric currently supports only 'iv'; "
+            f"got {tie_metric!r}"
+        )
+
+    if len(current) <= max(2, int(config.vif_min_features)):
+        if len(current) <= int(config.vif_min_features):
             summary_rows.append(_summary_row(
                 "vif", len(current), len(current), config.vif_threshold, weight_col,
                 note="skipped_at_floor",
@@ -139,7 +151,11 @@ def apply_vif_stage(
     analyzer = FeatureSelectionAnalyzer()
     threshold = float(config.vif_threshold)
     floor = int(config.vif_min_features)
-    tie_metric = str(getattr(config, "vif_tie_break_metric", "iv"))
+    sample_weight = (
+        resolve_sample_weight(data=ins, weight_col=weight_col, expected_len=len(ins))
+        if weight_col is not None
+        else None
+    )
     excluded: list[str] = []
     raw_vif_cast_columns: list[str] = []
     if bool(getattr(config, "vif_use_woe_bins", False)):
@@ -209,7 +225,13 @@ def apply_vif_stage(
     for iteration in range(len(current)):
         if len(survivors) <= floor:
             break
-        vif_table = analyzer.compute_vif(base[survivors])
+        if sample_weight is None:
+            # Preserve the historical unweighted call path byte-for-byte.
+            vif_table = analyzer.compute_vif(base[survivors])
+        else:
+            vif_table = analyzer.compute_vif(
+                base[survivors], sample_weight=sample_weight,
+            )
         vif_table = vif_table.sort_values("VIF", ascending=False).reset_index(drop=True)
         worst = vif_table.iloc[0]
         if not np.isfinite(worst["VIF"]) or worst["VIF"] > threshold:

{supermodelingfactory-0.7.0 → supermodelingfactory-0.7.2}/Modeling_Tool/Feature/WOE_Engine_Feature_Patch.py

@@ -467,14 +467,82 @@ class CorrelationFilter:
         self.correlated_dict = {}
         self.filtered_varlist = []
         self._corr_matrix_cache = None
+        self._corr_matrix_excluded = set()
         self._metric_summary_cache = None
+        self._correlation_decision_trace = []
+
+    def _corr_matrix_frame(self, varlist):
+        # 0.7.0-R1: mixed correlation base. Numeric cols stay raw so a
+        # pure-numeric varlist is byte-identical to the legacy .corr() path;
+        # non-numeric cols are WOE-encoded via the screening binner
+        # (corr_use_woe_bins semantics) and renamed back to raw names. Cols that
+        # cannot be encoded go to self._corr_matrix_excluded: they leave the
+        # matrix and survive the corr stage as NaN rows/cols once _high_corr_pairs
+        # reindexes them back in (same as the weighted raw precedent). At most one
+        # UserWarning per matrix build.
+        non_numeric = [c for c in varlist if not pd.api.types.is_numeric_dtype(self.data[c])]
+        if not non_numeric:
+            self._corr_matrix_excluded = set()
+            return self.data[varlist]
+
+        encoded = {}
+        excluded = set()
+        if self.woe_binner is not None:
+            suffix = str(getattr(self.woe_binner, "woe_suffix", "_woe"))
+            try:
+                adapter = as_woe_engine(self.woe_binner, woe_suffix=suffix)
+            except TypeError as exc:
+                raise TypeError(
+                    "corr_use_woe_bins=True routed categorical feature(s) through "
+                    "the screening WOE engine at the corr stage, but the supplied "
+                    "woe_binner is an Unsupported WOE engine. Expected WOE_Master, "
+                    "MonotoneWOEBinner, or WOEEngineAdapter."
+                ) from exc
+            suffix = adapter.woe_suffix
+            try:
+                tx = adapter.transform(self.data.copy(), varlist=non_numeric, suffix=suffix)
+            except (TypeError, ValueError, KeyError, AttributeError, np.linalg.LinAlgError):
+                tx = None
+            for name in non_numeric:
+                column = f"{name}{suffix}"
+                if tx is not None and column in tx.columns and pd.api.types.is_numeric_dtype(tx[column]):
+                    encoded[name] = tx[column].to_numpy()
+                else:
+                    excluded.add(name)
+            if excluded:
+                excluded_list = [c for c in non_numeric if c in excluded]
+                warnings.warn(
+                    f"corr_use_woe_bins=True could not WOE-encode {len(excluded)} "
+                    f"feature(s) {excluded_list[:5]}; they are excluded from the "
+                    f"correlation matrix and kept through the corr stage. Refit the "
+                    f"screening WOE engine to cover them.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+        else:
+            excluded = set(non_numeric)
+            warnings.warn(
+                f"raw-value correlation skips {len(non_numeric)} non-numeric "
+                f"feature(s) {non_numeric[:5]}; they are kept through the corr "
+                f"stage. Set corr_use_woe_bins=True to correlate categorical "
+                f"features via their WOE encoding.",
+                UserWarning,
+                stacklevel=2,
+            )
+
+        self._corr_matrix_excluded = excluded
+        selected = [c for c in varlist if c not in excluded]
+        frame = self.data[selected].copy()
+        for name, values in encoded.items():
+            frame[name] = values
+        return frame
 
     def _high_corr_pairs(self, varlist):
         if (
             self._corr_matrix_cache is None
-            or not set(varlist).issubset(self._corr_matrix_cache.columns)
+            or not (set(varlist) <= set(self._corr_matrix_cache.columns) | self._corr_matrix_excluded)
         ):
-            self._corr_matrix_cache = self.data[varlist].corr(method=self.method)
+            self._corr_matrix_cache = self._corr_matrix_frame(varlist).corr(method=self.method)
         matrix = self._corr_matrix_cache.reindex(index=varlist, columns=varlist)
         values = matrix.to_numpy(dtype=float)
         row_idx, col_idx = np.triu_indices(len(varlist), k=1)
@@ -527,9 +595,21 @@ class CorrelationFilter:
     def calculate_vif(df):
         return _BaseCorrelationFilter.calculate_vif(df)
 
+    def _sync_base_state(self):
+        self.correlated_dict = getattr(self._base, "correlated_dict", {})
+        self.filtered_varlist = getattr(self._base, "filtered_varlist", [])
+        self._corr_matrix_cache = getattr(self._base, "_corr_matrix_cache", None)
+        self._corr_matrix_excluded = getattr(self._base, "_corr_matrix_excluded", set())
+        self._metric_summary_cache = getattr(self._base, "_metric_summary_cache", None)
+        self._correlation_decision_trace = getattr(
+            self._base, "_correlation_decision_trace", [],
+        )
+
     def filter_single_iteration(self, varlist):
         if self.woe_binner is None and self.woe_engine == "master":
-            return self._base.filter_single_iteration(varlist)
+            result = self._base.filter_single_iteration(varlist)
+            self._sync_base_state()
+            return result
 
         name_mapping = {"iv": "iv", "ks": "ks_in_gains"}
         high_corr_var = self._high_corr_pairs(varlist)
@@ -550,7 +630,28 @@ class CorrelationFilter:
             selected = summary.sort_values([name_mapping[self.base_metric.lower()]], ascending=False)["var"].iloc[0]
             if selected not in selected_varlist:
                 selected_varlist.append(selected)
-            removed_varlist += [x for x in correlated_list if x != selected and x not in removed_varlist]
+            newly_removed = [
+                x for x in correlated_list
+                if x != selected and x not in removed_varlist
+            ]
+            metric_name = name_mapping[self.base_metric.lower()]
+            metric_map = summary.set_index("var")[metric_name].to_dict()
+            positions = {name: idx for idx, name in enumerate(varlist)}
+            for dropped_var in newly_removed:
+                decision_pair = [selected, dropped_var]
+                decision_pair.sort(key=positions.__getitem__)
+                var_a, var_b = decision_pair
+                corr_value = self._corr_matrix_cache.loc[var_a, var_b]
+                self._correlation_decision_trace.append({
+                    "var_a": var_a,
+                    "var_b": var_b,
+                    "corr": float(corr_value),
+                    "iv_a": float(metric_map.get(var_a, 0.0)),
+                    "iv_b": float(metric_map.get(var_b, 0.0)),
+                    "kept": selected,
+                    "dropped": dropped_var,
+                })
+            removed_varlist += newly_removed
             self.correlated_dict[var] = {"corr": single_var_corr, "gains": summary}
 
         return selected_varlist + [x for x in varlist if x not in (selected_varlist + removed_varlist)]
@@ -558,11 +659,11 @@ class CorrelationFilter:
     def remove_highly_correlated(self, varlist, max_iterations=10):
         if self.woe_binner is None and self.woe_engine == "master":
             result = self._base.remove_highly_correlated(varlist, max_iterations)
-            self.correlated_dict = getattr(self._base, "correlated_dict", {})
-            self.filtered_varlist = getattr(self._base, "filtered_varlist", [])
+            self._sync_base_state()
             return result
 
-        self._corr_matrix_cache = self.data[varlist].corr(method=self.method)
+        self._correlation_decision_trace = []
+        self._corr_matrix_cache = self._corr_matrix_frame(varlist).corr(method=self.method)
         self._metric_summary_cache = None
         self._metric_summary(varlist)
         last_keep_list = self.filter_single_iteration(varlist)

{supermodelingfactory-0.7.0 → supermodelingfactory-0.7.2}/Modeling_Tool/Feature/Weighted_Screen.py

@@ -578,21 +578,52 @@ def _weighted_corr_for_screen(
     """Build weighted correlation matrix for screening (WOE or raw-value path)."""
     from Modeling_Tool.WOE.WOE_Adapter import as_woe_engine
 
-    if corr_use_woe_bins:
+    non_numeric = [v for v in current if not pd.api.types.is_numeric_dtype(ins[v])]
+    if corr_use_woe_bins and non_numeric:
         eng = adapter if adapter is not None else (as_woe_engine(binner) if binner is not None else None)
         if eng is not None:
             suffix = getattr(eng, "woe_suffix", "_woe")
-            woe_ins = eng.transform(ins, varlist=current)
-            cols = [f"{v}{suffix}" for v in current if f"{v}{suffix}" in woe_ins.columns]
-            if cols:
-                X = woe_ins[cols].to_numpy(dtype=float)
-                return _weighted_pearson_corr_matrix(
-                    X,
+            # Match the unweighted mixed basis: numeric columns stay raw and
+            # only categorical columns are WOE encoded.
+            woe_ins = eng.transform(
+                ins.copy(), varlist=non_numeric, suffix=suffix
+            )
+            encoded: dict[str, np.ndarray] = {}
+            excluded: list[str] = []
+            for name in non_numeric:
+                column = f"{name}{suffix}"
+                if column in woe_ins.columns and pd.api.types.is_numeric_dtype(woe_ins[column]):
+                    encoded[name] = woe_ins[column].to_numpy()
+                else:
+                    excluded.append(name)
+            if excluded:
+                warnings.warn(
+                    f"corr_use_woe_bins=True could not WOE-encode {len(excluded)} "
+                    f"feature(s) {excluded[:5]}; they are excluded from the "
+                    f"correlation matrix and kept through the corr stage. Refit the "
+                    f"screening WOE engine to cover them.",
+                    UserWarning,
+                    stacklevel=2,
+                )
+
+            # Return a matrix on the full current vocabulary. Excluded
+            # categories remain NaN rows/columns so dedup keeps them.
+            corr_full = np.full((len(current), len(current)), np.nan)
+            excluded_set = set(excluded)
+            active = [name for name in current if name not in excluded_set]
+            if active:
+                frame = ins[active].copy()
+                for name, values in encoded.items():
+                    frame[name] = values
+                corr_active = _weighted_pearson_corr_matrix(
+                    frame[active].to_numpy(dtype=float),
                     w_ins,
-                    nan_policy="pairwise",
+                    nan_policy=corr_nan_policy,
                     corr_block_size=corr_block_size,
                 )
-    non_numeric = [v for v in current if not pd.api.types.is_numeric_dtype(ins[v])]
+                active_idx = [current.index(name) for name in active]
+                corr_full[np.ix_(active_idx, active_idx)] = corr_active
+            return corr_full
     if non_numeric:
         # Raw-value Pearson correlation is undefined for categorical/object
         # features. Exclude them from the correlation computation but keep
@@ -804,6 +835,99 @@ def _corr_dedup_weighted(
     return current, pd.DataFrame(dropped_rows)
 
 
+def _corr_filter_dropped_audit(
+    corr_filter: Any,
+    varlist: list[str],
+    kept: list[str],
+) -> pd.DataFrame:
+    """Convert an unweighted CorrelationFilter decision to weighted audit rows.
+
+    Constant positive weights reuse CorrelationFilter for byte-compatible
+    feature ordering and IV tie-breaking.  This adapter preserves the existing
+    seven-column ``corr_dropped`` evidence contract for that weighted call.
+    Each row's ``var_a/var_b`` endpoints are exactly its ``kept/dropped`` pair.
+    For star-shaped groups, ``corr`` may be below the cutoff because it records
+    the group winner versus the indirectly dropped member; another group edge
+    triggered the decision.
+    """
+    columns = ["var_a", "var_b", "corr", "iv_a", "iv_b", "kept", "dropped"]
+    kept_set = set(kept)
+    dropped = [name for name in varlist if name not in kept_set]
+    if not dropped:
+        return pd.DataFrame(columns=columns)
+
+    def _state(name: str):
+        value = getattr(corr_filter, name, None)
+        if value is None:
+            value = getattr(getattr(corr_filter, "_base", None), name, None)
+        return value
+
+    trace = _state("_correlation_decision_trace")
+    rows = []
+    recorded = set()
+    if isinstance(trace, list):
+        for row in trace:
+            if not isinstance(row, dict) or not set(columns).issubset(row):
+                continue
+            dropped_name = row["dropped"]
+            if dropped_name in dropped and dropped_name not in recorded:
+                rows.append({column: row[column] for column in columns})
+                recorded.add(dropped_name)
+    dropped = [name for name in dropped if name not in recorded]
+    if not dropped:
+        return pd.DataFrame(rows, columns=columns)
+
+    # Defensive fallback for third-party/future filters without trace support.
+    matrix = _state("_corr_matrix_cache")
+    if not isinstance(matrix, pd.DataFrame):
+        return pd.DataFrame(rows, columns=columns)
+    matrix = matrix.reindex(index=varlist, columns=varlist)
+
+    metric = _state("_metric_summary_cache")
+    iv_map: dict[str, float] = {}
+    if isinstance(metric, pd.DataFrame) and {"var", "iv"}.issubset(metric.columns):
+        for name, value in zip(metric["var"], metric["iv"]):
+            try:
+                iv_map[str(name)] = float(value)
+            except (TypeError, ValueError):
+                iv_map[str(name)] = 0.0
+
+    positions = {name: idx for idx, name in enumerate(varlist)}
+    threshold = float(getattr(corr_filter, "corr_cutpoint"))
+    for dropped_name in dropped:
+        candidates = []
+        for partner in varlist:
+            if partner == dropped_name:
+                continue
+            value = matrix.loc[dropped_name, partner]
+            if pd.notna(value) and abs(float(value)) > threshold:
+                candidates.append((partner, float(value)))
+        if not candidates:
+            continue
+        partner, corr_value = min(
+            candidates,
+            key=lambda item: (
+                0 if item[0] in kept_set else 1,
+                -abs(item[1]),
+                positions[item[0]],
+            ),
+        )
+        if positions[dropped_name] < positions[partner]:
+            var_a, var_b = dropped_name, partner
+        else:
+            var_a, var_b = partner, dropped_name
+        rows.append({
+            "var_a": var_a,
+            "var_b": var_b,
+            "corr": corr_value,
+            "iv_a": iv_map.get(var_a, 0.0),
+            "iv_b": iv_map.get(var_b, 0.0),
+            "kept": partner,
+            "dropped": dropped_name,
+        })
+    return pd.DataFrame(rows, columns=columns)
+
+
 def _legacy_unweighted_screen(
     splits: dict[str, pd.DataFrame],
     feature_cols: list[str],
@@ -1110,18 +1234,38 @@ def _weighted_screen_impl(
 
     corr_dropped = pd.DataFrame(columns=["var_a", "var_b", "corr", "iv_a", "iv_b", "kept", "dropped"])
     if corr_enabled and len(current) > 1:
-        corr = _weighted_corr_for_screen(
-            ins, current, w_ins,
-            corr_use_woe_bins=corr_use_woe_bins,
-            corr_nan_policy=corr_nan_policy,
-            corr_block_size=corr_block_size,
-            binner=prefit_woe_engine,
-        )
-        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, corr_threshold, corr_max_iterations,
-        )
+        if bool(np.all(w_ins == w_ins[0])) and corr_nan_policy == "pairwise":
+            # Constant positive weights follow the exact unweighted decision
+            # contract. Explicit non-default NaN policies stay on the weighted
+            # implementation so they cannot be silently ignored.
+            from Modeling_Tool import CorrelationFilter
+
+            corr_input = list(current)
+            use_binner = corr_use_woe_bins and prefit_woe_engine is not None
+            cf = CorrelationFilter(
+                data=ins[current + [target_col]],
+                dep=target_col,
+                corr_cutpoint=corr_threshold,
+                woe_binner=prefit_woe_engine if use_binner else None,
+                woe_engine="monotone" if use_binner else "master",
+            )
+            current = cf.remove_highly_correlated(
+                current, max_iterations=corr_max_iterations
+            )
+            corr_dropped = _corr_filter_dropped_audit(cf, corr_input, current)
+        else:
+            corr = _weighted_corr_for_screen(
+                ins, current, w_ins,
+                corr_use_woe_bins=corr_use_woe_bins,
+                corr_nan_policy=corr_nan_policy,
+                corr_block_size=corr_block_size,
+                binner=prefit_woe_engine,
+            )
+            iv_map = dict(zip(iv_table["var"], iv_table["iv_weighted"])) if not iv_table.empty else {}
+            current, corr_dropped = _corr_dedup_weighted(
+                current, corr, iv_map, corr_threshold, corr_max_iterations,
+            )
         summary_rows.append(_summary_row("corr", n_before, len(current), corr_threshold, weight_col))
 
     if gates_config is not None:

{supermodelingfactory-0.7.0 → supermodelingfactory-0.7.2}/Modeling_Tool/Model/LRM_Tool.py

@@ -381,7 +381,13 @@ class FeatureSelectionAnalyzer:
         self.selected_features_ = results.loc[results['selected'], 'feature'].tolist()
         return results
 
-    def compute_vif(self, data, nan_handling="fillna_median", nan_warn_threshold=0.05):
+    def compute_vif(
+        self,
+        data,
+        nan_handling="fillna_median",
+        nan_warn_threshold=0.05,
+        sample_weight=None,
+    ):
         """
         Compute Variance Inflation Factor (VIF) for multicollinearity detection.
 
@@ -389,6 +395,11 @@ class FeatureSelectionAnalyzer:
         ----------
         data : pd.DataFrame
             Feature matrix (should not include target variable)
+        sample_weight : array-like, optional
+            Per-row frequency/sample weights. Constant weights deliberately
+            use the legacy OLS implementation for strict parity. Non-constant
+            weights use WLS auxiliary regressions with the same no-intercept
+            design as variance_inflation_factor.
 
         Returns
         -------
@@ -403,6 +414,11 @@ class FeatureSelectionAnalyzer:
                 "with: pip install \"SuperModelingFactory[stats]\""
             ) from exc
 
+        weight = (
+            resolve_sample_weight(sample_weight=sample_weight, expected_len=len(data))
+            if sample_weight is not None
+            else None
+        )
         work = _prepare_nan_handled_frame(
             data,
             nan_handling=nan_handling,
@@ -410,9 +426,27 @@ class FeatureSelectionAnalyzer:
             context="FeatureSelectionAnalyzer.compute_vif",
         )
         x = work.values
+        if weight is not None and nan_handling == "drop_rows":
+            weight = weight[~data.isna().any(axis=1).to_numpy()]
+            weight = resolve_sample_weight(
+                sample_weight=weight, expected_len=len(work)
+            )
+
+        # Preserve the exact legacy call path for no weight and every
+        # constant-weight vector.
+        if weight is None or bool(np.all(weight == weight[0])):
+            vif_values = [variance_inflation_factor(x, i) for i in range(x.shape[1])]
+        else:
+            from statsmodels.regression.linear_model import WLS
+
+            vif_values = []
+            for i in range(x.shape[1]):
+                others = np.arange(x.shape[1]) != i
+                r_squared = WLS(x[:, i], x[:, others], weights=weight).fit().rsquared
+                vif_values.append(1.0 / (1.0 - r_squared))
         vif_data = pd.DataFrame({
             'feature': work.columns,
-            'VIF': [variance_inflation_factor(x, i) for i in range(x.shape[1])]
+            'VIF': vif_values,
         }).sort_values('VIF', ascending=False).reset_index(drop=True)
 
         return vif_data

{supermodelingfactory-0.7.0 → supermodelingfactory-0.7.2}/Modeling_Tool/Model/LRM_Tool.pyi

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