1. 首页
  2. 自学中心
  3. 软件
  4. Python

逻辑回归评分卡制作

代码和数据可以参考 针对银行数据制作评分卡

背景

​ 在银行借贷场景中,评分卡是一种以分数形式来衡量一个客户的信用风险大小的手段,它衡量向别人借

钱的人(受信人,需要融资的公司)不能如期履行合同中的还本付息责任,并让借钱给别人的人(授信人,银行等

金融机构)造成经济损失的可能性。一般来说,评分卡打出的分数越高,客户的信用越好,风险越小。这些”借钱

的人“,可能是个人,有可能是有需求的公司和企业:

对于企业来说,我们按照融资主体的融资用途,分别使用企业融资模型,现金流融资模型,项目融资模

型等模型。

​ 而对于个人来说,我们有”四张卡“来评判个人的信用程度:A卡,B卡,C卡和F卡。而众人常说的“评分

卡”其实是指A卡,又称为申请者评级模型,主要应用于相关融资类业务中新用户的主体评级,即判断金

融机构是否应该借钱给一个新用户,如果这个人的风险太高,我们可以拒绝贷款。

一个完整的模型开发,需要有以下流程:

逻辑回归评分卡制作

前期准备

逻辑回归评分卡制作

|

1.1 导入库

import numpy as np 
import pandas as pd 
import matplotlib.pyplot as plt
  • 准备数据
data = pd.read_csv(r"./data/rankingcard.csv",index_col=0)
data.shape # 查看数据维度

1.2 数据探索&数据预处理

  • 查看数据基本信息
data.info()
逻辑回归评分卡制作
  • MonthlyIncome、NumberOfDependents 存在缺少值

1.2.1 取出重复值

现实数据,尤其是银行业数据,可能会存在的一个问题就是样本重复,即有超过一行的样本所显示的所

有特征都一样。有时候可能时人为输入重复,有时候可能是系统录入重复,总而言之我们必须对数据进行去重处

理。

可能有人会说,难道不可能出现说两个样本的特征就是一模一样,但他们是两个样本吗?比如,两个人,一模一

样的名字,年已借有的房地产贷款数量等等,几乎不可能都出现一样。尤其是银行业数据经常是几百个特征,所有

特征都一样的可能性是微乎其微的。即便真的出现了如此极端的情况,我们也可以当作是少量信息损

失,将这条记录当作重复值除去。

# 删除重复值
data.drop_duplicates(inplace=True)
# 重置索引
data.reset_index(drop=True, inplace=True)
# 查看当前数据行列
data.shape

1.2.3 填补缺少值

1.2.3.1 用平均值填充家庭成员缺少值

# 查看缺少情况
data.isnull().sum()
# 填充家庭成员缺失值 ,将家庭成员缺少值全部填充为0
data['NumberOfDependents'].fillna(0, inplace=True)

1.2.3.2 用随机深林对月收入填充缺少值

​ 随机森林利用,既然可以使用A,B,C去预测Z,那也可以使用A,C,Z去预测B”的思想来填补缺失

值。对于一个有n个特征的数据来说,其中特征T有缺失值,我们就把特征T当作标签,其他的n-1个特征

和原本的标签组成新的特征矩阵。那对于T来说,它没有缺失的部分,就是我们的Y_train,这部分数据

既有标签也有特征,而它缺失的部分,只有特征没有标签,就是我们需要预测的部分。

特征T不缺失的值对应的其他n-1个特征 + 本来的标签:X_train

特征T不缺失的值:Y_train

特征T缺失的值对应的其他n-1个特征 + 本来的标签:X_test

特征T缺失的值:未知,我们需要预测的Y_test

这种做法,对于某一个特征大量缺失,其他特征却很完整的情况,非常适用。

构造随机森林填补缺失值的函数:

def fill_missing_rf(data,name):

    from sklearn.ensemble import RandomForestRegressor
    df1 = data[data[name].isnull()]
    df2 = data[~data[name].isnull()]
    X1 = df1.drop(columns = name)
    X2 = df2.drop(columns = name)
    y = df2[name]

    RF = RandomForestRegressor(max_depth=10, ).fit(X2, y)
    return RF.predict(X1) # 返回预测值
# 对缺少部分进行重新赋值
data.loc[data['MonthlyIncome'].isnull(),'MonthlyIncome'] =fill_missing_rf(data,'MonthlyIncome')
# 检查是否还有缺少情况
data.isnull().any()

1.2.4 描述性统计处理异常值

​ 现实数据永远都会有一些异常值,首先我们要去把他们捕捉出来,然后观察他们的性质。注意,我们并

不是要排除掉所有异常值,相反很多时候,异常值是我们的重点研究对象,比如说,双十一中购买量超高的品牌,

或课堂上让很多学生都兴奋的课题,这些是我们要重点研究观察的。

​ 日常处理异常值,我们使用箱线图或者 法则来找到异常值(千万不要说依赖于眼睛看,我们是数据挖掘

工程师,除了业务理解,我们还要有方法)。但在银行数据中,我们希望排除的“异常值”不是一些超高或超低的数字,而是一些不符合常理的数据:比如,收入不能为负数,但是一个超高水平的收入却是合理的,可以存在的。所以在银行业中,我们往往就使用普通的描述性统计来观察数据的异常与否与数据的分布情况。注意,这种方法只能在特征量有限的情况下进行,如果有几百个特征又无法成功降维或特征选择不管用,那还是用 比较好。

1.2.4.1 异常值:存在年龄为0的用户

# 查看年龄分布情况
data['age'].describebe()
'''
count    149391.000000
mean         52.306237
std          14.725962
min           0.000000
25%          41.000000
50%          52.000000
75%          63.000000
max         109.000000
'''
# 统计年龄为0的个数
sum(data['age']==0) # 1
# 年龄最小值最0,不符合实际业务需求需要删出。出现这种线性很可能由于相关人员录入错误造成,无法避免。
data = data[data['age']>0]
data.reset_index(drop= True,inplace= True) # 重置索引

1.2.4.2其它异常值处理

“NumberOfTime30-59DaysPastDueNotWorse”

“NumberOfTime60-89DaysPastDueNotWorse”

“NumberOfTimes90DaysLate”

这三个指标分别是“过去两年内出现35-59天逾期但是没有发展的更坏的次数”,“过去两年内出现60-89天

逾期但是没 有发展的更坏的次数”,“过去两年内出现90天逾期的次数”。这三个指标,在99%的分布的时

候依然是2,最大值却是 98,看起来非常奇怪。

一个人在过去两年内逾期35~59天98次,一年6个60天,两年内逾期98次这是怎么算出来的?

我们可以去咨询业务人员,请教他们这个逾期次数是如何计算的。如果这个指标是正常的,那这些两年

内逾期了98次的 客户,应该都是坏客户。在我们无法询问他们情况下,查看一下有多少个样本存

在这种异常:

sum(data['NumberOfTime30-59DaysPastDueNotWorse']>90) # 这样的样本存在255个

data['NumberOfTime30-59DaysPastDueNotWorse'].value_counts() 
'''
98       220
6        140
7         54
8         25
9         12
96         5
'''
# 大于90的样本有98、96分别为220、5,这部分样本应该删除

data = data[data['NumberOfTime30-59DaysPastDueNotWorse']<95]
data.reset_index(drop= True,inplace= True) # 重置索引

1.2.5 处理样本标签不均衡

  • 当遇到样本标签不均衡问题,可采取的方法为采样。采样包括下采样和上采样
# 查看正负样本占比
data['SeriousDlqin2yrs'].value_counts()
'''
0    139293
1      9873
'''
  • 存在严重的正负样本不均衡,这里采取上采样来平衡样本

可以看出,样本严重不均衡。虽然大家都在努力防范信用风险,但实际违约的人并不多。并且,银行并

不会真的一棒子打死所有会违约的人,很多人是会还钱的,只是忘记了还款日,很多人是不愿意欠人钱的,但是当

时真的很困难,资金周转不过来,所以发生逾期,但一旦他有了钱,他就会把钱换上。对于银行来说,只要你最后

能够把钱还上,我都愿意借钱给你,因为我借给你就有收入(利息)。所以,对于银行来说,真正想要被判别出来

的其实是 ”恶意违约“的人,而这部分人数非常非常少,样本就会不均衡。这一直是银行业建模的一个痛点:我们永远希望捕捉少数类。

逻辑回归中使用最多的是上采样方法来平衡样本。

  • 需要提前安装一个三方库: pip install imblearn
from imblearn.over_sampling import SMOTE #导入上采样 SMOTE方法 
sm = SMOTE(random_state=42) 
X,y = sm.fit_sample(X,y) #返回已经上采样完毕过后的特征矩阵和标签
# 查看样本
x.size # 278586
y.size # 278586
y.value_counts()
'''
1    139293
0    139293
'''
# 可以明显看出现在样本标签已经平衡

SMOTE上采样原理

SMOTE算法的思想是合成新的少数类样本,合成的策略是对每个少数类样本a,从它的最近邻中随机选 一个样本b,然后在a、b之间的连线上随机选一点作为新合成的少数类样本。如图所示:

逻辑回归评分卡制作

算法流程:

1、对于少数类中每一个样本a,以欧氏距离为标准计算它到少数类样本集中所有样本的距离,得到其 k近邻。 2、根据样本不平衡比例设置一个采样比例以确定采样倍率N,对于每一个少数类样本a,从其k近邻 中随机选择若干个样本,假设选择的近邻为b。

3、对于每一个随机选出的近邻b,分别与原样本a按照如下的公式构建新的样本:c=a+rand(0,1)∗|a−b|

1.3 划分数据集

from sklearn.model_selection import train_test_split 

X = pd.DataFrame(X) 
y = pd.DataFrame(y) 

X_train, X_vali, Y_train, Y_vali = train_test_split(X,y,test_size=0.3,random_state=420) 

model_data = pd.concat([y_train,x_train], axis=1) # 将特征与标签进行拼接
model_data.reset_index(drop=True, inplace=True) # 重置索引

vali_data = pd.concat([y_test, x_test], axis=1)
vali_data.reset_index(drop=True, inplace=True)

# 重新保存文件, 有利于后续操作
model_data.to_csv(r"model_data.csv") 
vali_data.to_csv(r"vali_data.csv")

1.4 分箱处理

要制作评分卡,是要给各个特征进行分档,以便业务人员能够根据新客户填写的信息为客户打 分。因此在评分卡制作过程中,一个重要的步骤就是分箱。可以说,分箱是评分卡最难,也是最核心的思路,分箱 的本质,其实就是离散化连续变量,好让拥有不同属性的人被分成不同的类别打上不同的分数,其实本质比较 类似于聚类。那我们在分箱中要回答几个问题:

  • 要分几个箱子才算合适?

​ 最开始我们并不知道,但是既然是将连续型变量离散化,想也知道箱子个数必然不能太多,最好控制在 十个以下。 而用来制作评分卡,最好能在4~5个为最佳。我们知道,离散化连续变量必然伴随着信息的 损失,并且箱子越少, 信息损失越大。为了衡量特征上的信息量以及特征对预测函数的贡献,银行业 定义了概念Information value(IV): IV=∑i=1n(good%−bad%)∗WOEi 其中 是这个特征上箱子的个数, 代表每个箱子, good%是这个箱内的优质客户(标签为0的客户) 占整个特征中所有优质客户的比例,bad% 是这个箱子里的坏客户(就是那些会违约,标签为1的那些 客户)占整个特征中所有坏客户的比例,而 则写作: WOEi=ln(good%bad%) 这是我们在银行业中用来衡量违约概率的指标,中文叫做证据权重(weight of Evidence),本质其实就是 优质客户比上坏客户的比例的对数。 WOE是对一个箱子来说的, WOE越大,代表了这个箱子里的优质客户越 多。而IV 是对整个特征来说的, 代表的意义是我们特征上的信息量以及这个特征对模型的贡献,由下表来控制

IV 特征对预测函数的贡献

< 0.03 特征几乎不带有效信息,对模型没有贡献,这种特征可以被删除
0.03~0.09 有效信息很少,对模型的贡献度低
0.1~0.29 有效信息一般,对模型的贡献度中等
0.3~0.49 有效信息较多,对模型的贡献度较高
>=0.5 有效信息非常多,对模型的贡献超高并且可疑

可见, 并非越大越好,我们想要找到 的大小和箱子个数的平衡点。箱子越多, 必然越小,因为 信息损失会非常多,所以,我们会对特征进行分箱,然后计算每个特征在每个箱子数目下的 值, 利用 值的曲线,找出合适的分箱个数。

  • 分箱要达到怎样的效果?

我们希望不同属性的人有不同的分数,因此我们希望在同一个箱子内的人的属性是尽量相似的,而不同 箱子的人的 属性是尽量不同的,即业界常说的”组间差异大,组内差异小“。对于评分卡来说,就是说我 们希望一个箱子内的人 违约概率是类似的,而不同箱子的人的违约概率差距很大,即WOE差距要大, 并且每个箱子中坏客户所占的比重(bad% )也要不同。那我们,可以使用卡方检验来对比两个箱子之 间的相似性,如果两个箱子之间卡方检验的P值很大,则说明他们非常相似,那我们就可以将这两个箱 子合并为一个箱子。

基于这样的思想,我们总结出我们对一个特征进行分箱的步骤: 1) 我们首先把连续型变量分成一组数量较多的分类型变量,比如,将几万个样本分成100组,或50 组。 2) 确保每一组中都要包含两种类别的样本,否则IV值会无法计算。 3) 我们对相邻的组进行卡方检验,卡方检验的P值很大的组进行合并,直到数据中的组数小于设定的N 箱为止。 4) 我们让一个特征分别分成[2,3,4…..20]箱,观察每个分箱个数下的IV值如何变化,找出最适合的分箱 个数。 5) 分箱完毕后,我们计算每个箱的WOE值,bad% ,观察分箱效果。 这些步骤都完成后,我们可以对各个特征都进行分箱,然后观察每个特征的IV值,以此来挑选特征

1.4.1 age列分箱

分箱方法有:

​ 1.cut 等距分箱

​ 2.qcut 等频分箱

pd.qcut,基于分位数的分箱函数,本质是将连续型变量离散化

只能够处理一维数据。返回箱子的上限和下限

参数q:要分箱的个数

参数retbins=True来要求同时返回结构为索引为样本索引,元素为分到的箱子的Series

现在返回两个值:每个样本属于哪个箱子,以及所有箱子的上限和下限

#按照等频对需要分箱的列进行分箱 
model_data["qcut"], updown = pd.qcut(model_data["age"], retbins=True, q=20) 
'''
pd.qcut,基于分位数的分箱函数,本质是将连续型变量离散化 
只能够处理一维数据。返回箱子的上限和下限 
参数q:要分箱的个数 
参数retbins=True来要求同时返回结构为索引为样本索引,元素为分到的箱子的Series 
现在返回两个值:每个样本属于哪个箱子,以及所有箱子的上限和下限
'''

#在这里时让model_data新添加一列叫做“分箱”,这一列其实就是每个样本所对应的箱子 
model_data["qcut"].value_counts() 
#所有箱子的上限和下限 updown
# 统计每个分箱中0和1的数量 # 这里使用了数据透视表的功能
groupby coount_y0 = model_data[model_data["SeriousDlqin2yrs"]==0].groupby(by="qcut").count()["SeriousDlqin2yrs"]
coount_y1 = model_data[model_data["SeriousDlqin2yrs"] == 1].groupby(by="qcut").count() ["SeriousDlqin2yrs"] 
#num_bins值分别为每个区间的上界,下界,0出现的次数,1出现的次数 
num_bins = [*zip(updown,updown[1:],coount_y0,coount_y1)] 
#注意zip会按照最短列来进行结合
num_bins

1.4.2 计算WOE IV

#计算WOE和BAD RATE 
#BAD RATE与bad%不是一个东西 
#BAD RATE是一个箱中,坏的样本所占的比例 (bad/total)
#而bad%是一个箱中的坏样本占整个特征中的坏样本的比例 
def get_woe(num_bins): 
    # 通过 num_bins 数据计算 
    woe columns = ["min","max","count_0","count_1"] 
    df=pd.DataFrame(num_bins,columns=columns) 
    df["total"] = df.count_0 + df.count_1
    #一个箱子当中所有的样本数 
    df["percentage"] = df.total / df.total.sum()
    #一个箱子里的样本数,占所有样本的比例 
    df["bad_rate"] = df.count_1 / df.total
    #一个箱子坏样本的数量占一个箱子里边所有样本数 的比例
    df["good%"] = df.count_0/df.count_0.sum() 
    df["bad%"] = df.count_1/df.count_1.sum() 
    df["woe"] = np.log(df["good%"] / df["bad%"]) 
    return df 

#计算IV值 
def get_iv(df): 
    rate = df["good%"] - df["bad%"] 
    iv = np.sum(rate * df.woe) 
    return iv

1.4.3 卡方检验

本质是为了检验两列数据的相似性,现在我们用来检验两个相邻的箱中数据的相似性。

1.找到相邻两个箱子之间的p-value(p-value越大代表两个组越相似,则合并这两个相邻组)

2.重复上述过程

num_bins_ = num_bins.copy() 
import matplotlib.pyplot as plt 
import scipy 
x1 = num_bins_[0][2:] 
x2 = num_bins_[1][2:]
x1,x2 
#不同的箱中的零和一的个数
pv = scipy.stats.chi2_contingency([x1,x2])[1] # 0 返回 chi2 值,1 返回 p 值。
pv
pvs = [] 
for i in range(len(num_bins_)-1): 
    x1 = num_bins_[i][2:] 
    x2 = num_bins_[i+1][2: ] 
    # 0 返回 chi2 值,1 返回 p 值。
    pv = scipy.stats.chi2_contingency([x1,x2])[1] #p值 

    # chi2 = scipy.stats.chi2_contingency([x1,x2])[0] #计算卡方值
    pvs.append(pv) pvs.index(max(pvs)) #取得最大p-value 让两个箱子合并 
    num_bins_[1:3] = [( num_bins_[1][0], num_bins_[2][1], num_bins_[1][2]+num_bins_[2][2], num_bins_[1][3]+num_bins_[2][3])] #合并第二组和第三组

1.4.4 通过IV值选择合适的箱子数

#通过IV值选择箱数 
IV = [] 
axisx = [] 
while len(num_bins_) > 2: #大于设置的最低分箱个数 
    pvs = [] #获取 num_bins_两两之间的卡方检验的置信度(或卡方值) 
    for i in range(len(num_bins_)-1): 
        x1 = num_bins_[i][2:] x2 = num_bins_[i+1][2: ] # 0 返回 chi2 值,1 返回 p 值。 
        pv = scipy.stats.chi2_contingency([x1,x2])[1] #p值 
        # chi2 = scipy.stats.chi2_contingency([x1,x2])[0]#计算卡方值
        pvs.append(pv) # 通过 p 值进行处理。合并 p 值最大的两组 
        i = pvs.index(max(pvs)) 
        num_bins_[i:i+2] = [( num_bins_[i][0], num_bins_[i+1][1], num_bins_[i][2]+num_bins_[i+1][2], num_bins_[i][3]+num_bins_[i+1][3])] bins_df = get_woe(num_bins_)#计算每次循环完得到箱子的WOE axisx.append(len(num_bins_))#合并后箱的个数 IV.append(get_iv(bins_df))#计算每次循环完得到箱子的IV
plt.figure() 
plt.plot(axisx,IV) 
plt.xticks(axisx)
plt.xlabel("number of box") 
plt.ylabel("IV") plt.show() #选择转折点处,也就是下坠最快的折线点,所以这里对于age来说选择箱数为6
# 将分箱过程定义成函数 
def get_bin(num_bins_,n): 
    while len(num_bins_) > n: 
        pvs = [] 
        for i in range(len(num_bins_)-1): 
            x1 = num_bins_[i][2:] 
            x2 = num_bins_[i+1][2:] 
            pv = scipy.stats.chi2_contingency([x1,x2])[1] 
            # chi2 = scipy.stats.chi2_contingency([x1,x2])[0] 
            pvs.append(pv) 
            i = pvs.index(max(pvs)) 
            num_bins_[i:i+2] = [( num_bins_[i][0], num_bins_[i+1][1], num_bins_[i][2]+num_bins_[i+1][2], num_bins_[i][3]+num_bins_[i+1][3])] 
    return num_bins_
afterbins = get_bin(num_bins,6) 
afterbins 
bins_df = get_woe(num_bins) #查看最终分箱过后的WOE值
bins_df #希望每组的bad_rate相差越大越好;
# woe差异越大越好,应该具有单调性,随着箱的增加,要么由正到负,要么由负到正,只能有一个转折过 程;# 如果woe值大小变化是有两个转折,比如呈现w型,证明分箱过程有问题 
# num_bins保留的信息越多越好

1.4.5 将选取分箱个数的整个过程封装成函数

def graphforbestbin(DF, X, Y, n,q=20,graph=True):
    '''
    自动最优分箱函数,基于卡方检验的分箱

    参数:
    DF: 需要输入的数据
    X: 需要分箱的列名
    Y: 分箱数据对应的标签 Y 列名
    n: 保留分箱个数
    q: 初始分箱的个数
    graph: 是否要画出IV图像

    区间为前开后闭 (]

    '''

    DF = DF[[X,Y]].copy()

    DF["qcut"],bins = pd.qcut(DF[X], retbins=True, q=q,duplicates="drop")
    coount_y0 = DF.loc[DF[Y]==0].groupby(by="qcut").count()[Y]
    coount_y1 = DF.loc[DF[Y]==1].groupby(by="qcut").count()[Y]
    num_bins = [*zip(bins,bins[1:],coount_y0,coount_y1)]

    #判断每个箱子是否包含正负样本
    for i in range(q):
        if 0 in num_bins[0][2:]:
            num_bins[0:2] = [(
                num_bins[0][0],
                num_bins[1][1],
                num_bins[0][2]+num_bins[1][2],
                num_bins[0][3]+num_bins[1][3])]
            continue

        for i in range(len(num_bins)):
            if 0 in num_bins[i][2:]:
                num_bins[i-1:i+1] = [(
                    num_bins[i-1][0],
                    num_bins[i][1],
                    num_bins[i-1][2]+num_bins[i][2],
                    num_bins[i-1][3]+num_bins[i][3])]
                break
        else:
            break

    #定义WOE函数
    def get_woe(num_bins):
        columns = ["min","max","count_0","count_1"]
        df = pd.DataFrame(num_bins,columns=columns)
        df["total"] = df.count_0 + df.count_1
        df["percentage"] = df.total / df.total.sum()
        df["bad_rate"] = df.count_1 / df.total
        df["good%"] = df.count_0/df.count_0.sum()
        df["bad%"] = df.count_1/df.count_1.sum()
        df["woe"] = np.log(df["good%"] / df["bad%"])
        return df

    #定义IV函数
    def get_iv(df):
        rate = df["good%"] - df["bad%"]
        iv = np.sum(rate * df.woe)
        return iv

    #找最合理的分箱数n
    IV = []
    axisx = []
    while len(num_bins) > n:
        pvs = []
        for i in range(len(num_bins)-1):
            x1 = num_bins[i][2:]
            x2 = num_bins[i+1][2:]
            pv = scipy.stats.chi2_contingency([x1,x2])[1]
            pvs.append(pv)

        i = pvs.index(max(pvs))
        num_bins[i:i+2] = [(
            num_bins[i][0],
            num_bins[i+1][1],
            num_bins[i][2]+num_bins[i+1][2],
            num_bins[i][3]+num_bins[i+1][3])]


        bins_df = pd.DataFrame(get_woe(num_bins))
        axisx.append(len(num_bins))
        IV.append(get_iv(bins_df))

    if graph:
        plt.figure()
        plt.plot(axisx,IV)
        plt.xticks(axisx)
        plt.xlabel("number of box")
        plt.ylabel("IV")
        plt.show()
    return bins_df

1.4.6 对所有特征进行分箱处理

出现分箱错误的特征,分成两个特征处理:

auto_col_bins 连续型变量,可以用分箱函数

hand_bins 类别型,手动分箱

#可以使用分箱的特征
auto_col_bins = {"RevolvingUtilizationOfUnsecuredLines":5
                 ,
                "age":4,
                "DebtRatio":4,
                "MonthlyIncome":5,
                "NumberOfOpenCreditLinesAndLoans":5}

#不能使用自动分箱的变量
hand_bins = {"NumberOfTime30-59DaysPastDueNotWorse":[0,1,2,13]
            ,"NumberOfTimes90DaysLate":[0,1,2,17]
            ,"NumberRealEstateLoansOrLines":[0,1,2,54]
            ,"NumberOfTime60-89DaysPastDueNotWorse":[0,1,2,8]
            ,"NumberOfDependents":[0,1,2,3]}

#保证区间覆盖使用 np.inf替换最大值,用-np.inf替换最小值 
#原因:比如一些新的值出现,例如家庭人数为30,以前没出现过,改成范围为极大值之后,这些新值就都能分到箱里边了
hand_bins = {k:[-np.inf,*v[:-1],np.inf] for k,v in hand_bins.items()}
bins_of_col = {}

# 生成自动分箱的分箱区间和分箱后的 WOE值

for col in auto_col_bins:
    bins_df = graphforbestbin(model_data,col
                             ,"SeriousDlqin2yrs"
                             ,n=auto_col_bins[col]
                             #使用字典的性质来取出每个特征所对应的箱的数量
                             ,q=20
                             ,graph=False)
    bins_list = sorted(set(bins_df["min"]).union(bins_df["max"]))
    #保证区间覆盖使用 np.inf 替换最大值 -np.inf 替换最小值
    bins_list[0],bins_list[-1] = -np.inf,np.inf
    bins_of_col[col] = bins_list

1.5 开始分箱 箱内填充WOE值

我们现在已经有了我们的箱子,接下来我们要做的是计算各箱的WOE,并且把WOE替换到我们的原始

数据model_data中,因为我们将使用WOE覆盖后的数据来建模,我们希望获取的是”各个箱”的分类结果,

即评分卡上各个评分项目的分类结果。

# 计算woe的函数
def get_woe(df,col,y,bins):

    df = df[[col,y]].copy()
    df["cut"] = pd.cut(df[col],bins)
    bins_df = df.groupby("cut")[y].value_counts().unstack()
    woe = bins_df["woe"] = np.log((bins_df[0]/bins_df[0].sum())/(bins_df[1]/bins_df[1].sum()))
    return woe

#将所有特征的WOE存储到字典当中
woeall = {}
for col in bins_of_col:
    woeall[col] = get_woe(model_data,col,"SeriousDlqin2yrs",bins_of_col[col])

woeall
#不希望覆盖掉原本的数据,创建一个新的DataFrame,索引和原始数据model_data一模一样
model_woe = pd.DataFrame(index=model_data.index)

#将原数据分箱后,按箱的结果把WOE结构用map函数映射到数据中
model_woe["age"] = pd.cut(model_data["age"],bins_of_col["age"]).map(woeall["age"])
model_woe.head()

1.5.1 得到最终特征矩阵

#对所有特征操作可以写成:
for col in bins_of_col:
    model_woe[col] = pd.cut(model_data[col],bins_of_col[col]).map(woeall[col])

#将标签补充到数据中
model_woe["SeriousDlqin2yrs"] = model_data["SeriousDlqin2yrs"]

#这就是我们的建模数据了
model_woe.head()
逻辑回归评分卡制作

1.5.2 处理测试集

同样需要将测试集按照特征分箱的方式分箱。

vali_woe = pd.DataFrame(index=vali_data.index)

for col in bins_of_col:
    vali_woe[col] = pd.cut(vali_data[col],bins_of_col[col]).map(woeall[col])
vali_woe["SeriousDlqin2yrs"] = vali_data["SeriousDlqin2yrs"]

vali_X = vali_woe.iloc[:,:-1]
vali_y = vali_woe.iloc[:,-1]
vali_X.head()
逻辑回归评分卡制作

1.6 建模

X = model_woe.iloc[:,:-1]
y = model_woe.iloc[:,-1]
X
# 使用LogisticRegression进行建模
from sklearn.linear_model import LogisticRegression as LR

lr = LR().fit(X,y)
lr.score(vali_X,vali_y)
# 找到较好的模型
c_1 = np.linspace(0.01,1,20)
c_2 = np.linspace(0.01,0.2,20)

score = []
for i in c_1:
    lr = LR(solver='liblinear',C=i).fit(X,y)
    score.append(lr.score(vali_X,vali_y))
plt.figure()
plt.plot(c_1,score)
plt.show()

lr.n_iter_ #array([7], dtype=int32)

score = []
for i in [1,2,3,4,5,6]: 
    lr = LR(solver='liblinear',C=0.025,max_iter=i).fit(X,y)
    score.append(lr.score(vali_X,vali_y))
plt.figure()
plt.plot([1,2,3,4,5,6],score)
plt.show()
# 模型评估
import scikitplot as skplt

#%%cmd
#pip install scikit-plot

vali_proba_df = pd.DataFrame(lr.predict_proba(vali_X))
skplt.metrics.plot_roc(vali_y, vali_proba_df,
                        plot_micro=False,figsize=(6,6),
                        plot_macro=False)

2 制作评分卡

建模完毕,我们使用准确率和ROC曲线验证了模型的预测能力。接下来就是要讲逻辑回归转换为标准评

分卡了。评分卡中的分数,由以下公式计算 Score=A−Blog(odds) 其中A与B是常数,A叫做“补偿”,B叫做“刻度”,log(odds) 代表一个人违约的可能性。其实逻辑回归的结果取对数几率形式会得到 OxT ,即我们的参数特征矩阵,所以 log(odds)其实就是我们的参数。两个常数可以通过两个假设的分值带入公式求出,这两个假设分别是:

  1. 某个特定的违约概率下的预期分值
  2. 指定的违约概率翻倍的分数(PDO)

例如,假设对数几率为1/60 时设定的特定分数为600,PDO=20,那么对数几率为1/30时的分数就是

620。带入以上线性表达式,可以得到 600=A−B∗log(160)
620=A−B∗log(130)

B = 20/np.log(2)
A = 600 + B*np.log(1/60)

B,A

有了A和B,分数就很容易得到了。其中不受评分卡中各特征影响的基础分,就是将截距 作为 带入公式进行计算,而其他各个特征各个分档的分数,也是将系数带入进行计算:

base_score = A - B*lr.intercept_#lr.intercept_:截距
base_score#array([481.56390143])

我们可以通过循环,将所有特征的评分卡内容全部一次性写往一个本地文件ScoreData.csv:

file = "ScoreData.csv"

with open(file,"w") as fdata:  
    fdata.write("base_score,{}\n".format(base_score))
for i,col in enumerate(X.columns):#[*enumerate(X.columns)]
    score = woeall[col] * (-B*lr.coef_[0][i])
    score.name = "Score"
    score.index.name = col
    score.to_csv(file,header=True,mode="a")

总结

​ 通过最后输出的结果,对业务人员具有参考作用。这样的评分效果对于识别用户具有一定的导向作用,回望整个分析过程,其中最耗费时间和精力的就是数据的清洗和对连续数据进行分箱操作。这里对于分箱数结合卡方检验来进行筛选试图找到最合理的分箱个数,通过也结合业务场景计算WOE和IV进行综合评价。最后,通过逻辑回归来进行评分卡的制作,对于模型评估通常可以采用ROC或者AUC评估模型的效果。

 

本文来自zhihu,观点不代表一起大数据-技术文章心得立场,如若转载,请注明出处:https://zhuanlan.zhihu.com/p/432972514

联系我们

在线咨询:点击这里给我发消息

邮件:23683716@qq.com

跳至工具栏