有帮助要帮我点赞哦
可以依据现在的流程，结合实际数据情况进行调整。
流程框架：
- eda
- 查看字段相似性，提炼相似字段
- 初步分箱
- 必要时展开二次分箱（或者多轮分箱调优）
- 可以进一步查看分箱后字段的相似性(woe值转化之后)
- 查看分箱效果
介绍的具体目录⬇️
（当前只试用了决策树分箱和等频｜等距的简单分箱、不均衡分箱，一些其它分箱手段，后续可以在这些方面补充一下）
文章目录
查看字段相似性
1.相似矩阵图
# 相似矩阵
import matplotlib.pyplot as plt
import seaborn as sns
# 多变量分析
corr = df_train.corr() # 相关性系数图
cmap = sns.diverging_palette(200, 20, sep=20, as_cmap=True)
f, ax = plt.subplots(figsize=(15, 10))
sns.heatmap(corr, annot=True, cmap=cmap, annot_kws={'size': 10}, linewidths=.5, fmt= '.3f',ax=ax)
plt.show()
2.拉取高相似度的字段
# 筛选完全相似的列表团
def filter_sim_li(cal_li):
# 过滤单个列表
def len_li(x):
return len(x) - 1
# 过滤掉单个的列表
cal_li = list(filter(len_li, cal_li))
set_tmp = set()
len_tmp = 0
res_dict = dict()
for each in cal_li:
each.sort() # 排序，不然比较结果受元素顺序影响
aa = tuple(each)
set_tmp.add(aa)
if len_tmp == len(set_tmp):
res_dict[aa] += 1
else:
res_dict[aa] = 0
len_tmp = len(set_tmp)
# 过滤字典键值对函数
def filter_dict(pair):
key, value = pair
if value > 0:
return True
else:
return False
filtered_res = dict(filter(filter_dict, res_dict.items())) # 记一下
return list(filtered_res.keys())
def extract_corr(df, lim_val=0.8):
"""
提取给出相似字段的dict，默认筛选阈值为0.8，给出df中与字段a相似性大于等于0.8的字段列表
:param df: 需要计算相似性的dataframe
:param lim_val: 给定的筛选阈值，默认为0.8
:return: 返回高相似度的字典，键为df中存在高相似度的字段，值为相似度高的字段列表 以及 完全相似的字段组
"""
corr_df = df.corr()
corr_df['sim_li'] = corr_df.apply(lambda x: list(x[x >= lim_val].index) if any(x) >= lim_val else None, axis=1)
corr_df['col_name'] = list(corr_df.index)
corr_df['con_dict'] = corr_df[['sim_li', 'col_name']].apply(lambda x:
{x[1]: list(set(x[0]) - set(x[1]))}
if len(x[0]) > 1 else None, axis=1)
filter_col = list(filter(None, list(corr_df['con_dict'])))
corr_cluster = filter_sim_li(corr_df['sim_li'])
return filter_col, corr_cluster
test_a, test_b = extract_corr(df_train, lim_val=0.8) # 查看高相似性的字段详情
去除异常值
实施建议
- 数据量少的时候谨慎处理
- 可以结合具体的分箱方法再来看要不要去除
- 如果使用pd.cut方法，需要根据区间长度等分，异常值会对结果影响较大
- 如果使用qcut或者其它方法，异常值的影响可能相对较小，确定边界后包含异常值情况即可
- 可以先不去除，分箱看一下效果再进行必要地修订
def remove_outliers(df, min_dict=None, max_dict=None, min_lim=0.01, max_lim=0.99):
"""
分箱前用来去除异常值，不给定min_lim,max_lim的话，默认去除前1%和后1%的数据，
min_dict,max_dict可以用来单独调节部分特征的阈值
:param df: 传入的dataframe（不包含标签列）
:param min_dict: dict,给出需要手动调节的特征最小阈值
:param max_dict: dict,给出需要手动调节的特征最大阈值
:param min_lim: float，去除前百分之多少分位数的值，0.01为前1%的数据
:param max_lim: float，去除后百分之多少分位数的值,0.99为后1%的数据
:return: df,删除异常值后的数据
"""
describe_val = df.describe([min_lim, max_lim])
col_list = [f'{int(each*100)}%' for each in [min_lim, max_lim]]
out_lim = describe_val.loc[col_list, :].to_dict('records')
min_line = out_lim[0] # 最小边界
max_line = out_lim[1] # 最大边界
# 如果有值要替换的话
if min_dict:
min_line.update(min_dict)
if max_dict:
max_line.update(max_dict)
for each in min_line.keys():
print(each)
print('cut范围：', [min_line[each], max_line[each]+0.000001])
x = pd.cut(df[each], [min_line[each], max_line[each]+0.000001], right=False)
print('drop数量：', x.isnull().sum())
df = df[x.notnull()]
return df
min_dict_1 = {'NumberRealEstateLoansOrLines': 2.0, 'NumberOfTimes90DaysLate': 0.1}
df_train = remove_outliers(df_train, min_lim=0.01)
df_train3 = remove_outliers(df_train, min_dict_1, min_lim=0.01)
分箱
1.初步分箱（等距｜等频分箱）
使用了等距分箱和等频分箱两种，可以用来初步尝试分箱效果。
-
等距分箱
优点：初步按照距离直接分割，较为简单
缺点：受异常值影响大 -
等频分箱
优点：按照分位数等分，每组内的数据量较为均衡
缺点：数据分布不均衡，大部分为1个值时，分割边界不好处理，如指定分为4组，前2组均为同一个值时会合并分组
实施建议：
结合前面数据探查的结果，可以用于初次分箱查看分箱效果时使用
批量使用，大致粗略查看
效果好的：微调，直接应用该分箱方案
效果不好的字段进行细调，或者尝试其它分箱方案
# (和前面去除异常值的自定义逻辑差不多，在等距or分位数分割基础上自定义修改)
def n_cut(df, cut_num=4, right=False, define_col=None, if_cut=True):
"""
用于等距分箱，默认所有字段都分4组，给定define_col的话对指定字段的分箱数进行修改
:param df: 传入待分箱的dataframe（不包含标签列）
:param cut_num: int，设置的分箱数（小于4组时，会按照实际存在的类别分）
:param right: bool，等距分箱cut时，False为左闭右开，True为左开右闭）
:param define_col: dict，对指定字段a设置其分箱数
:param if_cut: bool，默认为True，用等距分箱cut，False时使用等频分箱qcut
:return: 所有列的分箱结果
"""
if if_cut:
df_cut = df.apply(lambda x: pd.cut(x, cut_num, right=right)) # 先按照默认箱数等距分组
if define_col:
col_li = [each for each in define_col.keys()]
for each in col_li:
df_cut[each] = df[[each]].apply(lambda x: pd.cut(x, bins=define_col[each], right=right))
else:
df_cut = df.apply(lambda x: pd.qcut(x, cut_num, duplicates='drop')) # 先按照默认箱数等频分组
if define_col:
col_li = [each for each in define_col.keys()]
for each in col_li:
df_cut[each] = df[[each]].apply(lambda x: pd.qcut(x, q=define_col[each], duplicates='drop'))
return df_cut
ll1 = n_cut(df_train, cut_num=4, define_col={'age': 5}, if_cut=0)
ll = n_cut(df_train, 4)
2.决策树分箱
利用决策树的划分边界来作为分箱依据，可以在此基础上做进一步调整
(线上数据常出现的一个问题是“会返回一个单一区间，没有分割”，线下不知道能不能复现这个问题
推测还是和数据不均衡有关，我们设置了叶子结点样本数量最小占比
如果再遇到此类问题，可以尝试关闭｜调节该参数)
def optimal_binning_boundary(x: pd.Series, y: pd.Series, nan: float = -999., cut_num = 4) -> list:
"""
利用决策树获得最优分箱的边界值列表
"""
boundary = [] # 待return的分箱边界值列表
x = x.fillna(nan).values # 填充缺失值
y = y.values
clf = DecisionTreeClassifier(criterion='entropy', # “信息熵”最小化准则划分
max_leaf_nodes=cut_num, # 最大叶子节点数
min_samples_leaf=0.05) # 叶子节点样本数量最小占比
clf.fit(x.reshape(-1, 1), y) # 训练决策树
# fig = plt.figure(figsize=(15, 10))
# _ = tree.plot_tree(clf,
# feature_names=features,
# # class_names=,
# filled=True)
# plt.show()
n_nodes = clf.tree_.node_count
children_left = clf.tree_.children_left
children_right = clf.tree_.children_right
threshold = clf.tree_.threshold
for i in range(n_nodes):
if children_left[i] != children_right[i]: # 获得决策树节点上的划分边界值
boundary.append(threshold[i])
boundary.sort()
z = 0.0000000001
min_x = x.min()
max_x = x.max() + z # +0.1是为了考虑后续groupby操作时，能包含特征最大值的样本
boundary = [min_x] + boundary + [max_x]
return boundary
# 测试optimal_binning_boundary函数：
optimal_binning_boundary(x=train_data['RevolvingUtilizationOfUnsecuredLines'],
y=train_data['SeriousDlqin2yrs'])
上面是提取边界函数
下面是分割
def tree_cut(df, cut_num=4, right=False, define_col=None, label_name='label'):
"""
通过决策树获得划分边界，对数据进行分割，默认为4组分箱，可针对不同字段进行人工调节
:param df: 传入待分箱的dataframe
:param cut_num: int，设置的分箱数（小于4组时，会按照实际存在的类别分）
:param right: bool，False为左闭右开，True为左开右闭）
:param define_col: dict，对指定字段a设置其分箱数
:return: 所有列的分箱结果
"""
df_cut = pd.DataFrame()
if define_col:
col_name = list(set(df.columns) - set(define_col.keys()) - set(label_name))
else:
col_name = list(filter(None, [each if each != label_name else None for each in [*df.columns]]))
for each in col_name:
tree_boundary = optimal_binning_boundary(x=train_data[each],
y=train_data[label_name],
cut_num=cut_num)
df_cut[each] = pd.cut(df[each], bins=tree_boundary, right=right)
if define_col:
for each in define_col.keys():
tree_boundary = optimal_binning_boundary(x=train_data[each],
y=train_data[label_name],
cut_num=define_col[each])
df_cut[each] = pd.cut(df[each], bins=tree_boundary, right=right)
return df_cut
ll = tree_cut(df_train,label_name='SeriousDlqin2yrs')
3.处理不均衡分箱
用于数据分布严重不均衡的时候，eg：前60%都是0，到70%之后开始有值，取我们在分位数上的第一个值作为分箱边界划分时的最小值，切分有值后的区间，想要让前面的0值区域划分为一个单独区间时。
[0,0,0,0,0,1,3,4]
前面-1to0为一个区间（即所有0是一个区间，-1为自动补充的）
1到后面作为一个区间开始划分
以numberofdependents字段为例：
numberofdependents前60%都是0，到70%之后开始有值，-1到0为第一个区间
得到的边界为[-1, 0, 1.0, 1.33, 1.67, 2.0, 4.0]
# 实现一下简单分箱(等距，等频，自定义修改箱数)
# 处理不均衡分箱
def pre_boundary(df):
"""
处理不均衡分箱
:param df: 传入的dataframe
:return: 划分的切割边界
"""
if df['95%'] > 0:
tmp = [.6, .7, .8, .9, .95, .99]
q_val = df[[f"{int(each*100)}%" for each in tmp]].values.tolist()
boundary_1 = list(filter(None, [each if each > 0 else None for each in q_val]))[0]
boundary_2 = list(filter(None, [each if each > 0 else None for each in q_val]))[1]
cut_boundary = [round(each, 2) for each in list(np.linspace(boundary_1, boundary_2, 4))]
if df['min'] == 0:
return [-1, 0] + cut_boundary + [df['max']]
else:
return [df['min']] + [0] + cut_boundary + [df['max']]
else:
return None
# des_count = df_all0.describe([.6, .7, .8, .9, .95, .99]).T
# des_count['boundary'] = des_count.apply(lambda x:pre_boundary(x),axis=1)
上面这个是针对不均衡数据调试时采用的分箱函数，返回的是各字段的切割边界。
统计分箱效果
1.计算woe值，iv值等
bins_count函数,给定分好箱的df，返回计算的woe、iv值等结果。
# 初步查看各组分箱效果
def bins_count(df, df_label):
"""
计算分箱效果
:param df: dataframe，查看分箱的列
:param df_label: dataframe，标签列（一定要是dataframe，不能是series）
:return: result_df(指标计算结果)，col_iv(各特征的iv值)
"""
df_label.columns = ['y']
fe_li = df.columns
df = pd.concat([df, df_label],axis=1)
result_df = pd.DataFrame()
for each in fe_li:
# print(each)
grouped = df.groupby(each)['y'] # 统计各分箱区间的好、坏、总客户数量
result_df0 = grouped.agg([('good', lambda y: (y == 0).sum()),
('bad', lambda y: (y == 1).sum()),
('total', 'count')])
result_df0['good_pct'] = result_df0['good'] / result_df0['good'].sum() # 好客户占比
result_df0['bad_pct'] = result_df0['bad'] / result_df0['bad'].sum() # 坏客户占比
result_df0['total_pct'] = result_df0['total'] / result_df0['total'].sum() # 总客户占比
result_df0['bad_rate'] = result_df0['bad'] / result_df0['total'] # 坏比率
result_df0['woe'] = np.log(result_df0['good_pct'] / result_df0['bad_pct']) # WOE
result_df0['iv'] = (result_df0['good_pct'] - result_df0['bad_pct']) * result_df0['woe'] # IV
# print(result_df0)
# result_df0 = result_df0.reset_index(names='bins') # 根据pandas版本，看能不能用names
result_df0.index.name = 'bins'
result_df0 = result_df0.reset_index()
result_df0['bin_names'] = each
result_df = result_df.append(result_df0)
col_iv = result_df.groupby('bin_names')['iv'].sum().sort_values(ascending=False)
return result_df[['bins', 'bin_names', 'good', 'bad', 'total', 'bad_rate', 'woe', 'iv']], col_iv
cc, bb = bins_count(ll, df_train[['SeriousDlqin2yrs']])
tmp = cc.query("bin_names == 'age'")
eg中的输入：
-
ll为分箱好后的各字段
-
dataframe形式的y标签
eg中的输出： -
cc为各字段各分箱下的统计结果
-
bb为各字段的信息值（可以根据此结果从筛选过滤字段后，再进行二次分箱调节）
2.异常情况处理——woe、iv值出现∞
可以参考下面几个文档的内容：
- 本质上还是采样问题，可以调整融合分箱或者重新采样，使得样本里尽可能包含各种情况下的预测目标
这个解答下面还提到的另外两个点，大意都是调整调整分箱边界
- 如果为了快速处理，也可以参照第三个链接，把woe值的计算公式做一个小的处理
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
https://blog.csdn.net/weixin_44625028/article/details/123716573
3.异常情况处理——字段iv值很大
这里需要注意一个问题是：
- 不同的文档可能略有差异，但一般iv值低于0.03我们就不认为其具有区分力度了。IV在0.1到0.5之间的变量通常具有中等-高区分性，可以优先入模。
- 如果iv值过大了，很高了，可能意味着该变量为滞后变量，需要结合业务逻辑进行辨别。
（IV一般用于变量筛选。IV值过低的变量不具有区分能力，还可能对模型产生干扰，应该予以舍弃。正常情况下，IV在0.1到0.5之间的变量都可以先加入模型。
IV过高并不是好事，需要警惕。它说明这个变量对y的区分度极好。很有可能它是滞后变量。比如B卡中的某些贷后变量就可能会有很高的IV值。此时需要结合业务逻辑进行排查。）
参考链接：https://zhuanlan.zhihu.com/p/110369440?utm_source=qq&utm_id=0
初步绘图查看分箱效果
1.单个字段绘图
绘制单个变量各分箱的好坏数量以及bad_rate(这里目前是bad_rate，如果不想那么严格要求bad_rate的话，后面也可以换成woe值，保证woe值单调就可以了)
def plot_box_result(df, col_name):
tmp = df[df['bin_names'] == col_name]
fig, ax = plt.subplots(1, 1, figsize=(10,10))
sns.barplot(x=tmp.bins, y=tmp.total, color="#0000A3")
bottom_plot = sns.barplot(x=tmp.bins, y=tmp.good, color="red")
topbar = plt.Rectangle((0, 0), 1, 1, fc="#0000A3", edgecolor='none')
bottombar = plt.Rectangle((0, 0), 1, 1, fc='red', edgecolor='none')
l = plt.legend([bottombar, topbar], ['good', 'bad'], loc=2, ncol=1, prop={'size': 10})
l.draw_frame(False)
ax2 = ax.twinx() # 一定要放在这里啊
sns.lineplot(x=tmp["bins"].astype(str), y="bad_rate", data=tmp,
marker='o', lw=3, color="#0000A3",
linestyle='--', markeredgecolor='#0000A3', ax=ax2)
plt.title(col_name)
plt.show() # 明天对照着收藏夹整理一下这部分画图
plot_box_result(cc, 'age') # cc是前面bins_count的产出
这个age分箱还可以，bad_rate单调性很明显
2.对比多个字段一起查看
def plot_filteredfe(df, bb):
aa = bb[bb > 0.03]
fig_num = aa.shape[0]
fig_col = 3 # 一行最多画3张图
fig_row = math.ceil(fig_num / fig_col)
fig, axs = plt.subplots(fig_row, fig_col, figsize=(8 * fig_col, 8 * fig_row)) # larger figure size for subplots
# ax2s = axs.twinx() # 一定要放在这里啊
# fig.tight_layout()
for i in range(fig_num):
tmp = df[df['bin_names'] == bb.index[i]]
col_name = aa.index[i]
if (i+1) % fig_col != 0:
xx = (i+1) % fig_col - 1
yy = (i+1)//fig_col
else:
xx = fig_col - 1
yy = (i+1)//fig_col - 1
# print(yy,xx)
ax1 = axs[yy][xx]
# ax = axs[0]
# print(ax.rowNum,ax.colNum)
sns.barplot(x=tmp.bins, y=tmp.total, color="#0000A3", ax=ax1)
bottom_plot = sns.barplot(x=tmp.bins, y=tmp.good, color="red", ax=ax1)
# topbar = plt.Rectangle((0, 0), 1, 1, fc="#0000A3", edgecolor='none')
# bottombar = plt.Rectangle((0, 0), 1, 1, fc='red', edgecolor='none')
# l = plt.legend([bottombar, topbar], ['good', 'bad'], loc=2, ncol=1, prop={'size': 10})
# l.draw_frame(False)
ax2 = ax1.twinx() # 一定要放在这里啊
# ax2 = ax2s[yy][xx]
# print('ax2',ax2.rowNum,ax2.colNum)
sns.lineplot(x=tmp["bins"].astype(str), y="bad_rate", data=tmp,
marker='o', lw=3, color="#0000A3",
linestyle='--', markeredgecolor='#0000A3', ax=ax2)
plt.title(col_name)
plt.subplots_adjust(wspace=0.4,hspace=0.3)
plt.show()
plot_filteredfe(cc, bb)
3.jupyter中直接查看df
tmp是之前bins_count计算出来的统计结果
display(tmp.style.bar(color=['#d65f5f', '#5fba7d'], align='mid', subset=['bad_rate','woe'])) # 可以快速查看bad_rate和woe
评分卡工具
1.第三方python库–OptBinning(重点，单开一篇介绍)
OptBinning is a library written in Python implementing a rigorous and flexible mathematical programming formulation to solve the optimal binning problem for a binary, continuous and multiclass target type, incorporating constraints not previously addressed.
先大概看一下有哪些应用范畴，好的话可以专门开一篇介绍。
git地址：https://github.com/guillermo-navas-palencia/optbinning/tree/master（还放了两片文章，好像和流数据分箱相关，另外这个库的教程写的不是很全面，如后面涉及optimal piecewise binning的OptimalPWBinning，感觉他描述的并不是很全面，需要结合他的文章再看一下才能理解它这个piecewise的概念（目前看感觉是不均匀的分箱，每段分箱间距都不一样！！！））
教程地址：https://gnpalencia.org/optbinning/tutorials.html#optimal-binning-tutorials
另：
这个创作者的博客还记载了另外一个软件用于ab test(ab测试)：https://gnpalencia.org/software.html
2.第三方python库–toad
Toad is dedicated to facilitating model development process, especially for a scorecard. It provides intuitive functions of the entire process, from EDA, feature engineering and selection etc. to results validation and scorecard transformation. Its key functionality streamlines the most critical and time-consuming process such as feature selection and fine binning.
Toad 是专为工业界模型开发设计的Python工具包，特别针对评分卡的开发。Toad 的功能覆盖了建模全流程，从 EDA、特征工程、特征筛选 到 模型验证和评分卡转化。Toad 的主要功能极大简化了建模中最重要最费时的流程，即特征筛选和分箱。
git地址：
https://github.com/amphibian-dev/toad
这个是中文的哦～
-
一个总结
比较全的评分卡工具介绍可以看这里：
https://mp.weixin.qq.com/s/-WO74VGu83LqNtM7VrSzOQ -
一个总结
这里的最下面也有：
https://mp.weixin.qq.com/s/mzfLqhld_OcXMsjiMcx8FQ
它给出的建议是：
一般，评分卡只要用optbinning 与 toad 就够了。 -
alpha tools（付费的，博客里面为了恰饭推荐的，哈哈哈，感觉不是非常不会编程，可以不看这个工具）
这个人的博客里面有提及，但还没有仔细看：https://zhuanlan.zhihu.com/p/521833066
4127
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
