SuperModelingFactory 0.7.1__tar.gz → 0.7.2__tar.gz

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

@@ -419,6 +419,7 @@ class CorrelationFilter:
         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
@@ -546,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] = {}
@@ -585,6 +606,7 @@ class CorrelationFilter:
         >>> filter_analyzer = CorrelationFilter(df, 'target')
         >>> keep_vars = filter_analyzer.remove_highly_correlated(['var1', 'var2', 'var3'])
         """
+        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)

{supermodelingfactory-0.7.1 → 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.1 → 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.1 → supermodelingfactory-0.7.2}/Modeling_Tool/Feature/WOE_Engine_Feature_Patch.py

@@ -469,6 +469,7 @@ class CorrelationFilter:
         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
@@ -594,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)
@@ -617,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)]
@@ -625,10 +659,10 @@ 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._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)

{supermodelingfactory-0.7.1 → 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.1 → 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.1 → 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:

{supermodelingfactory-0.7.1 → supermodelingfactory-0.7.2}/Modeling_Tool/Pipeline/feature_validation.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import copy
 import gc
 import logging
 import warnings
@@ -470,6 +471,11 @@ class FeatureValidationPipeline:
         """Drop per-batch raw/WOE dataframes that are not needed for final merge."""
         woe_artifacts = dict(result.woe_artifacts or {})
         woe_artifacts["by_target"] = {}
+        for key in (
+            "categorical_transform_stats_by_target",
+            "unseen_category_stats_by_target",
+        ):
+            woe_artifacts[key] = copy.deepcopy(woe_artifacts.get(key, {}))
         return FeatureValidationPipelineResult(
             splits={},
             distribution_summary=result.distribution_summary,
@@ -487,7 +493,7 @@ class FeatureValidationPipeline:
             batch_results=result.batch_results,
             selected_features=list(result.selected_features),
             selection_summary=dict(result.selection_summary or {}),
-            screening_artifact=result.screening_artifact,
+            screening_artifact=None,
             config_snapshot=dict(result.config_snapshot or {}),
         )
 
@@ -730,13 +736,42 @@ class FeatureValidationPipeline:
         artifacts: list[dict[str, Any]],
         batch_metadata: pd.DataFrame,
     ) -> dict[str, Any]:
+        valid = [item for item in artifacts if item]
         return {
             "by_target": {},
-            "woe_table": self._concat_frames([item.get("woe_table", pd.DataFrame()) for item in artifacts if item]),
-            "refine_summary": self._concat_frames([item.get("refine_summary", pd.DataFrame()) for item in artifacts if item]),
+            "woe_table": self._concat_frames([item.get("woe_table", pd.DataFrame()) for item in valid]),
+            "refine_summary": self._concat_frames([item.get("refine_summary", pd.DataFrame()) for item in valid]),
+            "categorical_transform_stats_by_target": self._merge_transform_stats(
+                valid, "categorical_transform_stats_by_target"
+            ),
+            "unseen_category_stats_by_target": self._merge_transform_stats(
+                valid, "unseen_category_stats_by_target"
+            ),
             "batch_metadata": batch_metadata,
         }
 
+    @staticmethod
+    def _merge_transform_stats(
+        artifacts: list[dict[str, Any]], key: str
+    ) -> dict[str, Any]:
+        """Deep-merge target/split/feature audit stats without silent overwrite."""
+        merged: dict[str, Any] = {}
+        for artifact in artifacts:
+            payload = artifact.get(key, {}) or {}
+            for target, split_stats in payload.items():
+                target_out = merged.setdefault(target, {})
+                for split, feature_stats in split_stats.items():
+                    split_out = target_out.setdefault(split, {})
+                    for feature, stats in feature_stats.items():
+                        value = copy.deepcopy(stats)
+                        if feature in split_out and split_out[feature] != value:
+                            raise ValueError(
+                                f"conflicting {key} stats for target={target!r}, "
+                                f"split={split!r}, feature={feature!r}"
+                            )
+                        split_out[feature] = value
+        return merged
+
     @staticmethod
     def _concat_frames(frames: list[pd.DataFrame]) -> pd.DataFrame:
         valid = [df for df in frames if isinstance(df, pd.DataFrame) and not df.empty]
@@ -1247,16 +1282,27 @@ class FeatureValidationPipeline:
                 table = adapter.get_woe_table(fit_features)
                 table.insert(0, "target", target)
                 woe_tables.append(table)
-                woe_splits = {
-                    name: adapter.transform(df, varlist=fit_features)
-                    for name, df in splits.items()
-                }
+                woe_splits = {}
+                categorical_transform_stats_by_split = {}
+                unseen_category_stats_by_split = {}
+                for name, df in splits.items():
+                    woe_splits[name] = adapter.transform(df, varlist=fit_features)
+                    categorical_transform_stats_by_split[name] = copy.deepcopy(
+                        getattr(engine, "_categorical_transform_stats", {})
+                    )
+                    unseen_category_stats_by_split[name] = copy.deepcopy(
+                        getattr(engine, "_unseen_category_stats", {})
+                    )
                 self._plot_woe(engine, adapter, train, fit_features, target)
                 by_target[target] = {
                     "engine": engine,
                     "adapter": adapter,
                     "woe_splits": woe_splits,
                     "features": fit_features,
+                    "categorical_transform_stats_by_split": (
+                        categorical_transform_stats_by_split
+                    ),
+                    "unseen_category_stats_by_split": unseen_category_stats_by_split,
                 }
             except Exception as exc:
                 refine_rows.append({"target": target, "step": "fit", "status": "error", "error": repr(exc)})
@@ -1264,6 +1310,14 @@ class FeatureValidationPipeline:
             "by_target": by_target,
             "woe_table": pd.concat(woe_tables, ignore_index=True) if woe_tables else pd.DataFrame(),
             "refine_summary": pd.DataFrame(refine_rows),
+            "categorical_transform_stats_by_target": {
+                target: copy.deepcopy(item["categorical_transform_stats_by_split"])
+                for target, item in by_target.items()
+            },
+            "unseen_category_stats_by_target": {
+                target: copy.deepcopy(item["unseen_category_stats_by_split"])
+                for target, item in by_target.items()
+            },
         }
 
     def _fit_monotone_binner(