SuperModelingFactory 0.5.8__tar.gz → 0.5.10__tar.gz

{supermodelingfactory-0.5.8 → supermodelingfactory-0.5.10}/Modeling_Tool/Core/Binning_Tool.py

@@ -706,6 +706,46 @@ def get_bin_range(edges, precision = 5, ascending = False, left_sign = '(', righ
     return res
 
 
+def _materialize_bin_columns(data, binned, bin_range_list, bin_num_col, bin_range_col):
+    """Attach categorical bin numbers and labels without Python row callbacks."""
+    codes = binned.cat.codes.to_numpy(dtype=np.intp, copy=False)
+    range_values = np.empty(len(codes), dtype=object)
+    range_values[:] = np.nan
+    valid = codes >= 0
+    if valid.any():
+        labels = np.asarray(bin_range_list, dtype=object)
+        if codes[valid].max() >= len(labels):
+            raise ValueError("Binning category codes do not match bin range labels")
+        range_values[valid] = np.take(labels, codes[valid])
+
+    data[bin_num_col] = binned.astype(object)
+    data[bin_range_col] = range_values
+    return data
+
+
+def _parse_bin_range_bounds(data, col="_bin_range"):
+    """Parse interval labels into numeric left and right bounds vectorially."""
+    if col not in data.columns:
+        raise KeyError(f"Column {col!r} is not present in the bin mapping table")
+
+    ranges = data[col].astype("string").str.strip()
+    bounds = ranges.str.extract(
+        r"^[\[\(]\s*([^,]+?)\s*,\s*([^\]\)]+?)\s*[\]\)]$",
+        expand=True,
+    )
+    invalid = bounds.isna().any(axis=1)
+    if invalid.any():
+        examples = ranges.loc[invalid].dropna().head(3).tolist()
+        raise ValueError(f"Unable to parse bin range labels in {col!r}: {examples}")
+
+    try:
+        left = bounds.iloc[:, 0].str.strip().astype(float).to_numpy()
+        right = bounds.iloc[:, 1].str.strip().astype(float).to_numpy()
+    except (TypeError, ValueError) as exc:
+        raise ValueError(f"Bin range column {col!r} contains non-numeric bounds") from exc
+    return left, right
+
+
 def get_bin_range_list(data, col = "_bin_range"):
     """
     将分箱区间字符串列转换为边界值列表。
@@ -730,21 +770,8 @@ def get_bin_range_list(data, col = "_bin_range"):
     >>> unique_range = get_bin_range_list(data, col="bin_range")
     """
     
-    data["bin_value_list"] = data[col].apply(lambda x: x.replace("[", "")\
-                                                                  .replace("]", "")\
-                                                                  .replace("(", "")\
-                                                                  .replace(")", "")\
-                                                      .split(","))
-    bin_range = [np.inf if v.strip() == 'inf' else -np.inf if v.strip() == '-inf' else float(v.strip()) for x in data["bin_value_list"].tolist() for v in x]
-
-    unique_range = []
-    for x in bin_range:
-        if x not in unique_range:
-            unique_range.append(x)
-
-    unique_range.sort()
-        
-    return unique_range
+    left, right = _parse_bin_range_bounds(data, col=col)
+    return np.unique(np.concatenate([left, right])).tolist()
 
 
 def chi2_auto_binning(df_pvt, max_bins, min_cnt_in_bin, p=0.95):
@@ -1165,9 +1192,8 @@ class Binning:
         bin_num_col = self.bin_colnames[0]
         bin_range_col = self.bin_colnames[1]
         
-        self.data[bin_num_col] = binned.astype(object)
-        self.data[bin_range_col] = self.data[bin_num_col].apply(
-            lambda x: bin_range_list[int(x)] if self.include_missing else bin_range_list[int(x - 1)]
+        self.data = _materialize_bin_columns(
+            self.data, binned, bin_range_list, bin_num_col, bin_range_col
         )
         
         self.result = self.data
@@ -1237,9 +1263,8 @@ class Binning:
         bin_num_col = self.bin_colnames[0]
         bin_range_col = self.bin_colnames[1]
         
-        self.data[bin_num_col] = binned.astype(object)
-        self.data[bin_range_col] = self.data[bin_num_col].apply(
-            lambda x: bin_range_list[int(x)] if self.include_missing else bin_range_list[int(x - 1)]
+        self.data = _materialize_bin_columns(
+            self.data, binned, bin_range_list, bin_num_col, bin_range_col
         )
         
         self.bin_edges = sorted([np.inf if str(x).lower() == 'inf' else -np.inf if str(x).lower() == '-inf' else x for x in bin_edges])
@@ -1385,10 +1410,9 @@ def chi2_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, t
     binned = binning_series
     rename_catlist = [i for i in range(1, len(bin_range_list) + 1)] if not include_missing else [i for i in range(0, len(bin_range_list))]
     binned = binned.cat.rename_categories(rename_catlist)
-    data[bin_num_col] = binned.astype(object)
-#     print(bin_range_list)
-#     print(data[bin_num_col])
-    data[bin_range_col] = data[bin_num_col].apply(lambda x: bin_range_list[int(x)] if include_missing else bin_range_list[int(x - 1)])
+    data = _materialize_bin_columns(
+        data, binned, bin_range_list, bin_num_col, bin_range_col
+    )
     
     fnl_res = data
     
@@ -1399,7 +1423,7 @@ def chi2_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, t
 
 def run_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, include_missing = True, equal_freq = True, 
                 bin_colnames = ("bin_num", "bin_range"), ascending = False, right = True, include_lowest = False, 
-                tree_binning = False, target = None, random_state=42, spec_values = []):
+                tree_binning = False, target = None, random_state=42, spec_values = [], fillna = -999999):
     """
     通用分箱函数，支持等频或等距分箱。
     
@@ -1437,6 +1461,8 @@ def run_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, in
         随机种子
     spec_values : list, default []
         特殊值列表
+    fillna : scalar, default -999999
+        `include_missing=True` 时用于承载缺失值的分箱哨兵。
     
     Returns
     -------
@@ -1481,7 +1507,8 @@ def run_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, in
                                       ascending = ascending,
                                       include_missing = include_missing,
                                       random_state = random_state,
-                                      spec_values = spec_values)
+                                      spec_values = spec_values,
+                                      fillna = fillna)
     
     left_sign='[' if include_lowest else '('
     right_sign=']' if right else ')'
@@ -1489,8 +1516,9 @@ def run_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, in
     
     rename_catlist = [i for i in range(1, len(bin_range_list) + 1)] if not include_missing else [i for i in range(0, len(bin_range_list))]
     binned = binned.cat.rename_categories(rename_catlist)
-    data[bin_num_col] = binned.astype(object)
-    data[bin_range_col] = data[bin_num_col].apply(lambda x: bin_range_list[int(x)] if include_missing else bin_range_list[int(x - 1)])
+    data = _materialize_bin_columns(
+        data, binned, bin_range_list, bin_num_col, bin_range_col
+    )
         
     return data, bin_edges
 

{supermodelingfactory-0.5.8 → supermodelingfactory-0.5.10}/Modeling_Tool/Core/Binning_Tool.pyi

@@ -44,5 +44,5 @@ class Binning:
     def run(self): ...
     def get_result(self, return_edges = True): ...
 def chi2_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, tgt_name = None, include_missing = True, equal_freq = True, bin_colnames = ('_bin_num', '_bin_range'), ascending = True, chi2_p = 0.95, init_equi_bins = 100, fillna = -999999, spec_values = [], init_points = None): ...
-def run_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, include_missing = True, equal_freq = True, bin_colnames = ('bin_num', 'bin_range'), ascending = False, right = True, include_lowest = False, tree_binning = False, target = None, random_state = 42, spec_values = []): ...
+def run_binning(data, column, nbins = 10, precision = 5, min_bin_prop = 0.05, include_missing = True, equal_freq = True, bin_colnames = ('bin_num', 'bin_range'), ascending = False, right = True, include_lowest = False, tree_binning = False, target = None, random_state = 42, spec_values = [], fillna = -999999): ...
 def super_binning(data, score, dep, nbins = 10, precision = 5, min_bin_prop = 0.05, include_missing = True, equal_freq = True, chi2_method = False, chi2_p = 0.95, init_equi_bins = 2000, fillna = -999999, spec_values = [], tree_binning = False, random_state = 42, return_edges = False, ascending = True, bin_colnames = ('_bin_num', '_bin_range')): ...

{supermodelingfactory-0.5.8 → supermodelingfactory-0.5.10}/Modeling_Tool/Core/utils.py

@@ -1688,6 +1688,19 @@ def parse_sql_file(sql_path:str=None,
 
 
 
+def _calc_woe_iv_values(data, bad_pct, good_pct, fillwoe=True, filliv=True):
+    """Calculate WOE and IV together with one vectorized logarithm."""
+    if len(data[bad_pct]) > 0 and len(data[good_pct]) > 0:
+        bad_values = data[bad_pct]
+        good_values = data[good_pct]
+        woe = np.log(bad_values / good_values)
+        iv = (bad_values - good_values) * woe
+    else:
+        woe = 0 if fillwoe else np.nan
+        iv = 0 if filliv else np.nan
+    return woe, iv
+
+
 def calc_woe(data, bad_pct, good_pct, fillwoe=True):
     """
     计算WOE（Weight of Evidence）值。
@@ -1716,15 +1729,7 @@ def calc_woe(data, bad_pct, good_pct, fillwoe=True):
     >>> calc_woe(df, 'bad_pct', 'good_pct')
     """
     
-    if len(data[bad_pct]) > 0 and len(data[good_pct]) > 0:
-        woe = np.log(data[bad_pct] / data[good_pct])
-    else:
-        if fillwoe:
-            woe = 0
-        else:
-            woe = np.nan
-
-    return woe
+    return _calc_woe_iv_values(data, bad_pct, good_pct, fillwoe=fillwoe)[0]
 
 
 def calc_iv(data, bad_pct, good_pct, filliv=True):
@@ -1755,15 +1760,7 @@ def calc_iv(data, bad_pct, good_pct, filliv=True):
     >>> calc_iv(df, 'bad_pct', 'good_pct')
     """
     
-    if len(data[bad_pct]) > 0 and len(data[good_pct]) > 0:
-        iv = (data[bad_pct] - data[good_pct]) * np.log(data[bad_pct] / data[good_pct])
-    else:
-        if filliv:
-            iv = 0
-        else:
-            iv = np.nan
-
-    return iv
+    return _calc_woe_iv_values(data, bad_pct, good_pct, filliv=filliv)[1]
 
 
 def save_model(model, filename):
@@ -2413,9 +2410,13 @@ class WOEIVCalculator:
         -------
         tuple
         """
-        woe = self.calc_woe(fillna)
-        iv = self.calc_iv(fillna)
-        return woe, iv
+        return _calc_woe_iv_values(
+            self.data,
+            self.bad_pct_col,
+            self.good_pct_col,
+            fillwoe=fillna,
+            filliv=fillna,
+        )
 
 
 def get_feature_names(model, model_type=None):

{supermodelingfactory-0.5.8 → supermodelingfactory-0.5.10}/Modeling_Tool/Pipeline/_common.py

@@ -55,6 +55,12 @@ def as_list(value: Any | Iterable[Any] | None, default: list[Any] | None = None)
     return list(value)
 
 
+def normalize_split_values(values: pd.Series) -> pd.Series:
+    """Normalize declared split labels for case-insensitive pipeline routing."""
+    normalized = values.astype("string").str.strip().str.lower()
+    return normalized.mask(normalized.eq(""), pd.NA)
+
+
 def normalize_group_specs(
     value: Any,
     *,

{supermodelingfactory-0.5.8 → supermodelingfactory-0.5.10}/Modeling_Tool/Pipeline/credit_model.py

@@ -446,6 +446,7 @@ class CreditModelPipeline:
             return FeatureScreeningArtifact.from_fvp_result(
                 cfg.feature_validation_result,
                 target_col=cfg.target_col,
+                weight_col=cfg.weight_col,
             )
         return None
 

{supermodelingfactory-0.5.8 → supermodelingfactory-0.5.10}/Modeling_Tool/Pipeline/feature_validation.py

@@ -17,6 +17,7 @@ from ._common import (
     as_list,
     make_dirs,
     normalize_group_specs,
+    normalize_split_values,
     safe_to_csv,
     split_oot_by_flag,
     validate_woe_fit_query_columns,
@@ -132,6 +133,7 @@ class FeatureValidationPipelineResult:
     selected_features: list[str] = field(default_factory=list)
     selection_summary: dict[str, Any] = field(default_factory=dict)
     screening_artifact: Any | None = None
+    config_snapshot: dict[str, Any] = field(default_factory=dict)
 
 
 class FeatureValidationPipeline:
@@ -180,6 +182,12 @@ class FeatureValidationPipeline:
         incumbent_features = self._resolve_incumbent_features(work, new_features)
         target_cols = [col for col in as_list(cfg.target_cols) if col in work.columns]
         self._validate_input(work, new_features, incumbent_features, target_cols)
+        config_snapshot = self._build_config_snapshot(
+            new_features,
+            incumbent_features,
+            target_cols,
+            batch_mode=False,
+        )
 
         output_dir = Path(cfg.output_dir)
         if cfg.write_outputs or cfg.write_excel:
@@ -224,6 +232,7 @@ class FeatureValidationPipeline:
                 incumbent_features=incumbent_features,
                 target_cols=target_cols,
                 woe_artifacts=woe_artifacts,
+                config_snapshot=config_snapshot,
             )
         validation_summary = self._build_validation_summary(
             data=combined,
@@ -270,6 +279,7 @@ class FeatureValidationPipeline:
             selected_features=selected_features,
             selection_summary=selection_summary,
             screening_artifact=screening_artifact,
+            config_snapshot=config_snapshot,
         )
 
     def _resolve_input_type(self, data: pd.DataFrame | str | Path) -> str:
@@ -407,6 +417,7 @@ class FeatureValidationPipeline:
             selected_features=list(result.selected_features),
             selection_summary=dict(result.selection_summary or {}),
             screening_artifact=result.screening_artifact,
+            config_snapshot=dict(result.config_snapshot or {}),
         )
 
     def _validate_batch_config(self, new_features: list[str]) -> None:
@@ -496,6 +507,10 @@ class FeatureValidationPipeline:
         return self._dedupe([col for col in candidates if col and col in header_set])
 
     def _stable_split_labels(self, base_df: pd.DataFrame, splits: dict[str, pd.DataFrame]) -> pd.Series:
+        cfg = self.config
+        if cfg.split_col and cfg.split_col in base_df.columns:
+            return normalize_split_values(base_df[cfg.split_col])
+
         labels = pd.Series("ins", index=base_df.index, dtype=object)
         oos_ids = set(splits.get("oos", pd.DataFrame()).get("_smf_batch_row_id", pd.Series(dtype=int)).tolist())
         oot_ids = set(splits.get("oot", pd.DataFrame()).get("_smf_batch_row_id", pd.Series(dtype=int)).tolist())
@@ -503,6 +518,11 @@ class FeatureValidationPipeline:
         row_ids = base_df["_smf_batch_row_id"]
         labels.loc[row_ids.isin(oos_ids)] = "oos"
         labels.loc[row_ids.isin(unique_oot_ids)] = "oot"
+        for name, frame in splits.items():
+            if name in {"ins", "oos", "oot"}:
+                continue
+            ids = set(frame.get("_smf_batch_row_id", pd.Series(dtype=int)).tolist())
+            labels.loc[row_ids.isin(ids)] = name
         return labels
 
     def _merge_batch_results(
@@ -554,6 +574,12 @@ class FeatureValidationPipeline:
         selected_features = self._dedupe(
             [feat for res in batch_results for feat in as_list(res.selected_features)]
         )
+        config_snapshot = self._build_config_snapshot(
+            new_features,
+            incumbent_features,
+            target_cols,
+            batch_mode=True,
+        )
         selection_summary: dict[str, Any] = {}
         screening_artifact = None
         if self.config.selection_enabled and target_cols:
@@ -561,12 +587,7 @@ class FeatureValidationPipeline:
                 "initial_features": list(new_features),
                 "final_features": selected_features,
                 "target_col": target_cols[0],
-                "config_snapshot": {
-                    "selection_enabled": True,
-                    "selection_params": dict(self.config.selection_params or {}),
-                    "weight_col": self.config.weight_col,
-                    "batch_mode": True,
-                },
+                "config_snapshot": config_snapshot,
             }
             if selected_features:
                 from .screening_artifact import FeatureScreeningArtifact
@@ -619,6 +640,7 @@ class FeatureValidationPipeline:
             selected_features=selected_features,
             selection_summary=selection_summary,
             screening_artifact=screening_artifact,
+            config_snapshot=config_snapshot,
         )
 
     @staticmethod
@@ -854,6 +876,30 @@ class FeatureValidationPipeline:
         ]
         return pd.DataFrame(rows)
 
+    def _build_config_snapshot(
+        self,
+        new_features: list[str],
+        incumbent_features: list[str],
+        target_cols: list[str],
+        *,
+        batch_mode: bool,
+    ) -> dict[str, Any]:
+        cfg = self.config
+        return {
+            "selection_enabled": bool(cfg.selection_enabled),
+            "selection_params": dict(cfg.selection_params or {}),
+            "weight_col": cfg.weight_col,
+            "target_col": target_cols[0] if target_cols else None,
+            "target_cols": list(target_cols),
+            "new_feature_cols": list(new_features),
+            "incumbent_feature_cols": list(incumbent_features),
+            "woe_engine": cfg.woe_engine,
+            "woe_fit_query": cfg.woe_fit_query,
+            "woe_params": dict(cfg.woe_params or {}),
+            "monotone_woe_params": dict(cfg.monotone_woe_params or {}),
+            "batch_mode": bool(batch_mode),
+        }
+
     def _validate_input(
         self,
         data: pd.DataFrame,
@@ -864,6 +910,8 @@ class FeatureValidationPipeline:
         cfg = self.config
         missing = [col for col in [cfg.id_col, cfg.apply_time_col] if col and col not in data.columns]
         missing += [col for col in new_features + incumbent_features + target_cols if col not in data.columns]
+        if cfg.weight_col and cfg.weight_col not in data.columns:
+            missing.append(cfg.weight_col)
         if missing:
             raise KeyError(f"Missing required columns: {sorted(set(missing))}")
         if not new_features:
@@ -917,18 +965,20 @@ class FeatureValidationPipeline:
             raise KeyError(f"Missing split_col {cfg.split_col!r}")
         if sample_col in work.columns:
             raw_split = work[sample_col]
-            lower = raw_split.astype(str).str.strip().str.lower()
-            if cfg.split_col:
-                invalid = sorted(set(raw_split.dropna().astype(str).str.strip().str.lower()) - {"ins", "oos", "oot"})
-                if invalid:
-                    raise ValueError(f"split_col {cfg.split_col!r} only supports ins/oos/oot values, got {invalid}")
-            ins = work[lower == "ins"].copy()
-            oos = work[lower == "oos"].copy()
-            oot = work[lower == "oot"].copy()
+            normalized = normalize_split_values(raw_split)
+            ins = work[normalized.eq("ins").fillna(False)].copy()
+            oos = work[normalized.eq("oos").fillna(False)].copy()
+            oot = work[normalized.eq("oot").fillna(False)].copy()
             if len(ins) and len(oos):
                 if not len(oot):
                     oot = oos.copy()
-                return {"ins": ins, "oos": oos, "oot": oot}
+                splits = {"ins": ins, "oos": oos, "oot": oot}
+                if cfg.split_col:
+                    reserved = set(splits)
+                    for label in normalized.dropna().drop_duplicates().tolist():
+                        if label not in reserved:
+                            splits[str(label)] = work[normalized.eq(label).fillna(False)].copy()
+                return splits
             if cfg.split_col:
                 raise ValueError(f"split_col {cfg.split_col!r} must contain non-empty ins and oos samples")
 
@@ -1251,6 +1301,7 @@ class FeatureValidationPipeline:
         incumbent_features: list[str],
         target_cols: list[str],
         woe_artifacts: dict[str, Any],
+        config_snapshot: dict[str, Any],
     ) -> tuple[list[str], dict[str, Any], Any | None]:
         from Modeling_Tool.Feature.Feature_Screen import feature_screen
         from .screening_artifact import FeatureScreeningArtifact, screen_result_to_summary
@@ -1274,24 +1325,22 @@ class FeatureValidationPipeline:
             config=screen_cfg,
             prefit_woe_engine=engine,
         )
-        config_snapshot = {
-            "selection_enabled": True,
-            "selection_params": dict(cfg.selection_params or {}),
+        selection_config_snapshot = dict(config_snapshot)
+        selection_config_snapshot.update({
             "missing_rate_threshold": screen_cfg.missing_rate_threshold,
-            "weight_col": cfg.weight_col,
             "psi_use_woe_bins": screen_cfg.psi_use_woe_bins,
             "iv_use_woe_bins": screen_cfg.iv_use_woe_bins,
             "corr_use_woe_bins": screen_cfg.corr_use_woe_bins,
             "n_incumbent_features": len(incumbent_features),
-        }
+        })
         selection_summary = {
             "initial_features": list(new_features),
             "final_features": list(result.selected_features),
             "target_col": target,
-            "config_snapshot": config_snapshot,
+            "config_snapshot": selection_config_snapshot,
         }
         selection_summary.update(screen_result_to_summary(result, new_features))
-        selection_summary["config_snapshot"] = config_snapshot
+        selection_summary["config_snapshot"] = selection_config_snapshot
         artifact = FeatureScreeningArtifact.from_screen_result(
             result,
             initial_features=list(new_features),
@@ -1299,7 +1348,7 @@ class FeatureValidationPipeline:
             weight_col=cfg.weight_col,
             woe_artifacts=woe_artifacts,
             source="fvp",
-            config_snapshot=config_snapshot,
+            config_snapshot=selection_config_snapshot,
         )
         return list(result.selected_features), selection_summary, artifact
 

{supermodelingfactory-0.5.8 → supermodelingfactory-0.5.10}/Modeling_Tool/Pipeline/score_comparison.py

@@ -7,7 +7,14 @@ from typing import Any, Callable
 
 import pandas as pd
 
-from ._common import as_list, make_dirs, normalize_group_specs, safe_to_csv, write_basic_excel
+from ._common import (
+    as_list,
+    make_dirs,
+    normalize_group_specs,
+    normalize_split_values,
+    safe_to_csv,
+    write_basic_excel,
+)
 
 _logger = logging.getLogger(__name__)
 
@@ -287,6 +294,8 @@ class ScoreComparisonPipeline:
                     data.loc[missing_mask, col] = pd.NA
                 elif cfg.include_missing:
                     data.loc[missing_mask, col] = "[Missing]"
+        if cfg.split_col and cfg.split_col in data.columns:
+            data[cfg.split_col] = normalize_split_values(data[cfg.split_col])
 
     def _resolve_scores(self, data: pd.DataFrame) -> list[str]:
         cfg = self.config
@@ -314,10 +323,9 @@ class ScoreComparisonPipeline:
         if missing:
             raise KeyError(f"Missing required columns: {missing}")
         if cfg.split_col:
-            values = data[cfg.split_col].dropna().astype(str).str.strip().str.lower()
-            invalid = sorted(set(values) - {"ins", "oos", "oot"})
-            if invalid:
-                raise ValueError(f"split_col {cfg.split_col!r} only supports ins/oos/oot values, got {invalid}")
+            values = normalize_split_values(data[cfg.split_col]).dropna()
+            if values.empty:
+                raise ValueError(f"split_col {cfg.split_col!r} must contain at least one non-empty value")
 
     def _custom_metrics_func(self, sub_df: pd.DataFrame) -> pd.Series:
         cfg = self.config

{supermodelingfactory-0.5.8 → supermodelingfactory-0.5.10}/Modeling_Tool/Pipeline/screening_artifact.py

@@ -81,24 +81,47 @@ class FeatureScreeningArtifact:
         result: Any,
         *,
         target_col: str | None = None,
+        weight_col: str | None = None,
     ) -> FeatureScreeningArtifact:
         if getattr(result, "screening_artifact", None) is not None:
             return result.screening_artifact
+        summary = dict(getattr(result, "selection_summary", {}) or {})
+        summary_snapshot = dict(summary.get("config_snapshot", {}) or {})
+        result_snapshot = dict(getattr(result, "config_snapshot", {}) or {})
+        config_snapshot = {**summary_snapshot, **result_snapshot}
         resolved_target = target_col
         if not resolved_target:
-            summary = getattr(result, "selection_summary", {}) or {}
             resolved_target = summary.get("target_col")
+        if not resolved_target:
+            resolved_target = config_snapshot.get("target_col")
+        if not resolved_target:
+            target_cols = list(config_snapshot.get("target_cols") or [])
+            resolved_target = target_cols[0] if target_cols else None
         if not resolved_target:
             raise ValueError("target_col is required when building artifact from FVP result.")
-        summary = dict(getattr(result, "selection_summary", {}) or {})
-        config_snapshot = dict(summary.get("config_snapshot", {}) or {})
+        selected_features = list(getattr(result, "selected_features", []) or [])
+        if not selected_features and config_snapshot.get("selection_enabled") is False:
+            selected_features = list(config_snapshot.get("new_feature_cols") or [])
+        if not summary and config_snapshot.get("selection_enabled") is False:
+            summary = {
+                "initial_features": list(selected_features),
+                "final_features": list(selected_features),
+                "target_col": str(resolved_target),
+                "selection_skipped": True,
+                "config_snapshot": config_snapshot,
+            }
+        resolved_weight_col = (
+            config_snapshot["weight_col"]
+            if "weight_col" in config_snapshot
+            else weight_col
+        )
         return cls(
-            selected_features=list(getattr(result, "selected_features", []) or []),
+            selected_features=selected_features,
             selection_summary=summary,
             woe_artifacts=getattr(result, "woe_artifacts", None),
             source="fvp",
             target_col=str(resolved_target),
-            weight_col=config_snapshot.get("weight_col"),
+            weight_col=resolved_weight_col,
             config_snapshot=config_snapshot,
             created_at=datetime.now(timezone.utc).isoformat(),
         )
@@ -124,4 +147,4 @@ class FeatureScreeningArtifact:
 __all__ = [
     "FeatureScreeningArtifact",
     "screen_result_to_summary",
-]
+]