SuperModelingFactory 0.6.9__tar.gz → 0.7.0__tar.gz

{supermodelingfactory-0.6.9 → supermodelingfactory-0.7.0}/Modeling_Tool/Eval/Model_Eval_Tool.py

@@ -846,6 +846,7 @@ def get_gains_table(data, dep, nbins = 10, precision = 5, min_bin_prop = 0.05, i
             nbins=nbins,
             weight_col=weight_col,
             weighted_binning=weighted_binning,
+            ascending=ascending,
         )
         if retSummary:
             return pd.DataFrame({
@@ -2228,8 +2229,8 @@ class PerformanceEvaluator:
         # spec_values: sentinel scores (e.g. -1 for all-missing overrides)
         # that get their own evaluation bin and are excluded from quantile
         # edges and ranking metrics. ascending: None keeps every underlying
-        # function's own legacy default; an explicit bool is threaded through
-        # summary/gains/plot and the weighted path uniformly.
+        # function's legacy direction; an explicit bool is threaded through
+        # summary, gains, and figures (including weighted paths) uniformly.
         self.spec_values = list(spec_values) if spec_values else []
         self.ascending = ascending
         self.datasets = {}
@@ -2420,6 +2421,7 @@ class PerformanceEvaluator:
                         save_path=fig_save_path,
                         gains_table=gains_table,
                         equal_freq=self.equal_freq,
+                        ascending=self.ascending,
                     )
             if rpt_save_path:
                 fnl_df.to_csv(rpt_save_path, index=False)
@@ -2522,7 +2524,7 @@ class PerformanceEvaluator:
                 tree_binning = self.tree_binning,
                 random_state = self.random_state,
                 return_edges = True,
-                ascending = True
+                ascending = True if self.ascending is None else bool(self.ascending)
             )
 
             if benchmark_bin_edges is None or len(benchmark_bin_edges) < 2:
@@ -2556,7 +2558,8 @@ class PerformanceEvaluator:
                 save_path = save_path,
                 gains_table = gains_table,
                 equal_freq = self.equal_freq,
-                pct_bin_edges = benchmark_bin_edges
+                pct_bin_edges = benchmark_bin_edges,
+                ascending = self.ascending,
             )
 
             import re

{supermodelingfactory-0.6.9 → supermodelingfactory-0.7.0}/Modeling_Tool/Eval/Model_Eval_Tool.pyi

@@ -20,7 +20,7 @@ import pandas as pd
 from Modeling_Tool.Core.Binning_Tool import get_bin_range_list, super_binning
 from Modeling_Tool.Core.utils import load_model, calc_iv, calc_woe
 from .evaluate_model import evaluate_performance
-def get_gains_table(data, dep, nbins = 10, precision = 5, min_bin_prop = 0.05, include_missing = True, score = None, model = None, varlist = None, equal_freq = True, chi2_method = False, grp_name = None, min_data_size = 100, grp_colname = None, sync_range = True, chi2_p = 0.95, init_equi_bins = 100, fillna = -999999, spec_values = [], retSummary = False, tree_binning = False, random_state = 42, ascending = False, withSummary = False, wholeGroup = False, add_func = None): ...
+def get_gains_table(data, dep, nbins = 10, precision = 5, min_bin_prop = 0.05, include_missing = True, score = None, model = None, varlist = None, equal_freq = True, chi2_method = False, grp_name = None, min_data_size = 100, grp_colname = None, sync_range = True, chi2_p = 0.95, init_equi_bins = 100, fillna = -999999, spec_values = [], retSummary = False, tree_binning = False, random_state = 42, ascending = False, withSummary = False, wholeGroup = False, add_func = None, weight_col = None, weighted_binning = None): ...
 def get_perf_summary(train, validation, oot, tgt_name, scr_name = None, model = None, feature_cols = None, fig_save_path = None, rpt_save_path = None, to_show = False, display = True, dist_bins = 20, pct_bins = 10, precision = 5, min_bin_prop = 0.05, include_missing = False, equal_freq = True, chi2_method = False, init_equi_bins = 1000, chi2_p = 0.9, oot_grp_name = None, min_data_size = 100, grp_colname = None, tree_binning = False, random_state = 42, gains_table = False): ...
 def cross_risk(data, score_list, dep, nbins, agg_col = None, precision = 5, min_bin_prop = 0.05, include_missing = False, equal_freq = True, binning_numeric = [True, True], agg_func = 'mean', chi2_method = False, chi2_p = 0.95, init_equi_bins = 100, fillna = -999999, spec_values = [], tree_binning = False, random_state = 42): ...
 def get_gains_table_by_cust_metrics(data, dep, nbins = 10, precision = 5, min_bin_prop = 0.05, include_missing = True, score = None, model = None, varlist = None, equal_freq = True, chi2_method = False, grp_name = None, min_data_size = 100, grp_colname = None, sync_range = True, chi2_p = 0.95, init_equi_bins = 100, fillna = -999999, spec_values = [], tree_binning = False, random_state = 42, ascending = True, eval_metrics = ['age', 'monthly_income', 'education'], metric_agg_func = 'mean', withSummary = False): ...

{supermodelingfactory-0.6.9 → supermodelingfactory-0.7.0}/Modeling_Tool/Eval/evaluate_model.py

@@ -889,7 +889,13 @@ def calc_equid_pct(y_true, y_score, y_group=None, bins=10, ascending=True, sampl
         等分分组后各组统计量数据集
     """
     if sample_weight is not None:
-        return _weighted_eval.calc_equid_pct(y_true, y_score, bins=bins, sample_weight=sample_weight)
+        return _weighted_eval.calc_equid_pct(
+            y_true,
+            y_score,
+            bins=bins,
+            ascending=ascending,
+            sample_weight=sample_weight,
+        )
 
     y_true = np.array(y_true)
     y_score = np.array(y_score)
@@ -947,7 +953,12 @@ def calc_fixed_pct(y_true, y_score, y_group=None, bin_edges=None, ascending=True
         固定分箱后各组统计量数据集
     """
     if sample_weight is not None:
-        return _weighted_eval.calc_fixed_pct(y_true, y_score, sample_weight=sample_weight)
+        return _weighted_eval.calc_fixed_pct(
+            y_true,
+            y_score,
+            ascending=ascending,
+            sample_weight=sample_weight,
+        )
 
     if bin_edges is None:
         raise ValueError("bin_edges cannot be None when using fixed pct bins.")
@@ -1007,20 +1018,27 @@ def summarize_pct(pct_df, ascending=True):
     bins = pct_df.shape[0]
     interval = 100 / pct_df.shape[0]
 
-    if ascending:
-        pct_info = {
-            'pct_bins': bins,
-            'pct_interval': interval,
-            'pct_top_avgTrue'.format(interval):  pct_df['avg_true'].iloc[bins-1],
-            'pct_btm_avgTrue'.format(interval):  pct_df['avg_true'].iloc[0],
-        }
-    else:
-        pct_info = {
-            'pct_bins': bins,
-            'pct_interval': interval,
-            'pct_top_captureRate'.format(interval):  pct_df['capture_rate'].iloc[bins-1],
-            'pct_btm_captureRate'.format(interval):  pct_df['capture_rate'].iloc[0],
-        }
+    pct_info = {
+        'pct_bins': bins,
+        'pct_interval': interval,
+    }
+
+    # Precomputed gain frames historically only needed thresholds, gain, and
+    # capture_rate. Keep summarize_pct usable for those frames while exposing
+    # target-rate summary keys whenever the richer percentile schema is used.
+    if 'avg_true' in pct_df.columns:
+        top_idx, btm_idx = (bins - 1, 0) if ascending else (0, bins - 1)
+        pct_info.update({
+            'pct_top_avgTrue'.format(interval): pct_df['avg_true'].iloc[top_idx],
+            'pct_btm_avgTrue'.format(interval): pct_df['avg_true'].iloc[btm_idx],
+        })
+
+    if not ascending and 'capture_rate' in pct_df.columns:
+        # Preserve the historical descending-summary keys for direct callers.
+        pct_info.update({
+            'pct_top_captureRate'.format(interval): pct_df['capture_rate'].iloc[bins-1],
+            'pct_btm_captureRate'.format(interval): pct_df['capture_rate'].iloc[0],
+        })
 
     return pct_info
 
@@ -1374,7 +1392,7 @@ def __plot_pct_axes_base(ax, fontdicts):
     ax.set_ylabel('Target rate', fontdict=fontdicts['axislabel'])
 
 
-def __plot_single_pct_axes(pct_df, ax, fontdicts):
+def __plot_single_pct_axes(pct_df, ax, fontdicts, ascending=True):
     """在axes上绘制单个Score分布图.
 
     Parameters
@@ -1397,7 +1415,7 @@ def __plot_single_pct_axes(pct_df, ax, fontdicts):
     ax.plot(X, pct_df['avg_true'], color=palette['ClassicBlueRedGrey'][1], linewidth=2, marker='.', markersize=5, label='True')
     ax.axhline(y=pct_df['cumavg_true'][pct_df.shape[0]-1], linestyle='--', color=palette['ClassicBlueRedGrey'][2], linewidth=2, label='Random')
 
-    pct_info = summarize_pct(pct_df)
+    pct_info = summarize_pct(pct_df, ascending=ascending)
     _b, _i, _top, _btm = pct_info['pct_bins'], pct_info['pct_interval'], pct_info['pct_top_avgTrue'], pct_info['pct_btm_avgTrue']
     ax.set_title("Bins={0}  Top{1:.0f}%={2:.2%}  BTM{1:.0f}%={3:.2%}".format(_b, _i, _top, _btm), fontdict=fontdicts['subtitle'])
     ax.legend(loc=2, fontsize=fontdicts['legend']['size'])
@@ -1524,7 +1542,7 @@ def __plot_multi_cumpct_axes(pct_dfs, ax, fontdicts):
 
 # Gain Curve
 @timeit_decorator
-def plot_gain_curve(pct_dfs, square_figsize=8, fontdicts=fontdicts['main'], to_show=True, save_path=None):
+def plot_gain_curve(pct_dfs, square_figsize=8, fontdicts=fontdicts['main'], to_show=True, save_path=None, ascending=False):
     """绘制Score分布曲线图.
 
     Parameters
@@ -1537,6 +1555,8 @@ def plot_gain_curve(pct_dfs, square_figsize=8, fontdicts=fontdicts['main'], to_s
         是否展示图片. 默认为True
     save_path: str
         结果图片存放文件地址. 默认值为None, 即不保存
+    ascending: bool, default False
+        Gain 图按分数升序（True）或降序（False）累计。
     """
     plt.figure(figsize=(square_figsize, square_figsize))
     plt.suptitle('Gain Curve', fontsize=fontdicts['suptitle']['size'], fontweight=fontdicts['suptitle']['weight'])  #, findfont=zhfont)
@@ -1545,9 +1565,9 @@ def plot_gain_curve(pct_dfs, square_figsize=8, fontdicts=fontdicts['main'], to_s
     models = list(pct_dfs.keys())
     if len(models) == 1:
         pct_df = pct_dfs[models[0]]
-        __plot_single_gain_axes(pct_df, ax, fontdicts)
+        __plot_single_gain_axes(pct_df, ax, fontdicts, ascending=ascending)
     else:
-        __plot_multi_gain_axes(pct_dfs, ax, fontdicts)
+        __plot_multi_gain_axes(pct_dfs, ax, fontdicts, ascending=ascending)
     ax.legend(loc=2, fontsize=fontdicts['legend']['size'])
 
     if to_show:
@@ -1557,7 +1577,7 @@ def plot_gain_curve(pct_dfs, square_figsize=8, fontdicts=fontdicts['main'], to_s
     plt.close()
 
 
-def __plot_gain_axes_base(ax, fontdicts):
+def __plot_gain_axes_base(ax, fontdicts, ascending=False):
     """在axes上绘制Score分布图基础.
 
     Parameters
@@ -1570,11 +1590,12 @@ def __plot_gain_axes_base(ax, fontdicts):
     ax.plot([0,100], [0,1], color='k', linestyle='--', linewidth=1)
     ax.set_xlim([0,100])
     ax.set_ylim([0,1])
-    ax.set_xlabel('Percentile % (Score Descending)', fontdict=fontdicts['axislabel'])
+    direction = 'Ascending' if ascending else 'Descending'
+    ax.set_xlabel(f'Percentile % (Score {direction})', fontdict=fontdicts['axislabel'])
     ax.set_ylabel('gain', fontdict=fontdicts['axislabel'])
 
     
-def __plot_single_gain_axes(pct_df, ax, fontdicts):
+def __plot_single_gain_axes(pct_df, ax, fontdicts, ascending=False):
     """在axes上绘制单个Score分布图.
 
     Parameters
@@ -1586,11 +1607,11 @@ def __plot_single_gain_axes(pct_df, ax, fontdicts):
     fontdicts: dict
         绘图相关字体字典
     """
-    __plot_gain_axes_base(ax, fontdicts)
+    __plot_gain_axes_base(ax, fontdicts, ascending=ascending)
 
     plot_df = pct_df.copy()
     if {'avg_score', 'proportion', 'capture_rate'}.issubset(plot_df.columns):
-        plot_df = plot_df.sort_values('avg_score', ascending=False).reset_index(drop=True)
+        plot_df = plot_df.sort_values('avg_score', ascending=ascending).reset_index(drop=True)
         plot_df['thresholds'] = plot_df['proportion'].cumsum() * 100
         plot_df['gain'] = plot_df['capture_rate'].cumsum()
 
@@ -1600,14 +1621,15 @@ def __plot_single_gain_axes(pct_df, ax, fontdicts):
     Y = np.insert(Y, 0, 0)
     ax.plot(X, Y, color=palette['ClassicBlueRedGrey'][0], linewidth=2, marker='.', markersize=5, label='avgScore')
 
-    pct_info = summarize_pct(plot_df, ascending=False)
+    pct_info = summarize_pct(plot_df, ascending=ascending)
     _b, _i = pct_info['pct_bins'], pct_info['pct_interval']
-    _top = plot_df['capture_rate'].iloc[0] if plot_df.shape[0] > 0 else np.nan
-    _btm = plot_df['capture_rate'].iloc[-1] if plot_df.shape[0] > 0 else np.nan
+    _top_idx, _btm_idx = (-1, 0) if ascending else (0, -1)
+    _top = plot_df['capture_rate'].iloc[_top_idx] if plot_df.shape[0] > 0 else np.nan
+    _btm = plot_df['capture_rate'].iloc[_btm_idx] if plot_df.shape[0] > 0 else np.nan
     ax.set_title("Bins={0}  Top{1:.0f}%={2:.2%}  BTM{1:.0f}%={3:.2%}".format(_b, _i, _top, _btm), fontdict=fontdicts['subtitle'])
 
 
-def __plot_multi_gain_axes(pct_dfs, ax, fontdicts):
+def __plot_multi_gain_axes(pct_dfs, ax, fontdicts, ascending=False):
     """在axes上绘制多个Score分布图.
 
     Parameters
@@ -1619,14 +1641,14 @@ def __plot_multi_gain_axes(pct_dfs, ax, fontdicts):
     fontdicts: dict
         绘图相关字体字典
     """
-    __plot_gain_axes_base(ax, fontdicts)
+    __plot_gain_axes_base(ax, fontdicts, ascending=ascending)
 
     models = list(pct_dfs.keys())
     for i in range(len(models)):
         md = models[i]
         pct_df = pct_dfs[md].copy()
         if {'avg_score', 'proportion', 'capture_rate'}.issubset(pct_df.columns):
-            pct_df = pct_df.sort_values('avg_score', ascending=False).reset_index(drop=True)
+            pct_df = pct_df.sort_values('avg_score', ascending=ascending).reset_index(drop=True)
             pct_df['thresholds'] = pct_df['proportion'].cumsum() * 100
             pct_df['gain'] = pct_df['capture_rate'].cumsum()
         X = np.array(pct_df['thresholds'])
@@ -1636,7 +1658,7 @@ def __plot_multi_gain_axes(pct_dfs, ax, fontdicts):
         ax.plot(X, Y, color=palette['MorandiDark'][i], linewidth=2, marker='.', markersize=5, label='{0} avgTrue'.format(md))
 
 
-def _weighted_gains_to_plot_frames(weighted_gains):
+def _weighted_gains_to_plot_frames(weighted_gains, pct_ascending=True, gain_ascending=False):
     """Convert weighted gains output into the plotting helpers' long schema."""
     if weighted_gains is None or weighted_gains.empty:
         return pd.DataFrame(), pd.DataFrame()
@@ -1646,8 +1668,8 @@ def _weighted_gains_to_plot_frames(weighted_gains):
     if missing:
         raise KeyError(f"Weighted gains table missing plotting columns: {missing}")
 
-    descending = weighted_gains.reset_index(drop=True).copy()
-    total_bad = float(descending["N_BAD"].sum())
+    gains = weighted_gains.reset_index(drop=True).copy()
+    total_bad = float(gains["N_BAD"].sum())
 
     def _convert(source):
         source = source.reset_index(drop=True)
@@ -1680,10 +1702,10 @@ def _weighted_gains_to_plot_frames(weighted_gains):
             }
         )
 
-    # Percentile charts historically run from low score to high score, while
-    # gain charts run from the highest score downward.
-    percentile_frame = _convert(descending.iloc[::-1])
-    gain_frame = _convert(descending)
+    # An explicit direction governs both plots. The optional defaults retain
+    # the historical mixed behavior for direct callers that leave it unset.
+    percentile_frame = _convert(gains.sort_values("AVG_SCORE", ascending=pct_ascending))
+    gain_frame = _convert(gains.sort_values("AVG_SCORE", ascending=gain_ascending))
     return percentile_frame, gain_frame
 
 
@@ -1696,7 +1718,7 @@ def _set_weighted_axis_title(ax, fontdicts):
 
 
 @timeit_decorator
-def evaluate_performance(datasets, dist_bins=20, pct_bins=10, square_figsize=5, fontdicts=fontdicts['sub'], to_show=True, save_path=None, gains_table = True, equal_freq = True, pct_bin_edges = None, sample_weight=None):
+def evaluate_performance(datasets, dist_bins=20, pct_bins=10, square_figsize=5, fontdicts=fontdicts['sub'], to_show=True, save_path=None, gains_table = True, equal_freq = True, pct_bin_edges = None, sample_weight=None, ascending=None):
     """绘制单模型预测效果评价图.
 
     Parameters
@@ -1715,6 +1737,9 @@ def evaluate_performance(datasets, dist_bins=20, pct_bins=10, square_figsize=5,
         是否展示图片. 默认为True
     save_path: str
         结果图片存放文件地址. 默认值为None, 即不保存
+    ascending: bool, optional
+        显式值统一控制收益表、百分位图和 Gain 图的分数方向；None 保留
+        历史百分位升序、Gain 降序的行为。
     
     Returns
     -------
@@ -1746,7 +1771,7 @@ def evaluate_performance(datasets, dist_bins=20, pct_bins=10, square_figsize=5,
         y_true = datasets[d]['y_true']
         y_score = datasets[d]['y_score']
         dataset_weight = datasets[d].get('sample_weight', sample_weight)
-        result.update({d: __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins, fontdicts, gains_table, equal_freq, pct_bin_edges, sample_weight=dataset_weight)})
+        result.update({d: __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins, fontdicts, gains_table, equal_freq, pct_bin_edges, sample_weight=dataset_weight, ascending=ascending)})
 
     result_df = pd.DataFrame.from_dict(result, orient='index').reset_index()
 
@@ -1779,7 +1804,7 @@ def resturct_gains(gains_table):
     
     return gains_table
 
-def __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins, fontdicts, gains_table = True, equal_freq = True, pct_bin_edges = None, sample_weight=None):
+def __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins, fontdicts, gains_table = True, equal_freq = True, pct_bin_edges = None, sample_weight=None, ascending=None):
     """绘制单模型在单样本集上预测效果评价图.
     包括: ROC、KDE、PCT、Gain四图.
 
@@ -1806,6 +1831,13 @@ def __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins,
 #     from Model_Eval_Tool import get_gains_table
     from .Model_Eval_Tool import get_gains_table
     
+    # ``None`` preserves the historical PCT-ascending / gain-descending
+    # split. An explicit bool applies one direction consistently.
+    pct_ascending = True if ascending is None else bool(ascending)
+    gain_ascending = False if ascending is None else bool(ascending)
+    unweighted_gains_ascending = True if ascending is None else bool(ascending)
+    weighted_gains_ascending = False if ascending is None else bool(ascending)
+
     # 清理数据
     mask = np.isfinite(y_score) & np.isfinite(y_true)
     if sample_weight is not None:
@@ -1832,7 +1864,7 @@ def __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins,
             include_missing = False,
             score = 'y_score',
             equal_freq = equal_freq,
-            ascending = True ,
+            ascending = unweighted_gains_ascending,
             withSummary = False,
             weight_col = '_sample_weight' if sample_weight is not None else None,
         )
@@ -1847,28 +1879,28 @@ def __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins,
             "y_score",
             nbins=bin_count,
             weight_col="w",
+            ascending=weighted_gains_ascending,
+        )
+        pct_df, pct_desc_df = _weighted_gains_to_plot_frames(
+            weighted_gains,
+            pct_ascending=pct_ascending,
+            gain_ascending=gain_ascending,
         )
-        pct_df, pct_desc_df = _weighted_gains_to_plot_frames(weighted_gains)
         if gains_table:
             y_gains = weighted_gains
-        pct_info = {
-            "pct_bins": weighted_gains.shape[0],
-            "pct_interval": 100.0 / weighted_gains.shape[0] if weighted_gains.shape[0] else np.nan,
-            "pct_top_avgTrue": float(weighted_gains["AVG_BAD"].iloc[0]) if len(weighted_gains) else np.nan,
-            "pct_btm_avgTrue": float(weighted_gains["AVG_BAD"].iloc[-1]) if len(weighted_gains) else np.nan,
-        }
+        pct_info = summarize_pct(pct_df, ascending=pct_ascending)
     else:
         if pct_bin_edges is not None:
-            pct_df = calc_fixed_pct(y_true, y_score, None, bin_edges=pct_bin_edges, ascending=True, sample_weight=sample_weight)
+            pct_df = calc_fixed_pct(y_true, y_score, None, bin_edges=pct_bin_edges, ascending=pct_ascending, sample_weight=sample_weight)
         else:
-            pct_df = calc_equid_pct(y_true, y_score, None, bins=pct_bins, sample_weight=sample_weight)
+            pct_df = calc_equid_pct(y_true, y_score, None, bins=pct_bins, ascending=pct_ascending, sample_weight=sample_weight)
 
         if gains_table:
             pct_index = pct_df["thresholds"]
             pct_df = resturct_gains(y_gains)
             pct_df["thresholds"] = pct_index
 
-        pct_info = summarize_pct(pct_df, ascending=True)
+        pct_info = summarize_pct(pct_df, ascending=pct_ascending)
     
     if len(y_true) < 2 or len(np.unique(y_true)) < 2:
         # 返回默认性能指标（全部为NaN）
@@ -1884,9 +1916,9 @@ def __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins,
     
     if sample_weight is None:
         if pct_bin_edges is not None:
-            pct_desc_df = calc_fixed_pct(y_true, y_score, None, bin_edges=pct_bin_edges, ascending=False, sample_weight=sample_weight)
+            pct_desc_df = calc_fixed_pct(y_true, y_score, None, bin_edges=pct_bin_edges, ascending=gain_ascending, sample_weight=sample_weight)
         else:
-            pct_desc_df = calc_equid_pct(y_true, y_score, None, bins=pct_bins, ascending=False, sample_weight=sample_weight)
+            pct_desc_df = calc_equid_pct(y_true, y_score, None, bins=pct_bins, ascending=gain_ascending, sample_weight=sample_weight)
 
     ax_roc = plt.subplot(nrow, ncol, i*ncol+1)
     __plot_single_roc_axes(roc_df, ax_roc, fontdicts)
@@ -1900,16 +1932,16 @@ def __evaluate_performance(y_true, y_score, nrow, ncol, i, dist_bins, pct_bins,
         sample_weight=sample_weight,
     )
     if sample_weight is None:
-        __plot_single_pct_axes(pct_df, plt.subplot(nrow, ncol, i*ncol+3), fontdicts)
-        __plot_single_gain_axes(pct_desc_df, plt.subplot(nrow, ncol, i*ncol+4), fontdicts)
+        __plot_single_pct_axes(pct_df, plt.subplot(nrow, ncol, i*ncol+3), fontdicts, ascending=pct_ascending)
+        __plot_single_gain_axes(pct_desc_df, plt.subplot(nrow, ncol, i*ncol+4), fontdicts, ascending=gain_ascending)
     else:
         _set_weighted_axis_title(ax_roc, fontdicts)
         _set_weighted_axis_title(ax_kde, fontdicts)
         ax_pct = plt.subplot(nrow, ncol, i * ncol + 3)
-        __plot_single_pct_axes(pct_df, ax_pct, fontdicts)
+        __plot_single_pct_axes(pct_df, ax_pct, fontdicts, ascending=pct_ascending)
         _set_weighted_axis_title(ax_pct, fontdicts)
         ax_gain = plt.subplot(nrow, ncol, i * ncol + 4)
-        __plot_single_gain_axes(pct_desc_df, ax_gain, fontdicts)
+        __plot_single_gain_axes(pct_desc_df, ax_gain, fontdicts, ascending=gain_ascending)
         _set_weighted_axis_title(ax_gain, fontdicts)
 
     info = {

{supermodelingfactory-0.6.9 → supermodelingfactory-0.7.0}/Modeling_Tool/Eval/evaluate_model.pyi

@@ -42,8 +42,8 @@ def plot_dist_curve(dist_dfs, square_figsize = 8, fontdicts = fontdicts['main'],
 def plot_cumdist_curve(dist_dfs, square_figsize = 8, fontdicts = fontdicts['main'], to_show = True, save_path = None): ...
 def plot_pct_curve(pct_dfs, square_figsize = 8, fontdicts = fontdicts['main'], to_show = True, save_path = None): ...
 def plot_cumpct_curve(pct_dfs, square_figsize = 8, fontdicts = fontdicts['main'], to_show = True, save_path = None): ...
-def plot_gain_curve(pct_dfs, square_figsize = 8, fontdicts = fontdicts['main'], to_show = True, save_path = None): ...
-def evaluate_performance(datasets, dist_bins = 20, pct_bins = 10, square_figsize = 5, fontdicts = fontdicts['sub'], to_show = True, save_path = None, gains_table = True, equal_freq = True, pct_bin_edges = None): ...
+def plot_gain_curve(pct_dfs, square_figsize = 8, fontdicts = fontdicts['main'], to_show = True, save_path = None, ascending = False): ...
+def evaluate_performance(datasets, dist_bins = 20, pct_bins = 10, square_figsize = 5, fontdicts = fontdicts['sub'], to_show = True, save_path = None, gains_table = True, equal_freq = True, pct_bin_edges = None, sample_weight = None, ascending = None): ...
 def resturct_gains(gains_table): ...
 def evaluate_distribution(datasets, dist_bins = 10, square_figsize = 5, fontdicts = fontdicts['sub'], toplot = True, save_path = None): ...
 def comparison_performance(datasets, pct_bins = 10, square_figsize = 5, fontdicts = fontdicts['sub'], to_show = True, save_path = None): ...

{supermodelingfactory-0.6.9 → supermodelingfactory-0.7.0}/Modeling_Tool/Eval/weighted_eval_utils.py

@@ -269,6 +269,7 @@ def calc_equid_dist(y_true, y_score, bins=10, sample_weight=None, **kwargs):
         "s",
         nbins=bins,
         weight_col="w",
+        **kwargs,
     )
 
 

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

@@ -5,7 +5,7 @@ from __future__ import annotations
 import warnings
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Literal, Mapping
+from typing import Any, Callable, Literal, Mapping
 
 import numpy as np
 import pandas as pd
@@ -113,6 +113,11 @@ class FeatureScreenConfig:
     vif_threshold: float = 10.0
     vif_min_features: int = 2
     vif_tie_break_metric: str = "iv"
+    # G06-2: False (legacy) computes VIF on raw values with non-numeric
+    # survivors excluded+warned (raw string columns crash statsmodels);
+    # True computes VIF on the WOE-encoded INS view (all-numeric, matches
+    # the LR design-matrix collinearity semantics).
+    vif_use_woe_bins: bool = False
 
 
 def screen_config_from_mapping(
@@ -181,6 +186,7 @@ def screen_config_from_mapping(
         vif_threshold=float(cfg.get("vif_threshold", 10.0)),
         vif_min_features=int(cfg.get("vif_min_features", 2)),
         vif_tie_break_metric=str(cfg.get("vif_tie_break_metric", "iv")),
+        vif_use_woe_bins=bool(cfg.get("vif_use_woe_bins", False)),
     )
 
 
@@ -199,6 +205,10 @@ def fit_screening_woe_engine(
     from Modeling_Tool.Pipeline._common import apply_woe_fit_query
 
     fit_ins, _ = apply_woe_fit_query(train, woe_fit_query, target=target_col)
+    # A screening WOE fit is an internal diagnostic artifact.  In particular,
+    # WOE_Master can append transformed columns while fitting/transforming, so
+    # never let an opt-in screen stage mutate the caller's INS frame.
+    fit_ins = fit_ins.copy()
     if woe_engine.lower() == "monotone":
         from Modeling_Tool import MonotoneWOEBinner
 
@@ -236,7 +246,12 @@ def fit_screening_woe_engine(
 
 
 def _needs_woe_bins(config: FeatureScreenConfig) -> bool:
-    return config.psi_use_woe_bins or config.iv_use_woe_bins or config.corr_use_woe_bins
+    return (
+        config.psi_use_woe_bins
+        or config.iv_use_woe_bins
+        or config.corr_use_woe_bins
+        or (config.vif_enabled and config.vif_use_woe_bins)
+    )
 
 
 def _resolve_screening_binner(
@@ -250,6 +265,22 @@ def _resolve_screening_binner(
         return prefit_woe_engine
     if not _needs_woe_bins(config):
         return None
+    categorical = [
+        col for col in (config.categorical_features or []) if col in feature_cols
+    ]
+    if (
+        config.vif_enabled
+        and config.vif_use_woe_bins
+        and categorical
+        and str(config.woe_engine).lower() != "monotone"
+    ):
+        raise ValueError(
+            "vif_use_woe_bins=True with categorical_features requires "
+            "woe_engine='monotone'. The equal_freq WOE_Master screening "
+            "engine does not support categorical fitting on this path; use "
+            "the monotone engine or leave vif_use_woe_bins=False to retain "
+            "the raw-basis exclude-and-warn behavior."
+        )
     return fit_screening_woe_engine(
         splits["ins"],
         feature_cols,
@@ -393,6 +424,11 @@ def _woe_bins_unweighted_screen(
         ins, current, config, selection_evidence, gate_iv_map,
         summary_rows, dropped_rows, stage_tables,
         weight_col=None, on_empty_stage=config.on_empty_stage,
+        woe_frame_fn=(
+            _vif_woe_frame_fn(ins, binner)
+            if config.vif_enabled and config.vif_use_woe_bins
+            else None
+        ),
     )
 
     summary_rows.append(_summary_row("final", len(feature_cols), len(current), None, None))
@@ -427,6 +463,50 @@ def _bins_to_numpy(bins: Any) -> np.ndarray:
     return np.asarray(bins, dtype=object)
 
 
+def _vif_woe_frame_fn(
+    ins: pd.DataFrame, binner: Any | None
+) -> Callable[[list[str]], pd.DataFrame] | None:
+    """Lazy WOE-encoded INS view for the VIF gate (G06-2,
+    ``vif_use_woe_bins=True``). Returns None when no screening engine was
+    fitted — the gate raises an actionable error in that case. Columns are
+    renamed back to the raw feature names so drop bookkeeping stays on the
+    selection's own vocabulary."""
+    if binner is None:
+        return None
+    def _frame(feats: list[str]) -> pd.DataFrame:
+        names = list(feats)
+        # Construct the adapter only when this opt-in gate actually reaches
+        # VIF.  This preserves the historical opaque-prefit-engine path when
+        # VIF/WOE is disabled and avoids doing work at a min-feature floor.
+        from Modeling_Tool.WOE.WOE_Adapter import as_woe_engine
+
+        engine_suffix = str(getattr(binner, "woe_suffix", "_woe"))
+        try:
+            adapter = as_woe_engine(binner, woe_suffix=engine_suffix)
+        except TypeError as exc:
+            raise ValueError(
+                "vif_use_woe_bins=True requires a supported fitted WOE "
+                "engine (WOE_Master, MonotoneWOEBinner, or WOEEngineAdapter)."
+            ) from exc
+        suffix = adapter.woe_suffix
+        # Transform a copy as well: some legacy engines retain or append
+        # intermediate WOE columns on the passed frame.
+        tx = adapter.transform(ins.copy(), varlist=names, suffix=suffix)
+        expected = [f"{name}{suffix}" for name in names]
+        missing = [name for name, column in zip(names, expected) if column not in tx.columns]
+        if missing:
+            raise ValueError(
+                "vif_use_woe_bins=True could not produce WOE columns for "
+                f"{missing!r}. Refit the screening WOE engine or supply a "
+                "prefit engine that covers every surviving feature."
+            )
+        frame = tx[expected].copy()
+        frame.columns = names
+        return frame
+
+    return _frame
+
+
 def _screen_engine_payload(
     binner: Any | None,
     *,
@@ -647,6 +727,11 @@ def _weighted_woe_bins_screen(
         ins, current, config, selection_evidence, gate_iv_map,
         summary_rows, dropped_rows, stage_tables,
         weight_col=weight_col, on_empty_stage=config.on_empty_stage,
+        woe_frame_fn=(
+            _vif_woe_frame_fn(ins, binner)
+            if config.vif_enabled and config.vif_use_woe_bins
+            else None
+        ),
     )
 
     summary_rows.append(_summary_row("final", len(feature_cols), len(current), None, weight_col))