【转】决策树分箱、卡方分箱、bestks以及评价标准WOE和IV值

最新推荐文章于 2024-07-02 21:12:53 发布

Just Jump

最新推荐文章于 2024-07-02 21:12:53 发布

阅读量2.8k

点赞数 2

分类专栏：特征工程文章标签：数据挖掘机器学习特征分箱

原文链接：https://www.bilibili.com/read/cv12971807

版权

特征工程专栏收录该内容

22 篇文章 2 订阅

订阅专栏

转自：

WOE编码与IV值_咔咔响-CSDN博客1.woe又叫证据权重，用来衡量对先验认识修正的增量2.woe的实质是表示当前分箱中好坏客户的各自占总体好坏客户比例的差异3.woe可以将非线性变量线性处理化，提高业务解释性4.woe能...https://blog.csdn.net/qq_27388259/article/details/112168938

WOE：分组中正样本占比 / 负样本占比

对数据集进行最优分箱和WOE转换 - Reynold.C - 博客园对数据集分箱的方式三种，等宽等频最优，下面介绍对数据集进行最优分箱，分箱的其他介绍可以查看其他的博文，具体在这就不细说了：大体步骤： woe.py conf.py woe_executor.py thttps://www.cnblogs.com/leixingzhi7/p/9366908.html

https://github.com/boredbird/woe/tree/master/woehttps://github.com/boredbird/woe/tree/master/woe

决策树分箱、卡方分箱、bestks以及评价标准WOE和IV) - 哔哩哔哩特征工程之特征分箱：决策树分箱、卡方分箱、bestks以及评价标准1.WOE和IV2.无监督分箱2.1等频分箱2.2等距分箱3.有监督分箱3.1决策树分箱3.2best-ks分箱3.3卡方分箱前言：在做数据挖掘项目的时候，特征工程通常是其中非常重要的一个环节，但是难度也比较高，并且不同项目特征工程会有所差异，因此在做相关项目时可以多总结一些对结果提升比较明显的操作，近期做了一下天池上面的入门金融风控的项目，发现在对部分连续变量和离散变量进行分箱之后和woe编码后效果有一定提升。废话不多说进入正题https://www.bilibili.com/read/cv12971807视频：python信用评分卡建模（附代码）视频教程系列_哔哩哔哩_bilibilipython信用评分卡建模（附代码）视频教程系列网校主页https://study.163.com/provider/400000000398149/index.htm?share=2&shareId=400000000398149该视频课程完整课程和数据脚本下载链接：https://study.163.com/course/courseMain.htm?courseId=10052140https://www.bilibili.com/video/BV157411k7Jw

特征工程之特征分箱：决策树分箱、卡方分箱、bestks以及评价标准

1.WOE和IV
2.无监督分箱
2.1等频分箱
2.2等距分箱
3.有监督分箱
3.1决策树分箱
3.2best-ks分箱
3.3卡方分箱

前言：在做数据挖掘项目的时候，特征工程通常是其中非常重要的一个环节，但是难度也比较高，并且不同项目特征工程会有所差异，因此在做相关项目时可以多总结一些对结果提升比较明显的操作，近期做了一下天池上面的入门金融风控的项目，发现在对部分连续变量和离散变量进行分箱之后和woe编码后效果有一定提升。

废话不多说进入正题：在特征工程我们通常可以对连续值属性进行分箱操作（也就是常说的离散化），并且对于取值较多的离散变量也可进行分箱操作，分箱之后主要有以下好处：

    分箱后的特征对异常数据有更好的鲁棒性。例如年龄中含有200，300这类的数据，分箱之后就可能划到>80这一箱中，但是如果直接传入模型训练的话会对模型造成很大干扰。
    可以将变量转换到相似的尺度上。例如收入有1000，10000，百万，千万等，可以离散化为0（低收入），1（中等收入），2（高收入）等。
    离散后的变量方便我们做特征交叉。例如将离散后的特征与连续变量进行groupby，构造均值、方差等。
    缺失值的处理，可以将缺失值合并为一个箱。

并且分箱我们通常会遵循以下原则：

    组内差异小
    组间差异大
    每组占比不小于5%
    必须有好坏两种分类（对于二分类而言）

对于某个属性分箱过后的结果是好还是坏，我们可以使用WOE和IV进行评估。
1.WOE和IV

（1）WOE（Weight Of Evidence），即证据权重，其表达式如下：

示例WOE编码与IV值_咔咔响-CSDN博客

举一个例子说明，对于特征F1和F2，都只有两种取值1和0，它们对同一目标变量响应如下

F1	Bad(Y=1)	Good(Y=0)	rate	woe
1	90	10	0.1%	4.394
0	9910	89990	99.9%	-0.009
All	10000	90000	-	-

F2	Bad(Y=1)	Good(Y=0)	rate	woe
1	6000	600	6.6%	4.500
0	4000	89400	93.4%	-0.910
All	10000	90000	-	-

含义解释：正负样本量、；具有特征值的正负样本数，特征覆盖样本率；

注：rate表示落入该箱子的总客户数占总体客户数的比例

F1	woe	IV
1	4.394	0.0391
0	-0.009	0.0001
总计	4.386	0.0391

F2	woe	IV
1	4.500	2.6699
0	-0.910	0.5397
总计	3.590	3.2096

woe和iv的python实现：

def WOE(data, feat, label):

    bin_values = data[feat].unique()
    good_total_num = len(data[data[label]==1])
    bad_total_num = len(data[data[label]==0])

    woe_dic = {}
    df = pd.DataFrame()
    for i,val in enumerate(bin_values):
        good_num = len(data[(data[feat]==val) & (data[label]==1)])
        bad_num = len(data[(data[feat]==val) & (data[label]==0)])
        df.loc[i,feat] = val
        df.loc[i, feat+'_woe'] = np.log( (good_num/good_total_num) / ((bad_num/bad_total_num+0.0001)) )
        woe_dic[val] = np.log( (good_num/good_total_num) / ((bad_num/bad_total_num+0.0001)) )

    return woe_dic,df

def IV(data, woe_dic, feat, label):
    good_total_num = len(data[data[label] == 1])
    bad_total_num = len(data[data[label] == 0])
    bin_values = data[feat].unique()
    feat_IV = 0
    for val in bin_values:
        woe = woe_dic[val]
        good_num = len(data[(data[feat] == val) & (data[label] == 1)])
        bad_num = len(data[(data[feat] == val) & (data[label] == 0)])

        feat_IV += ((good_num/good_total_num)-(bad_num/bad_total_num))*woe

    return feat_IV 作者：python风控模型 https://www.bilibili.com/read/cv12971807 出处：bilibili

知道了特征分箱后的评估方法之后就可以考虑如何进行分箱。而分箱的方法主要分为两大类：无监督分箱（等频分箱、等距分箱），有监督分箱（best-ks分箱、决策树分箱、卡方分箱）。
2.无监督分箱
2.1等频分箱

等频分箱的意思就是分箱之后，每个箱内的数据量相等。可以用pandas提供的qcut方法进行处理。
2.2等距分箱

等距分箱就是每个箱的区间的大小是相等的，每个箱内的数据量不一定相等。

例子：

import pandas as pd
import numpy as np

data = np.random.randn(100)
#等频分箱
data_bins = pd.qcut(data, q=5)
print(data_bins.value_counts())
#等距分箱
data_bins = pd.cut(data,bins=5)
print(data_bins.value_counts()) 作者：python风控模型 https://www.bilibili.com/read/cv12971807 出处：bilibili

输出结果：通过结果我们也能很明显看出两种分箱的差异

(-2.554, -0.844]    20
(-0.844, -0.153]    20
(-0.153, 0.25]      20
(0.25, 1.049]       20
(1.049, 2.385]      20
dtype: int64
(-2.558, -1.566]     6
(-1.566, -0.578]    21
(-0.578, 0.41]      43
(0.41, 1.397]       21
(1.397, 2.385]       9
dtype: int64 作者：python风控模型 https://www.bilibili.com/read/cv12971807 出处：bilibili

3.有监督分箱
3.1决策树分箱

决策树分箱的原理就是用想要离散化的变量单变量用树模型拟合目标变量，例如直接使用sklearn提供的决策树（是用cart决策树实现的），然后将内部节点的阈值作为分箱的切点。

补充，cart决策树和ID3、C4.5决策树不同，cart决策树对于离散变量的处理其实和连续变量一样，都是将特征的所有取值从小到大排序，然后取两两之间的均值，然后遍历所有这些均值，然后取gini系数最大的点作为阈值进行划分数据集。并且该特征后续还可参与划分。

python实现：

from sklearn.tree import DecisionTreeClassifier
def optimal_binning_boundary(x, y):
    '''
        利用决策树获得最优分箱的边界值列表,利用决策树生成的内部划分节点的阈值，作为分箱的边界
    '''
    boundary = []  # 待return的分箱边界值列表

    x = x.fillna(-1).values  # 填充缺失值
    y = y.values

    clf = DecisionTreeClassifier(criterion='entropy',  # “信息熵”最小化准则划分
                                 max_leaf_nodes=6,  # 最大叶子节点数
                                 min_samples_leaf=0.05)  # 叶子节点样本数量最小占比

    clf.fit(x, y)  # 训练决策树

    #tree.plot_tree(clf) #打印决策树的结构图
    #plt.show()

    n_nodes = clf.tree_.node_count #决策树的节点数
    children_left = clf.tree_.children_left #node_count大小的数组，children_left[i]表示第i个节点的左子节点
    children_right = clf.tree_.children_right #node_count大小的数组，children_right[i]表示第i个节点的右子节点
    threshold = clf.tree_.threshold #node_count大小的数组，threshold[i]表示第i个节点划分数据集的阈值

    for i in range(n_nodes):
        if children_left[i] != children_right[i]:  # 非叶节点
            boundary.append(threshold[i])

    boundary.sort()

    min_x = x.min()
    max_x = x.max() + 0.1  # +0.1是为了考虑后续groupby操作时，能包含特征最大值的样本
    boundary = [min_x] + boundary + [max_x]

    return boundary 作者：python风控模型 https://www.bilibili.com/read/cv12971807 出处：bilibili

3.2best-ks分箱

KS（Kolmogorov Smirnov）用于模型风险区分能力进行评估，指标衡量的是好坏样本累计部分之间的差距。KS值越大，表示该变量越能将正，负客户的区分程度越大。通常来说，KS>0.2即表示特征有较好的准确率。

KS的计算方式：计算分箱后每组的好账户占比和坏帐户占比的差值的绝对值： ∣ g o o d 占比 − b a d 占比 ∣ |good占比-bad占比| ∣good占比−bad占比∣，然后取所有组中最大的KS值作为变量的KS值。

best-ks分箱的原理：

    将变量的所有取值从小到大排序
    计算每一点的KS值
    选取最大的KS值对应的特征值 x m x_m xm，将特征x分为 x i ≤ x m {x_i\leq x_m} xi≤xm和 x i > x m {x_i>x_m} xi>xm两部分。然后对于每部分重复2-3步。

python代码实现：
————————————————

def best_ks_box(data, var_name, box_num):
    data = data[[var_name, 'isDefault']]
    """
    KS值函数
    """
    def ks_bin(data_, limit):
        g = data_.iloc[:, 1].value_counts()[0]
        b = data_.iloc[:, 1].value_counts()[1]
        data_cro = pd.crosstab(data_.iloc[:, 0], data_.iloc[:, 1])
        data_cro[0] = data_cro[0] / g
        data_cro[1] = data_cro[1] / b
        data_cro_cum = data_cro.cumsum()
        ks_list = abs(data_cro_cum[1] - data_cro_cum[0])
        ks_list_index = ks_list.nlargest(len(ks_list)).index.tolist()
        for i in ks_list_index:
            data_1 = data_[data_.iloc[:, 0] <= i]
            data_2 = data_[data_.iloc[:, 0] > i]
            if len(data_1) >= limit and len(data_2) >= limit:
                break
        return i

    """
    区间选取函数
    """

    def ks_zone(data_, list_):
        list_zone = list()
        list_.sort()
        n = 0
        for val in list_:
            m = sum(data_.iloc[:, 0] <= val) - n
            n = sum(data_.iloc[:, 0] <= val)
            print(val,' , m:',m,' n:',n)
            list_zone.append(m)
        #list_zone[i]存放的是list_[i]-list[i-1]之间的数据量的大小
        list_zone.append(50000 - sum(list_zone))
        print('sum ',sum(list_zone[:-1]))
        print('list zone ',list_zone)
        #选取最大数据量的区间
        max_index = list_zone.index(max(list_zone))
        if max_index == 0:
            rst = [data_.iloc[:, 0].unique().min(), list_[0]]
        elif max_index == len(list_):
            rst = [list_[-1], data_.iloc[:, 0].unique().max()]
        else:
            rst = [list_[max_index - 1], list_[max_index]]
        return rst

    data_ = data.copy()
    limit_ = data.shape[0] / 20  # 总体的5%
    """"
    循环体
    """
    zone = list()
    for i in range(box_num - 1):
        #找出ks值最大的点作为切点，进行分箱
        ks_ = ks_bin(data_, limit_)
        zone.append(ks_)
        new_zone = ks_zone(data, zone)
        data_ = data[(data.iloc[:, 0] > new_zone[0]) & (data.iloc[:, 0] <= new_zone[1])]

    zone.append(data.iloc[:, 0].unique().max())
    zone.append(data.iloc[:, 0].unique().min())
    zone.sort()
    return zone 作者：python风控模型 https://www.bilibili.com/read/cv12971807 出处：bilibili

3.3卡方分箱

卡方检验的原理：卡方分箱是依赖于卡方检验的分箱方法，在统计指标上选择卡方统计量（chi-Square）进行判别，分箱的基本思想是判断相邻的两个区间是否有分布差异，基于卡方统计量的结果进行自下而上的合并，直到满足分箱的限制条件为止。

基本步骤：

    预先设定一个卡方的阈值
    对需要进行离散的属性进行排序，每个取值属于一个区间
    合并区间：(1)计算每一对相邻区间的卡方值： X 2 = ∑ i = 1 2 ∑ j = 1 2 ( A i j − E i j ) 2 E i j X^2=\sum_{i=1}^2\sum_{j=1}^{2}\frac{(A_{ij}-E_{ij})^2}{E_{ij}} X2=∑i=12∑j=12Eij(Aij−Eij)2；(2)然后将卡方值最小的一对区间合并。
    其中 A i j A_{ij} Aij是第i区间第j类的样本数量， E i j E_{ij} Eij是 A i j A_{ij} Aij的期望数量 = N i ∗ C j N =N_i*\frac{C_j}{N} =Ni∗NCj，N是总样本数，N_i是第i组的样本数，C_j是第j类样本数量。

上述步骤的终止条件：

分箱个数：每次将样本中具有最小卡方值的区间与相邻的最小卡方区间进行合并，直到分箱个数达到限制条件为止。
卡方阈值：根据自由度和显著性水平得到对应的卡方阈值，如果分箱的各区间最小卡方值小于卡方阈值，则继续合并，直到最小卡方值超过设定阈值为止。

python代码实现：
————————————————

# 计算2*2列联表的卡方值
def get_chi2_value(arr):
    rowsum = arr.sum(axis=1)  # 对行求和，大小为M的数组，是当前分箱情况下，每个箱的样本数量
    colsum = arr.sum(axis=0)  # 对列求和，大小为N_class的数组，每个元素就是每个类别的样本数量
    n = arr.sum()
    emat = np.array([i * j / n for i in rowsum for j in colsum]) #计算每个区间下每个类别样本数量的期望值，大小为M*N_class
    arr_flat = arr.reshape(-1)
    arr_flat = arr_flat[emat != 0]  # 剔除了期望为0的值,不参与求和计算，不然没法做除法！
    emat = emat[emat != 0]  # 剔除了期望为0的值,不参与求和计算，不然没法做除法！
    E = (arr_flat - emat) ** 2 / emat
    return E.sum()

# 自由度以及分位点对应的卡方临界值
def get_chi2_threshold(percents, nfree):
    return chi2.isf(percents, df=nfree)

# 计算卡方切分的切分点
def get_chimerge_cutoff(ser, tag, max_groups=None, threshold=None):
    freq_tab = pd.crosstab(ser, tag)
    cutoffs = freq_tab.index.values  # 保存每个分箱的下标
    freq = freq_tab.values  # [M,N_class]大小的矩阵，M是初始箱体的个数，N_class是目标变量类别的个数
    while True:
        min_value = None #存放所有对相邻区间中卡方值最小的区间的卡方值
        min_idx = None #存放最小卡方值的一对区间中第一个区间的下标
        for i in range(len(freq) - 1):
            chi_value = get_chi2_value(freq[i:(i + 2)]) #计算第i个区间和第i+1个区间的卡方值
            if min_value == None or min_value > chi_value:
                min_value = chi_value
                min_idx = i
        if (max_groups is not None and max_groups < len(freq)) or (
                threshold is not None and min_value < get_chi2_threshold(threshold, len(cutoffs)-1)):
            tmp = freq[min_idx] + freq[min_idx + 1] #合并卡方值最小的那一对区间
            freq[min_idx] = tmp
            freq = np.delete(freq, min_idx + 1, 0) #删除被合并的区间
            cutoffs = np.delete(cutoffs, min_idx + 1, 0)
        else:
            break
    return cutoffs 作者：python风控模型 https://www.bilibili.com/read/cv12971807 出处：bilibili