python分箱函数 python等宽分箱

python用卡方检验，自动分箱，结果是否可靠有待验证

def calc_chiSquare(sampleSet, feature, target):

    '''

    计算某个特征每种属性值python分箱函数的卡方统计量

    params:

        sampleSet: 样本集

        feature: 目标特征

        target: 目标Y值 (0或1) Y值为二分类变量

    return:

        卡方统计量dataframe

        feature: 特征名称

        act_target_cnt: 实际坏样本数

        expected_target_cntpython分箱函数：期望坏样本数

        chi_square：卡方统计量

    '''

    # 计算样本期望频率

    target_cnt = sampleSet[target].sum()

    sample_cnt = len(sampleSet[target])

    expected_ratio = target_cnt * 1.0/sample_cnt

    # 对变量按属性值从大到小排序

    df = sampleSet[[feature, target]]

    col_value = list(set(df[feature])) 

    # 计算每一个属性值对应python分箱函数的卡方统计量等信息

    chi_list = []; target_list = []; expected_target_list = []

    for value in col_value:

        df_target_cnt = df.loc[df[feature] == value, target].sum()

        df_cnt = len(df.loc[df[feature] == value, target])

        expected_target_cnt = df_cnt * expected_ratio

        chi_square = (df_target_cnt - expected_target_cnt)**2 / expected_target_cnt

        chi_list.append(chi_square)

        target_list.append(df_target_cnt)

        expected_target_list.append(expected_target_cnt)

    # 结果输出到dataframe, 对应字段为特征属性值, 卡方统计量, 实际坏样本量, 期望坏样本量

    chi_stats = pd.DataFrame({feature:col_value, 'chi_square':chi_list,

                              'act_target_cnt':target_list, 'expected_target_cnt':expected_target_list})

    return chi_stats[[feature, 'act_target_cnt', 'expected_target_cnt', 'chi_square']]

def chiMerge_maxInterval(chi_stats, feature, maxInterval=5):

    '''

    卡方分箱合并--最大区间限制法

    params:

        chi_stats: 卡方统计量dataframe

        feature: 目标特征

        maxInterval：最大分箱数阈值

    return:

        卡方合并结果dataframe, 特征分割split_list

    '''

    group_cnt = len(chi_stats)

    split_list = [chi_stats[feature].min()]

    # 如果变量区间超过最大分箱限制python分箱函数，则根据合并原则进行合并

    while(group_cnt maxInterval):

        min_index = chi_stats[chi_stats['chi_square']==chi_stats['chi_square'].min()].index.tolist()[0]

        # 如果分箱区间在最前,则向下合并

        if min_index == 0:

            chi_stats = merge_chiSquare(chi_stats, min_index+1, min_index)

        # 如果分箱区间在最后python分箱函数，则向上合并

        elif min_index == group_cnt-1:

            chi_stats = merge_chiSquare(chi_stats, min_index-1, min_index)

        # 如果分箱区间在中间，则判断与其相邻的最小卡方的区间，然后进行合并

        else:

            if chi_stats.loc[min_index-1, 'chi_square'] chi_stats.loc[min_index+1, 'chi_square']:

                chi_stats = merge_chiSquare(chi_stats, min_index, min_index+1)

            else:

                chi_stats = merge_chiSquare(chi_stats, min_index-1, min_index)

        group_cnt = len(chi_stats)

    chiMerge_result = chi_stats

    split_list.extend(chiMerge_result[feature].tolist())

    return chiMerge_result, split_list

def chiMerge_minChiSquare(chi_stats, feature, dfree=4, cf=0.1, maxInterval=5):

    '''

    卡方分箱合并--卡方阈值法

    params:

        chi_stats: 卡方统计量dataframe

        feature: 目标特征

        maxInterval: 最大分箱数阈值, default 5

        dfree: 自由度, 最大分箱数-1, default 4

        cf: 显著性水平, default 10%

    return:

        卡方合并结果dataframe, 特征分割split_list

    '''

    threshold = get_chiSquare_distuibution(dfree, cf)

    min_chiSquare = chi_stats['chi_square'].min()

    group_cnt = len(chi_stats)

    split_list = [chi_stats[feature].min()]

    # 如果变量区间的最小卡方值小于阈值，则继续合并直到最小值大于等于阈值

    while(min_chiSquare threshold and group_cnt maxInterval):

        min_index = chi_stats[chi_stats['chi_square']==chi_stats['chi_square'].min()].index.tolist()[0]

        # 如果分箱区间在最前,则向下合并

        if min_index == 0:

            chi_stats = merge_chiSquare(chi_stats, min_index+1, min_index)

        # 如果分箱区间在最后，则向上合并

        elif min_index == group_cnt-1:

            chi_stats = merge_chiSquare(chi_stats, min_index-1, min_index)

        # 如果分箱区间在中间，则判断与其相邻的最小卡方的区间，然后进行合并

        else:

            if chi_stats.loc[min_index-1, 'chi_square'] chi_stats.loc[min_index+1, 'chi_square']:

                chi_stats = merge_chiSquare(chi_stats, min_index, min_index+1)

            else:

                chi_stats = merge_chiSquare(chi_stats, min_index-1, min_index)

        min_chiSquare = chi_stats['chi_square'].min()

        group_cnt = len(chi_stats)

    chiMerge_result = chi_stats

    split_list.extend(chiMerge_result[feature].tolist())

    return chiMerge_result, split_list

def get_chiSquare_distuibution(dfree=4, cf=0.1):

    '''

    根据自由度和置信度得到卡方分布和阈值

    params:

        dfree: 自由度, 最大分箱数-1, default 4

        cf: 显著性水平, default 10%

    return:

        卡方阈值

    '''

    percents = [0.95, 0.90, 0.5, 0.1, 0.05, 0.025, 0.01, 0.005]

    df = pd.DataFrame(np.array([chi2.isf(percents, df=i) for i in range(1, 30)]))

    df.columns = percents

    df.index = df.index+1

    # 显示小数点后面数字

    pd.set_option('precision', 3)

    return df.loc[dfree, cf]

def merge_chiSquare(chi_result, index, mergeIndex, a = 'expected_target_cnt',

                    b = 'act_target_cnt', c = 'chi_square'):

    '''

    params:

        chi_result: 待合并卡方数据集

        index: 合并后的序列号

        mergeIndex: 需合并的区间序号

        a, b, c: 指定合并字段

    return:

        分箱合并后的卡方dataframe

    '''

    chi_result.loc[mergeIndex, a] = chi_result.loc[mergeIndex, a] + chi_result.loc[index, a]

    chi_result.loc[mergeIndex, b] = chi_result.loc[mergeIndex, b] + chi_result.loc[index, b]

    chi_result.loc[mergeIndex, c] = (chi_result.loc[mergeIndex, b] - chi_result.loc[mergeIndex, a])**2 /chi_result.loc[mergeIndex, a]

    chi_result = chi_result.drop([index])

    chi_result = chi_result.reset_index(drop=True)

    return chi_result

for col in bin_col:

    chi_stats = calc_chiSquare(exp_f_data_label_dr, col, 'label')

    chiMerge_result, split_list = chiMerge_maxInterval(chi_stats, col, maxInterval=5)

    print(col, 'feature maybe split like this:', split_list)

相关问答

Q1: 如何在python中实现数据的最优分箱

其实任何开发工具只是把算法变成代码，根本上是你要想清楚如何分箱。

你所需要python分箱函数的最优分箱应该是从所有分箱的可能中找到具有最小方差的方案，分箱的数量通常按照等频或者等宽划分，还是要预设或者通过最优化计算得到。

然后，对应每种分箱方法计算其方差，你找到找到相应的函数，把这个方差的计算方法实现代码。

对Python完全不熟，帮不python分箱函数了你。你可以搜一些代码，自己调试和验证一下

Q2: 【Python】split()函数

Python中有split()和os.path.split()两个函数，具体作用如下：

split()：拆分字符串，通过指定分隔符对字符串进行切片，并返回分割后的字符串列表（list）

os.path.split()：按照路径将文件名和路径分割开

一、函数说明

1、split()函数

语法：str.split(str="",num=string.count(str))[n]

参数说明：

str:表示为分隔符，默认为空格，但是不能为空('')。若字符串中没有分隔符，则把整个字符串作为列表的一个元素

num:表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量

[n]:表示选取第n个分片

注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略

2、os.path.split()函数

语法：os.path.split('PATH')

参数说明：

1.PATH指一个文件的全路径作为参数：

2.如果给出的是一个目录和文件名，则输出路径和文件名

3.如果给出的是一个目录名，则输出路径和为空文件名

二、分离字符串

string = ""

1.以'.'为分隔符

print(string.split('.'))

['www', 'gziscas', 'com', 'cn']

2.分割两次

print(string.split('.'，2))

['www', 'gziscas', 'com.cn']

3.分割两次，并取序列为1的项

print(string.split('.',2)[1])

gziscas

4.分割两次，并把分割后的三个部分保存到三个文件

u1, u2, u3 =string.split('.',2)

print(u1)—— www

print(u2)—— gziscas

print(u3) ——com.cn

三、分离文件名和路径

import os

print(os.path.split('/dodo/soft/python/'))

('/dodo/soft/python', '')

print(os.path.split('/dodo/soft/python'))

('/dodo/soft', 'python')

四、实例

str="hello boy[]byebye"

print(str.split("[")[1].split("]")[0])

Q3: python 对toad里面的toad.metrics.KS_bucket函数改写成自定义分段

toad函数里面有个 类似于woe 统计各段python分箱函数的好坏python分箱函数，好坏比， 累计好坏比，KSpython分箱函数的一个数为

toad.metrics.KS_bucket

此函数中有两个参数，可以 是等频分，也可以 是等距分箱，但此分箱均是以分数的最大最小值 为基础划分的。

我想把整成0~1区间的，所以对原函数进行了修改。

关于python分箱函数和python等宽分箱的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。