SuperModelingFactory 0.5.9__tar.gz → 0.5.10__tar.gz

{supermodelingfactory-0.5.9 → 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.9 → 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.9 → 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.9 → supermodelingfactory-0.5.10}/Modeling_Tool/WOE/WOE_Master.py

@@ -4,10 +4,10 @@ import numpy as np
 import warnings
 
 from .WOE_Plot_Tool import get_bivar_graph
-from .WOE_Tool import mapping_woe, woe_transform
+from .WOE_Tool import _vectorized_group_slopes, mapping_woe, woe_transform
 
 from Modeling_Tool.Core.Binning_Tool import run_binning, get_bin_range_list
-from Modeling_Tool.Core.utils import calc_woe, calc_iv
+from Modeling_Tool.Core.utils import _calc_woe_iv_values
 from Modeling_Tool._utils.sentinels import SMF_MISSING_BIN
 
 def get_overall_woe_table(woe_master, data, varlist=None):
@@ -29,8 +29,9 @@ def get_overall_woe_table(woe_master, data, varlist=None):
         right = first_bin[-1] == ']'
 
         fill_val = woe_master.missing_ref_value
-        data_proc = data.copy()
+        data_proc = data[[var, woe_master.dep]].copy()
         data_proc[var] = data_proc[var].fillna(fill_val)
+        data_proc["_smf_good_n"] = data_proc[woe_master.dep].eq(0).astype(np.int64)
 
         # 使用训练集边界分箱
         binned, _ = run_binning(
@@ -54,14 +55,15 @@ def get_overall_woe_table(woe_master, data, varlist=None):
             N=(var, "count"),
             AVG_BAD=(dep, "mean"),
             N_BAD=(dep, "sum"),
-            N_GOOD=(dep, lambda x: (x == 0).sum())
+            N_GOOD=("_smf_good_n", "sum")
         ).reset_index()
 
         # 计算 WOE / IV / LIFT
         stats["BAD_PCT_PER_BIN"] = stats["N_BAD"] / stats["N_BAD"].sum()
         stats["GOOD_PCT_PER_BIN"] = stats["N_GOOD"] / stats["N_GOOD"].sum()
-        stats["WOE"] = calc_woe(stats, bad_pct="BAD_PCT_PER_BIN", good_pct="GOOD_PCT_PER_BIN")
-        stats["IV"] = calc_iv(stats, bad_pct="BAD_PCT_PER_BIN", good_pct="GOOD_PCT_PER_BIN")
+        stats["WOE"], stats["IV"] = _calc_woe_iv_values(
+            stats, "BAD_PCT_PER_BIN", "GOOD_PCT_PER_BIN"
+        )
         stats["LIFT"] = stats["AVG_BAD"] / stats["AVG_BAD"].mean()
         stats["VAR"] = var
 
@@ -95,8 +97,9 @@ def get_group_woe_table(woe_master, data, group, varlist=None):
         right = first_bin[-1] == ']'
         fill_val = woe_master.missing_ref_value
 
-        data_proc = data.copy()
+        data_proc = data[[group, var, woe_master.dep]].copy()
         data_proc[var] = data_proc[var].fillna(fill_val)
+        data_proc["_smf_good_n"] = data_proc[woe_master.dep].eq(0).astype(np.int64)
 
         binned, _ = run_binning(
             data=data_proc,
@@ -120,7 +123,7 @@ def get_group_woe_table(woe_master, data, group, varlist=None):
             N=(var, "count"),
             AVG_BAD=(dep, "mean"),
             N_BAD=(dep, "sum"),
-            N_GOOD=(dep, lambda x: (x == 0).sum())
+            N_GOOD=("_smf_good_n", "sum")
         ).reset_index()
 
         # 计算各分箱内 WOE（全局分母）
@@ -128,8 +131,9 @@ def get_group_woe_table(woe_master, data, group, varlist=None):
         total_good = stats["N_GOOD"].sum()
         stats["BAD_PCT_PER_BIN"] = stats["N_BAD"] / total_bad
         stats["GOOD_PCT_PER_BIN"] = stats["N_GOOD"] / total_good
-        stats["WOE"] = calc_woe(stats, bad_pct="BAD_PCT_PER_BIN", good_pct="GOOD_PCT_PER_BIN")
-        stats["IV"] = calc_iv(stats, bad_pct="BAD_PCT_PER_BIN", good_pct="GOOD_PCT_PER_BIN")
+        stats["WOE"], stats["IV"] = _calc_woe_iv_values(
+            stats, "BAD_PCT_PER_BIN", "GOOD_PCT_PER_BIN"
+        )
         stats["LIFT"] = stats["AVG_BAD"] / stats["AVG_BAD"].mean()
         stats["VAR"] = var
 
@@ -147,10 +151,12 @@ def get_group_woe_table(woe_master, data, group, varlist=None):
         ).reset_index()
 
         # 计算单调性斜率（可选）
-        from Modeling_Tool.Core.Slope_Tool import calculate_slope_manual
-        slopes = stats.groupby(group).apply(lambda x: calculate_slope_manual(x, "AVG_BAD"))
+        slopes = _vectorized_group_slopes(stats, group, "AVG_BAD")
         sum_grp["SLOPE"] = sum_grp[group].map(slopes)
-        sum_grp["direction"] = sum_grp["SLOPE"].apply(lambda x: 1 if x > 0 else -1 if x < 0 else 0)
+        slope_values = sum_grp["SLOPE"].to_numpy()
+        sum_grp["direction"] = np.select(
+            [slope_values > 0, slope_values < 0], [1, -1], default=0
+        )
         sum_grp["VAR"] = var
 
         summaries.append(sum_grp)
@@ -364,7 +370,14 @@ class WOE_Master(object):
             varlist = self.varlist
 
         woe_mapping_table = self.get_mapping_table()
-        data_woe = mapping_woe(data, varlist, woe_mapping_table, suffix=self.woe_suffix, drop_bin_info=True)
+        data_woe = mapping_woe(
+            data,
+            varlist,
+            woe_mapping_table,
+            suffix=self.woe_suffix,
+            drop_bin_info=True,
+            missing_ref_value=self.missing_ref_value,
+        )
         return data_woe
 
     def update_woe(self, varlist, nbins=10, equal_freq=True, tree_binning_seed=None, chi2_config=None,

{supermodelingfactory-0.5.9 → supermodelingfactory-0.5.10}/Modeling_Tool/WOE/WOE_Tool.py

@@ -7,9 +7,53 @@ import numpy as np
 import pandas as pd
 import logging
 
-from Modeling_Tool.Core.Binning_Tool import run_binning, super_binning, get_bin_range_list
+from Modeling_Tool.Core.Binning_Tool import (
+    _parse_bin_range_bounds,
+    get_bin_range_list,
+    run_binning,
+    super_binning,
+)
 from Modeling_Tool.Core.Slope_Tool import calculate_slope_manual
-from Modeling_Tool.Core.utils import calc_iv, calc_woe
+from Modeling_Tool.Core.utils import _calc_woe_iv_values, calc_iv, calc_woe
+
+
+def _vectorized_lookup(values, mapping_keys, mapping_values):
+    """Map a whole Series through a unique lookup table with integer codes."""
+    key_index = pd.Index(np.asarray(list(mapping_keys), dtype=object))
+    if not key_index.is_unique:
+        raise ValueError("WOE mapping keys must be unique")
+
+    positions = key_index.get_indexer(values.astype(object).to_numpy())
+    output = np.full(len(values), np.nan, dtype=float)
+    valid = positions >= 0
+    if valid.any():
+        mapped = np.asarray(list(mapping_values), dtype=float)
+        output[valid] = np.take(mapped, positions[valid])
+    return pd.Series(output, index=values.index)
+
+
+def _vectorized_group_slopes(data, group_col, value_col):
+    """Calculate per-group OLS slopes without ``groupby.apply`` callbacks."""
+    work = data[[group_col, value_col]].copy()
+    work["_smf_x"] = work.groupby(group_col, sort=False).cumcount().astype(float)
+    work["_smf_y"] = pd.to_numeric(work[value_col], errors="coerce")
+    work["_smf_xy"] = work["_smf_x"] * work["_smf_y"]
+    work["_smf_x2"] = work["_smf_x"] ** 2
+
+    grouped = work.groupby(group_col, sort=False).agg(
+        n=("_smf_y", "size"),
+        n_valid=("_smf_y", "count"),
+        sum_x=("_smf_x", "sum"),
+        sum_y=("_smf_y", "sum"),
+        sum_xy=("_smf_xy", "sum"),
+        sum_x2=("_smf_x2", "sum"),
+    )
+    numerator = grouped["n"] * grouped["sum_xy"] - grouped["sum_x"] * grouped["sum_y"]
+    denominator = grouped["n"] * grouped["sum_x2"] - grouped["sum_x"] ** 2
+    slopes = numerator / denominator
+    slopes[(grouped["n"] != grouped["n_valid"]) | denominator.eq(0)] = np.nan
+    slopes.name = "SLOPE"
+    return slopes
 
 def is_monotonic(data, column, direction='auto', strict=False, handle_nan='drop'):
     """检查Pandas Series或DataFrame列是否单调（递增或递减）。
@@ -216,24 +260,33 @@ class WOETransformer:
         tuple
             (woe_table, woe_mapping_dict) 元组
         """
-        woe_table = binning_res.groupby([f"_bin_num_{var}", f"_bin_range_{var}"], dropna=False)\
-            .agg(
+        working = binning_res.copy()
+        target = working[dep]
+        working["_smf_target_n"] = target.notna().astype(np.int64)
+        working["_smf_bad_n"] = target.eq(1).astype(np.int64)
+        working["_smf_good_n"] = target.eq(0).astype(np.int64)
+        woe_table = working.groupby(
+            [f"_bin_num_{var}", f"_bin_range_{var}"], dropna=False
+        ).agg(
             MIN=(var, "min"),
             MAX=(var, "max"),
             N=(f"_bin_num_{var}", "count"),
             AVG_SCORE=(var, "mean"),
-            AVG_BAD=(dep, lambda x: ((x == 1).sum() / x.count())),
-            AVG_GOOD=(dep, lambda x: ((x == 0).sum() / x.count())),
-            N_BAD=(dep, "sum"),
-            N_GOOD=(dep, lambda x: (x == 0).sum())
+            TARGET_N=("_smf_target_n", "sum"),
+            N_BAD=("_smf_bad_n", "sum"),
+            N_GOOD=("_smf_good_n", "sum"),
         )
+        woe_table["AVG_BAD"] = woe_table["N_BAD"] / woe_table["TARGET_N"]
+        woe_table["AVG_GOOD"] = woe_table["N_GOOD"] / woe_table["TARGET_N"]
+        woe_table = woe_table.drop(columns="TARGET_N")
 
         # IV/WOE Calculation
         woe_table["BAD_PCT_PER_BIN"] = woe_table["N_BAD"] / woe_table["N_BAD"].sum()
         woe_table["GOOD_PCT_PER_BIN"] = woe_table["N_GOOD"] / woe_table["N_GOOD"].sum()
         woe_table["LIFT"] = woe_table['AVG_BAD'] / woe_table['AVG_BAD'].mean()
-        woe_table["WOE"] = calc_woe(data=woe_table, bad_pct="BAD_PCT_PER_BIN", good_pct="GOOD_PCT_PER_BIN")
-        woe_table["IV"] = calc_iv(data=woe_table, bad_pct="BAD_PCT_PER_BIN", good_pct="GOOD_PCT_PER_BIN")
+        woe_table["WOE"], woe_table["IV"] = _calc_woe_iv_values(
+            woe_table, "BAD_PCT_PER_BIN", "GOOD_PCT_PER_BIN"
+        )
 
         # WOE Mapping Dictionary
         woe_table = woe_table.reset_index(drop=False)
@@ -300,7 +353,11 @@ class WOETransformer:
                 logging.warning(f"WARNING: {var} WOE values are NOT monotonic in Train Dataset!")
 
         # WOE Mapping to DataFrame
-        train_res[f"{var}_woe"] = train_res[f"_bin_range_{var}"].map(train_woe_mapping_dict)
+        train_res[f"{var}_woe"] = _vectorized_lookup(
+            train_res[f"_bin_range_{var}"],
+            train_woe_mapping_dict.keys(),
+            train_woe_mapping_dict.values(),
+        )
 
         # Drop Bin Info
         if self.drop_bin_info:
@@ -312,7 +369,10 @@ class WOETransformer:
             woe_mapping_table["BIN_NUM"] = woe_mapping_table[f"_bin_num_{var}"]
             woe_mapping_table["VAR"] = var
             oot_res = _mapping_woe_single_var(
-                data=oot_df, var=var, woe_mapping_table=woe_mapping_table
+                data=oot_df,
+                var=var,
+                woe_mapping_table=woe_mapping_table,
+                missing_ref_value=self.fillna,
             )
 
         if self.ret_woe_table and oot_df is not None:
@@ -426,24 +486,12 @@ def convert_single_var_woe(data, var, woe_mapping_table, missing_ref=None, ret_b
     var_woe_mapping = woe_mapping_table.query(f"var_name == '{var}_woe'")
     var_woe_mapping = var_woe_mapping[["bin_no", "bin_value", "woe", "n"]]
 
-    var_woe_mapping["bin_value_list"] = var_woe_mapping["bin_value"].apply(
-        lambda x: x.replace("[", "").replace(")", "").split(",")
-    )
-
-    woe_mapping_dict = dict(zip(var_woe_mapping['bin_no'], var_woe_mapping['woe']))
-    bin_range = [
-        float(v.strip()) if v.strip() != 'inf' else np.inf
-        for x in var_woe_mapping["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)
+    left, right = _parse_bin_range_bounds(var_woe_mapping, col="bin_value")
+    unique_range = np.unique(np.concatenate([left, right])).tolist()
 
-    if missing_ref:
-        var_serires = data[var].fillna(missing_ref)
+    var_serires = data[var]
+    if missing_ref is not None:
+        var_serires = var_serires.fillna(missing_ref)
 
     bin_no_transform = pd.cut(
         var_serires,
@@ -455,9 +503,11 @@ def convert_single_var_woe(data, var, woe_mapping_table, missing_ref=None, ret_b
     if ret_bin_no:
         return bin_no_transform
 
-    woe_res = bin_no_transform.map(woe_mapping_dict)
-
-    return woe_res
+    return _vectorized_lookup(
+        pd.Series(bin_no_transform.astype(object), index=data.index),
+        var_woe_mapping["bin_no"],
+        var_woe_mapping["woe"],
+    )
 
 
 class WOEMappingTransformer:
@@ -727,16 +777,14 @@ def get_woe_table(data, var, dep, grp_name=None, nbins=10, precision=5,
     direction = 1 if dep_slope > 0 else -1 if dep_slope < 0 else 0
 
     if grp_name:
-        slope_grp = pd.DataFrame(
-            gains_table.groupby([grp_name]).apply(calculate_slope_manual, "AVG_BAD"),
-            columns=["SLOPE"]
-        )
+        slope_grp = _vectorized_group_slopes(gains_table, grp_name, "AVG_BAD").to_frame()
         grp_summary = gains_table.groupby([grp_name]).agg(
             N=("N", sum), IV=("IV", sum), KS=("KS_PER_BIN", max),
             BTM_LIFT=("LIFT", min), TOP_LIFT=("LIFT", max)
         ).merge(slope_grp, left_index=True, right_index=True)
-        grp_summary['direction'] = grp_summary['SLOPE'].apply(
-            lambda x: 1 if x > 0 else -1 if x < 0 else 0
+        slope_values = grp_summary["SLOPE"].to_numpy()
+        grp_summary['direction'] = np.select(
+            [slope_values > 0, slope_values < 0], [1, -1], default=0
         )
         grp_woe_pvt = gains_table.pivot_table(
             index=["BIN_NUM", "BIN_RANGE"],
@@ -969,7 +1017,58 @@ def woe_transformation(train_df, varlist, dep, oot_df=None, nbins=10, chi2_confi
     return transformer.transform(train_df, varlist, dep, oot_df)
 
 
-def _mapping_woe_single_var(data, var, woe_mapping_table, suffix="_woe", drop_bin_info=True):
+def _map_woe_arrays(data, var, woe_mapping_table, suffix="_woe", missing_ref_value=-999999):
+    """Return vectorized WOE and bin columns for one feature."""
+    var_woe_mapping = woe_mapping_table.loc[
+        woe_mapping_table["VAR"].eq(var), ["BIN_NUM", "BIN_RANGE", "WOE", "N"]
+    ].copy()
+    if var_woe_mapping.empty:
+        raise KeyError(f"No WOE mapping rows found for variable {var!r}")
+
+    first_range = var_woe_mapping["BIN_RANGE"].astype("string").dropna().iloc[0]
+    include_lowest = first_range.startswith("[")
+    right = first_range.endswith("]")
+    bin_range = get_bin_range_list(var_woe_mapping, col="BIN_RANGE")
+
+    binned, _ = run_binning(
+        data=data[[var]].copy(),
+        column=var,
+        nbins=sorted(set([*bin_range, -np.inf, np.inf])),
+        include_missing=True,
+        equal_freq=True,
+        bin_colnames=("_BIN_NUM_", "_BIN_RANGE_"),
+        ascending=True,
+        include_lowest=include_lowest,
+        right=right,
+        fillna=missing_ref_value,
+    )
+    woe_values = _vectorized_lookup(
+        binned["_BIN_RANGE_"],
+        var_woe_mapping["BIN_RANGE"],
+        var_woe_mapping["WOE"],
+    )
+    missing_count = int(woe_values.isna().sum())
+    if missing_count:
+        logging.warning(f"WARNING: Failed to Map WOE values for {missing_count} Records!")
+
+    return pd.DataFrame(
+        {
+            "_BIN_NUM_": binned["_BIN_NUM_"].to_numpy(copy=False),
+            "_BIN_RANGE_": binned["_BIN_RANGE_"].to_numpy(copy=False),
+            f"{var}{suffix}": woe_values.to_numpy(copy=False),
+        },
+        index=data.index,
+    )
+
+
+def _mapping_woe_single_var(
+    data,
+    var,
+    woe_mapping_table,
+    suffix="_woe",
+    drop_bin_info=True,
+    missing_ref_value=-999999,
+):
     """基于WOE映射表为单个变量映射WOE值。
 
     使用预计算的WOE映射表对新数据进行转换，
@@ -987,6 +1086,9 @@ def _mapping_woe_single_var(data, var, woe_mapping_table, suffix="_woe", drop_bi
         变量名后缀，默认为'_woe'
     drop_bin_info : bool, optional
         是否删除中间分箱信息列，默认为True
+    missing_ref_value : scalar, optional
+        转换缺失值时使用的训练期分箱哨兵，默认 -999999。若训练使用了
+        自定义哨兵，转换时必须传入同一个值。
 
     返回:
     --------
@@ -1000,62 +1102,29 @@ def _mapping_woe_single_var(data, var, woe_mapping_table, suffix="_woe", drop_bi
 #     from Modeling_Tool.Modeling_Tool.Model_Eval_Tool import run_binning
 #     from 代码优化.Model_Eval_Tool import get_bin_range_list
 
-    left = woe_mapping_table.loc[woe_mapping_table["VAR"] == var, "BIN_RANGE"].str[0].unique()[0]
-    right = woe_mapping_table.loc[woe_mapping_table["VAR"] == var, "BIN_RANGE"].str[-1].unique()[0]
-
-    include_lowest = False if left == '(' else True
-    right = False if right == ')' else True
-
-    var_woe_mapping = woe_mapping_table.query(f"VAR == '{var}'")
-    var_woe_mapping = var_woe_mapping[["BIN_NUM", "BIN_RANGE", "WOE", "N"]]
-    bin_range = get_bin_range_list(var_woe_mapping, col="BIN_RANGE")
-    woe_mapping_dict = dict(zip(var_woe_mapping['BIN_RANGE'], var_woe_mapping['WOE']))
-
-    res, edges = run_binning(
-        data=data,
-        column=var,
-        nbins=sorted(set(list(bin_range) + [-np.inf, np.inf])),
-        include_missing=True,
-        equal_freq=True,
-        bin_colnames=(f"_BIN_NUM_", f"_BIN_RANGE_"),
-        ascending=True,
-        include_lowest=include_lowest,
-        right=right
-    )
-
-    res[f"{var}{suffix}"] = res["_BIN_RANGE_"].map(woe_mapping_dict)
-
-    res_woe_table = res.groupby(["_BIN_RANGE_"]).agg(
-        {f"_BIN_RANGE_": "count", var: [min, max], f"{var}{suffix}": [min, max, "mean"]}
-    )
-
-    check_res = res_woe_table.dropna()
-    assert (check_res[(f"{var}{suffix}", "min")] == check_res[(f"{var}{suffix}", "max")]).all(), \
-        f"Error occurred when mapping var: {var}{suffix}"
-    assert data.shape[0] == res.shape[0]
-
-    missing_woe = pd.isnull(res[var + suffix]).sum() > 0
-    if missing_woe:
-        logging.warning(f"WARNING: Failed to Map WOE values for {pd.isnull(res[var + suffix]).sum()} Records!")
-
-    woe = pd.DataFrame(
-        res_woe_table.loc[
-            res_woe_table[(var, "min")] != res_woe_table[(var, "max")],
-            (f"{var}_woe", "mean")
-        ]
+    mapped = _map_woe_arrays(
+        data,
+        var,
+        woe_mapping_table,
+        suffix=suffix,
+        missing_ref_value=missing_ref_value,
     )
-    monotonicity = is_monotonic(woe, (f"{var}_woe", "mean"))
-
-    if monotonicity[0]:
-        logging.warning(f"WARNING: {var} WOE values are NOT monotonic in the given Dataset!")
-
-    if drop_bin_info:
-        res = res.drop(columns=["_BIN_NUM_", "_BIN_RANGE_"])
-
-    return res
-
-
-def mapping_woe(data, varlist, woe_mapping_table, suffix="_woe", drop_bin_info = True):
+    mapped_cols = [f"{var}{suffix}"]
+    if not drop_bin_info:
+        mapped_cols = ["_BIN_NUM_", "_BIN_RANGE_", *mapped_cols]
+
+    base = data.drop(columns=mapped_cols, errors="ignore")
+    return pd.concat([base, mapped[mapped_cols]], axis=1)
+
+
+def mapping_woe(
+    data,
+    varlist,
+    woe_mapping_table,
+    suffix="_woe",
+    drop_bin_info=True,
+    missing_ref_value=-999999,
+):
     """基于WOE映射表批量映射WOE值。
 
     使用预计算的WOE映射表对多个变量进行WOE转换。
@@ -1072,6 +1141,9 @@ def mapping_woe(data, varlist, woe_mapping_table, suffix="_woe", drop_bin_info =
         变量名后缀，默认为'_woe'
     drop_bin_info : bool, optional
         是否删除中间分箱信息列，默认为True
+    missing_ref_value : scalar, optional
+        转换缺失值时使用的训练期分箱哨兵，默认 -999999。若训练使用了
+        自定义哨兵，转换时必须传入同一个值。
 
     返回:
     --------
@@ -1082,13 +1154,27 @@ def mapping_woe(data, varlist, woe_mapping_table, suffix="_woe", drop_bin_info =
     --------
     >>> result = mapping_woe(df, ['var1', 'var2'], woe_table)
     """
-    transformer = WOEMappingTransformer(
-        woe_mapping_table=woe_mapping_table,
-        suffix=suffix
-#         drop_bin_info=drop_bin_info
-    )
-    res = data.copy()
+    woe_columns = {}
+    last_bin_columns = None
     for var in varlist:
-        res = _mapping_woe_single_var(data=res, var=var, woe_mapping_table=woe_mapping_table,
-                                       suffix=suffix, drop_bin_info=drop_bin_info)
-    return res
+        mapped = _map_woe_arrays(
+            data,
+            var,
+            woe_mapping_table,
+            suffix=suffix,
+            missing_ref_value=missing_ref_value,
+        )
+        woe_columns[f"{var}{suffix}"] = mapped[f"{var}{suffix}"].to_numpy(copy=False)
+        last_bin_columns = mapped[["_BIN_NUM_", "_BIN_RANGE_"]]
+
+    output_cols = list(woe_columns)
+    if not drop_bin_info:
+        output_cols.extend(["_BIN_NUM_", "_BIN_RANGE_"])
+    base = data.drop(columns=output_cols, errors="ignore").copy()
+
+    frames = [base]
+    if not drop_bin_info and last_bin_columns is not None:
+        frames.append(last_bin_columns)
+    if woe_columns:
+        frames.append(pd.DataFrame(woe_columns, index=data.index))
+    return pd.concat(frames, axis=1)

{supermodelingfactory-0.5.9 → supermodelingfactory-0.5.10}/Modeling_Tool/WOE/WOE_Tool.pyi

@@ -38,4 +38,4 @@ def get_woe_table(data, var, dep, grp_name = None, nbins = 10, precision = 5, mi
 def plot_monotonicity_check(data, column, title = None, include_missing = True): ...
 def woe_transform(train_df, var, dep, nbins, oot_df = None, chi2_config = None, tree_binning_seed = None, precision = 5, min_bin_prop = 0.05, include_missing = False, equal_freq = True, ascending = True, fillna = -999999, spec_values = None, drop_bin_info = True, ret_woe_table = True, check_monotonicity = False): ...
 def woe_transformation(train_df, varlist, dep, oot_df = None, nbins = 10, chi2_config = None, tree_binning_seed = None, precision = 5, min_bin_prop = 0.05, include_missing = False, equal_freq = True, fillna = -999999, spec_values = None, drop_bin_info = True, ret_woe_table = True): ...
-def mapping_woe(data, varlist, woe_mapping_table, suffix = '_woe', drop_bin_info = True): ...
+def mapping_woe(data, varlist, woe_mapping_table, suffix = '_woe', drop_bin_info = True, missing_ref_value = -999999): ...

{supermodelingfactory-0.5.9 → supermodelingfactory-0.5.10}/Modeling_Tool/__init__.py

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 __author__ = "Jingkai Sun"
-__version__ = "0.5.9"
+__version__ = "0.5.10"
 
 from ._utils import SMF_MISSING_BIN
 

{supermodelingfactory-0.5.9 → supermodelingfactory-0.5.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SuperModelingFactory
-Version: 0.5.9
+Version: 0.5.10
 Summary: Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting.
 Home-page: https://github.com/Kyle-J-Sun/SuperModelingFactory
 Author: Kyle Sun
@@ -265,7 +265,7 @@ em.close_workbook()
 
 ## 版本
 
-- **Version**: 0.5.9
+- **Version**: 0.5.10
 - **Author**: Jingkai Sun
 
 ## 许可证

{supermodelingfactory-0.5.9 → supermodelingfactory-0.5.10}/README.md

@@ -208,7 +208,7 @@ em.close_workbook()
 
 ## 版本
 
-- **Version**: 0.5.9
+- **Version**: 0.5.10
 - **Author**: Jingkai Sun
 
 ## 许可证

{supermodelingfactory-0.5.9 → supermodelingfactory-0.5.10}/SuperModelingFactory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SuperModelingFactory
-Version: 0.5.9
+Version: 0.5.10
 Summary: Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting.
 Home-page: https://github.com/Kyle-J-Sun/SuperModelingFactory
 Author: Kyle Sun
@@ -265,7 +265,7 @@ em.close_workbook()
 
 ## 版本
 
-- **Version**: 0.5.9
+- **Version**: 0.5.10
 - **Author**: Jingkai Sun
 
 ## 许可证

{supermodelingfactory-0.5.9 → supermodelingfactory-0.5.10}/pyproject.toml

@@ -12,7 +12,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "SuperModelingFactory"
-version = "0.5.9"
+version = "0.5.10"
 description = "Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting."
 readme = "README.md"
 requires-python = ">=3.10"

{supermodelingfactory-0.5.9 → supermodelingfactory-0.5.10}/setup.py

@@ -15,7 +15,7 @@ def _read(path: str) -> str:
 
 setup(
     name="SuperModelingFactory",
-    version=os.environ.get("SMF_VERSION", "0.5.9"),
+    version=os.environ.get("SMF_VERSION", "0.5.10"),
     description="Credit risk modeling factory: WOE binning, scorecards, LightGBM, Excel reporting.",
     long_description=_read("README.md"),
     long_description_content_type="text/markdown",