目录
一.评分卡
二.导库，获取数据
三.探索数据与数据预处理
1.去除重复值
2.填补缺失值
3.描述性统计处理异常值
4.为什么不统一量纲，也不标准化数据分布
5.样本不均衡问题
6.分训练集和测试集
三.分箱
1.分多少个箱子才合适
2.分箱要达成什么样的效果
3.等频分箱
4.定义WOE和IV函数
5.卡方检验，合并箱体，画出IV曲线
6.用最佳分箱个数分箱，并验证分箱结果
7.将选取最佳分箱个数的过程包装为函数
8.对所有特征进行分箱选择
9.计算各箱的WOE并映射到数据中
四.建模与模型验证
五.制作评分卡
六.评分卡代码实现
一.评分卡
在银行借贷场景中，评分卡是一种以分数形式来衡量一个客户的信用风险大小的手段，它衡量向别人借钱的人（受信人，需要融资的公司）不能如期履行合同中的还本付息责任，并让借钱给别人的人（授信人，银行等金融机构）造成经济损失的可能性。一般来说，评分卡打出的分数越高，客户的信用越好，风险越小。
这些”借钱的人“，可能是个人，有可能是有需求的公司和企业。对于企业来说，我们按照融资主体的融资用途，分别使用企业融资模型，现金流融资模型，项目融资模型等模型。而对于个人来说，我们有”四张卡“来评判个人的信用程度：A卡，B卡，C卡和F卡。而众人常说的“评分卡”其实是指A卡，又称为申请者评级模型，主要应用于相关融资类业务中新用户的主体评级，即判断金融机构是否应该借钱给一个新用户，如果这个人的风险太高，我们可以拒绝贷款。
二.导库，获取数据
在银行系统中，这个数据通常使来自于其他部门的同事的收集，因此千万别忘记抓住给你数据的人，问问她/他各个项都是什么含义。通常来说，当特征非常多的时候（比如几百个），都会有一个附带的excel或pdf文档给到你，备注了各个特征都是什么含义。这种情况下其实要一个个去看还是非常困难，所以如果特征很多，建议先做降维.
三.探索数据与数据预处理
在这一步我们要样本总体的大概情况，比如查看缺失值，量纲是否统一，是否需要做哑变量等等。其实数据的探索和数据的预处理并不是完全分开的，并不一定非要先做哪一个，因此这个顺序只是供大家参考。
1.去除重复值
现实数据，尤其是银行业数据，可能会存在的一个问题就是样本重复，即有超过一行的样本所显示的所有特征都一样。有时候可能时人为输入重复，有时候可能是系统录入重复，总而言之我们必须对数据进行去重处理。可能有人会说，难道不可能出现说两个样本的特征就是一模一样，但他们是两个样本吗？比如，两个人，一模一样的名字，年龄，性别，学历，工资……当特征量很少的时候，这的确是有可能的，但一些指标，比如说家属人数，月收入，已借有的房地产贷款数量等等，几乎不可能都出现一样。尤其是银行业数据经常是几百个特征，所有特征都一样的可能性是微乎其微的。即便真的出现了如此极端的情况，我们也可以当作是少量信息损失，将这条记录当作重复值除去。
2.填补缺失值
第二个要面临的问题，就是缺失值。在这里我们需要填补的特征是“收入”和“家属人数”。“家属人数”缺失很少，仅缺失了大约2.5%，可以考虑直接删除，或者使用均值来填补。“收入”缺失了几乎20%，并且我们知道，“收入”必然是一个对信用评分来说很重要的因素，因此这个特征必须要进行填补。在这里，我们使用均值填补“家属人数”。
那字段"收入"怎么办呢？对于银行数据来说，我们甚至可以有这样的推断：一个来借钱的人应该是会知道，“高收入”或者“稳定收入”于他/她自己而言会是申请贷款过程中的一个助力，因此如果收入稳定良好的人，肯定会倾向于写上自己的收入情况，那么这些“收入”栏缺失的人，更可能是收入状况不稳定或收入比较低的人。基于这种判断，我们可以用比如说，四分位数来填补缺失值，把所有收入为空的客户都当成是低收入人群。当然了，也有可能这些缺失是银行数据收集过程中的失误，我们并无法判断为什么收入栏会有缺失，所以我们的推断也有可能是不正确的。具体采用什么样的手段填补缺失值，要和业务人员去沟通，观察缺失值是如何产生的。在这里，我们使用随机森林填补“收入”。
随机森林利用“既然我可以使用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.
这种做法，对于某一个特征大量缺失，其他特征却很完整的情况，非常适用。
3.描述性统计处理异常值
现实数据永远都会有一些异常值，首先我们要去把他们捕捉出来，然后观察他们的性质。注意，我们并不是要排除掉所有异常值，相反很多时候，异常值是我们的重点研究对象，比如说，双十一中购买量超高的品牌，或课堂上让很多学生都兴奋的课题，这些是我们要重点研究观察的。
在银行数据中，我们希望排除的“异常值”不是一些超高或超低的数字，而是一些不符合常理的数据：比如，收入不能为负数，但是一个超高水平的收入却是合理的，可以存在的。所以在银行业中，我们往往就使用普通的描述性统计来观察数据的异常与否与数据的分布情况。
4.为什么不统一量纲，也不标准化数据分布
无论算法有什么样的规定，无论统计学中有什么样的要求，我们的最终目的都是要为业务服务。现在我们要制作评分卡，评分卡是要给业务人员们使用的基于新客户填写的各种信息为客户打分的一张卡片，而为了制作这张卡片，我们需要对我们的数据进行一个“分档”，比如说，年龄20~30岁为一档，年龄30~50岁为一档，月收入1W以上为一档，5000~1W为一档，每档的分数不同。
一旦我们将数据统一量纲，或者标准化了之后，数据大小和范围都会改变，统计结果是漂亮了，但是对于业务人员来说，他们完全无法理解，标准化后的年龄在0.00328~0.00467之间为一档是什么含义。并且，新客户填写的信息，天生就是量纲不统一的，我们的确可以将所有的信息录入之后，统一进行标准化，然后导入算法计算，但是最终落到业务人员手上去判断的时候，他们会完全不理解为什么录入的信息变成了一串统计上很美但实际上根本看不懂的数字。由于业务要求，在制作评分卡的时候，我们要尽量保持数据的原貌，年龄就是8~110的数字，收入就是大于0，最大值可以无限的数字，即便量纲不统一，我们也不对数据进行标准化处理。
5.样本不均衡问题
虽然大家都在努力防范信用风险，但实际违约的人并不多。并且，银行并不会真的一棒子打死所有会违约的人，很多人是会还钱的，只是忘记了还款日，很多人是不愿意欠人钱的，但是当时真的很困难，资金周转不过来，所以发生逾期，但一旦他有了钱，他就会把钱换上。对于银行来说，只要你最后能够把钱还上，我都愿意借钱给你，因为我借给你就有收入（利息）。所以，对于银行来说，真正想要被判别出来的其实是”恶意违约“的人，而这部分人数非常非常少，样本就会不均衡。这一直是银行业建模的一个痛点：我们永远希望捕捉少数类。
逻辑回归中使用最多的是上采样方法来平衡样本。如此，我们就实现了样本平衡，样本量也增加了。
6.分训练集和测试集
三.分箱
我们要制作评分卡，是要给各个特征进行分档，以便业务人员能够根据新客户填写的信息为客户打分。因此在评分卡制作过程中，一个重要的步骤就是分箱。可以说，分箱是评分卡最难，也是最核心的思路，分箱的本质，其实就是离散化连续变量，好让拥有不同属性的人被分成不同的类别（打上不同的分数），其实本质比较类似于聚类。
1.分多少个箱子才合适
最开始我们并不知道，但是既然是将连续型变量离散化，想也知道箱子个数必然不能太多，最好控制在十个以下。而用来制作评分卡，最好能在4~5个为最佳。我们知道，离散化连续变量必然伴随着信息的损失，并且箱子越少，信息损失越大。为了衡量特征上的信息量以及特征对预测函数的贡献，银行业定义了概念Information value(IV)：
这是我们在银行业中用来衡量违约概率的指标，中文叫做证据权重(weight of Evidence)，本质其实就是优质客户比上坏客户的比例的对数。WOE是对一个箱子来说的，WOE越大，代表了这个箱子里的优质客户越多。而IV是对整个特征来说的，IV代表的意义是我们特征上的信息量以及这个特征对模型的贡献，由下表来控制：
可见，IV并非越大越好，我们想要找到IV的大小和箱子个数的平衡点。箱子越多，IV必然越小，因为信息损失会非常多，所以，我们会对特征进行分箱，然后计算每 个特征在每个箱子数目下的WOE值，利用IV值的曲线，找出合适的分箱个数。
2.分箱要达成什么样的效果
我们希望不同属性的人有不同的分数，因此我们希望在同一个箱子内的人的属性是尽量相似的，而不同箱子的人的属性是尽量不同的，即业界常说的”组间差异大，组内差异小“。对于评分卡来说，就是说我们希望一个箱子内的人违约概率是类似的，而不同箱子的人的违约概率差距很大，即WOE差距要大，并且每个箱子中坏客户所占的比重也要不同。那我们，可以使用卡方检验来对比两个箱子之间的相似性，如果两个箱子之间卡方检验的P值很大，则说明他们非常相似，那我们就可以将这两个箱子合并为一个箱子。
基于这样的思想，我们总结出我们对一个特征进行分箱的步骤：
1）我们首先把连续型变量分成一组数量较多的分类型变量，比如，将几万个样本分成100组，或50组
2）确保每一组中都要包含两种类别的样本，否则IV值会无法计算
3）我们对相邻的组进行卡方检验，卡方检验的P值很大的组进行合并，直到数据中的组数小于设定的N箱为止
4）我们让一个特征分别分成[2,3,4.....20]箱，观察每个分箱个数下的IV值如何变化，找出最适合的分箱个数
5）分箱完毕后,我们计算每个箱的WOE值,bad值,观察分箱效果
3.等频分箱
4.定义WOE和IV函数
5.卡方检验，合并箱体，画出IV曲线
6.用最佳分箱个数分箱，并验证分箱结果
7.将选取最佳分箱个数的过程包装为函数
8.对所有特征进行分箱选择
我们发现，不是所有的特征都可以使用这个分箱函数，比如说有的特征，像家人数量，就无法分出20组。于是我们将可以分箱的特征放出来单独分组，不能自动分箱的变量自己观察然后手写.接下来对所有特征按照选择的箱体个数和手写的分箱范围进行分箱
9.计算各箱的WOE并映射到数据中
我们现在已经有了我们的箱子，接下来我们要做的是计算各箱的WOE，并且把WOE替换到我们的原始数据model_data中，因为我们将使用WOE覆盖后的数据来建模，我们希望获取的是”各个箱”的分类结果，即评分卡上各个评分项目的分类结果。
四.建模与模型验证
终于弄完了我们的训练集，接下来我们要处理测试集，在已经有分箱的情况下，测试集的处理就非常简单了，我们只需要将已经计算好的WOE映射到测试集中去就可以了
返回的结果一般，我们可以试着使用C和max_iter的学习曲线把逻辑回归的效果调上去。
五.制作评分卡
建模完毕，我们使用准确率和ROC曲线验证了模型的预测能力。接下来就是要讲逻辑回归转换为标准评分卡了。评分卡中的分数，由以下公式计算：
六.评分卡代码实现
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression as LR
data = pd.read_csv(r"./rankingcard.csv",index_col=0)
print(data.head()) # 注意可以看到第一列为标签，剩下的10列为特征
# 观察数据结构
print(data.shape) # (150000, 11)
print(data.info())
data.drop_duplicates(inplace=True)
print(data.info())
# 删除之后千万不要忘记，恢复索引
data.index = range(data.shape[0])
print(data.info())
#探索缺失值
print(data.info())
print(data.isnull().sum()/data.shape[0])#得到缺失值的比例
print(data.isnull().mean())#上一行代码的另一种形式书写
data["NumberOfDependents"].fillna(int(data["NumberOfDependents"].mean()), inplace=True)
# 这里用均值填补家庭人数这一项
# 如果你选择的是删除那些缺失了2.5%的特征，千万记得恢复索引哟~
print(data.info())
print(data.isnull().sum() / data.shape[0])
def fill_missing_rf(X,y,to_fill):
"""
使用随机森林填补一个特征的缺失值的函数
参数：
X：要填补的特征矩阵
y：完整的，没有缺失值的标签
to_fill：字符串，要填补的那一列的名称
"""
#构建我们的新特征矩阵和新标签
df = X.copy()
fill = df.loc[:,to_fill]#提取出需要填补的那一列
df = pd.concat([df.loc[:,df.columns != to_fill],pd.DataFrame(y)],axis=1)#concat将两个dataframe进行合并
# 找出我们的训练集和测试集
Ytrain = fill[fill.notnull()]
Ytest = fill[fill.isnull()]
Xtrain = df.iloc[Ytrain.index,:]
Xtest = df.iloc[Ytest.index,:]
#用随机森林回归来填补缺失值
from sklearn.ensemble import RandomForestRegressor as rfr
rfr = rfr(n_estimators=100)#实例化
rfr = rfr.fit(Xtrain, Ytrain)#导入
Ypredict = rfr.predict(Xtest)#预测
return Ypredict
X = data.iloc[:,1:]
y = data["SeriousDlqin2yrs"]#y = data.iloc[:,0]
print(X.shape)#(149391, 10)
#=====[TIME WARNING:1 min]=====#
y_pred = fill_missing_rf(X,y,"MonthlyIncome")
#注意可以通过以下代码检验数据是否数量相同
# y_pred.shape == data.loc[data.loc[:,"MonthlyIncome"].isnull(),"MonthlyIncome"].shape
#确认我们的结果合理之后，我们就可以将数据覆盖了
data.loc[data.loc[:,"MonthlyIncome"].isnull(),"MonthlyIncome"] = y_pred
print(data.info())
print(data.describe([0.01,0.1,0.25,.5,.75,.9,.99]).T)
#异常值也被我们观察到，年龄的最小值居然有0，这不符合银行的业务需求，即便是儿童账户也要至少8岁，我们可以
# 查看一下年龄为0的人有多少
print((data["age"] == 0).sum())
#发现只有一个人年龄为0，可以判断这肯定是录入失误造成的，可以当成是缺失值来处理，直接删除掉这个样本
data = data[data["age"] != 0]
"""
另外，有三个指标看起来很奇怪：
"NumberOfTime30-59DaysPastDueNotWorse"
"NumberOfTime60-89DaysPastDueNotWorse"
"NumberOfTimes90DaysLate"
这三个指标分别是“过去两年内出现35-59天逾期但是没有发展的更坏的次数”，“过去两年内出现60-89天逾期但是没
有发展的更坏的次数”,“过去两年内出现90天逾期的次数”。这三个指标，在99%的分布的时候依然是2，最大值却是
98，看起来非常奇怪。一个人在过去两年内逾期35~59天98次，一年6个60天，两年内逾期98次这是怎么算出来的？
我们可以去咨询业务人员，请教他们这个逾期次数是如何计算的。如果这个指标是正常的，那这些两年内逾期了98次的
客户，应该都是坏客户。在我们无法询问他们情况下，我们查看一下有多少个样本存在这种异常：
"""
print(data[data.loc[:,"NumberOfTimes90DaysLate"] > 90])
print(data[data.loc[:,"NumberOfTimes90DaysLate"] > 90].count())#count用来计数
print(data.loc[:,"NumberOfTimes90DaysLate"].value_counts())#对取值进行计数
# 有225个样本存在这样的情况，并且这些样本，我们观察一下，标签并不都是1，他们并不都是坏客户。因此，我们基
# 本可以判断，这些样本是某种异常，应该把它们删除。
data = data[data.loc[:, "NumberOfTimes90DaysLate"] < 90]#删数据会保留原来的索引,因此一定要恢复索引
data.index = range(data.shape[0])
print(data.info())
# 探索标签的分布
X = data.iloc[:, 1:]
y = data.iloc[:, 0]
print(y.value_counts()) # 查看每一类别值得数据量，查看样本是否均衡
n_sample = X.shape[0]
n_1_sample = y.value_counts()[1]
n_0_sample = y.value_counts()[0]
print('样本个数：{}; 1占{:.2%}; 0占{:.2%}'.format(n_sample, n_1_sample / n_sample, n_0_sample / n_sample))
# 样本个数：149165; 1占6.62%; 0占93.38%
# 如果报错，就在prompt安装：pip install imblearn
import imblearn
# imblearn是专门用来处理不平衡数据集的库，在处理样本不均衡问题中性能高过sklearn很多
# imblearn里面也是一个个的类，也需要进行实例化，fit拟合，和sklearn用法相似
from imblearn.over_sampling import SMOTE#上采样处理数据不平衡
sm = SMOTE(random_state=42) # 实例化
X, y = sm.fit_sample(X, y)
n_sample_ = X.shape[0] # 278584
pd.Series(y).value_counts()
n_1_sample = pd.Series(y).value_counts()[1]
n_0_sample = pd.Series(y).value_counts()[0]
print('样本个数：{}; 1占{:.2%}; 0占{:.2%}'.format(n_sample_, n_1_sample / n_sample_, n_0_sample / n_sample_))
# 样本个数：278584; 1占50.00%; 0占50.00%
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.index = range(model_data.shape[0])#设置行索引
model_data.columns = data.columns#设置成列索引
vali_data = pd.concat([Y_vali, X_vali], axis=1) #组合成验证集
vali_data.index = range(vali_data.shape[0])#设置行索引
vali_data.columns = data.columns#设置成列索引
model_data.to_csv(r"./model_data.csv") # 训练数据
vali_data.to_csv(r"./vali_data.csv") # 验证数据
# dataframe["列名"]
# 当这个列存在的时候，就是索引；当这个列名不存在的时候，DataFrame会自动生成叫做这个列名的一个新的列
# 按照等频对需要分箱的列进行分箱
# “age”为例子
model_data["qcut"], updown = pd.qcut(model_data["age"], retbins=True, q=20) # 分享操作,等频分箱
"""
pd.qcut，基于分位数的分箱函数，本质是将连续型变量离散化
只能够处理一维数据。返回箱子的上限和下限
参数q：要分箱的个数
参数retbins=True来要求同时返回结构为索引为样本索引，元素为分到的箱子的Series
现在返回两个值：每个样本属于哪个箱子，以及所有箱子的上限和下限
"""
# 在这里时让model_data新添加一列叫做“分箱”，这一列其实就是每个样本所对应的箱子
print(model_data.head())
print(model_data["qcut"])
print(model_data["qcut"].value_counts())
# 所有箱子的上限和下限
print(updown)
# 这里使用了数据透视表的功能groupby
coount_y0 = model_data[model_data["SeriousDlqin2yrs"] == 0].groupby(by="qcut").count()["SeriousDlqin2yrs"]# 统计每个分箱中0的数量
coount_y1 = model_data[model_data["SeriousDlqin2yrs"] == 1].groupby(by="qcut").count()["SeriousDlqin2yrs"]# 统计每个分箱中1的数量
# num_bins值分别为每个区间的上界，下界，0出现的次数，1出现的次数
num_bins = [*zip(updown, updown[1:], coount_y0, coount_y1)]#会生成一个个元组,惰性对象要加[*]把值显现出来,注意zip会按照最短列来进行结合
print(num_bins)
# 计算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.count_0.sum()是所有样本为0类的总数
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
num_bins_ = num_bins.copy()
import matplotlib.pyplot as plt
import scipy
IV = []
axisx = []
while len(num_bins_) > 2: # 大于设置的最低分箱个数,限制箱体数
pvs = []
# 获取 num_bins_两两之间的卡方检验的置信度（或卡方值）
for i in range(len(num_bins_) - 1):#计算卡方值,对相邻的组进行卡方检验
x1 = num_bins_[i][2:]#提取0的个数,1的个数
x2 = num_bins_[i + 1][2:]#提取相邻组0的个数,1的个数
# 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_)
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)
print(afterbins)
bins_df = get_woe(num_bins)
print(bins_df)
# 希望每组的bad_rate相差越大越好；
# woe差异越大越好，应该具有单调性，随着箱的增加，要么由正到负，要么由负到正，只能有一个转折过程；
# 如果woe值大小变化是有两个转折，比如呈现w型，证明分箱过程有问题
# num_bins保留的信息越多越好
def graphforbestbin(DF, X, Y, n=5, 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
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
def get_iv(df):
rate = df["good%"] - df["bad%"]
iv = np.sum(rate * df.woe)
return iv
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
print(model_data.columns)
for i in model_data.columns[1:-1]:
print(i)
graphforbestbin(model_data,i,"SeriousDlqin2yrs",n=2,q=20)
auto_col_bins = {"RevolvingUtilizationOfUnsecuredLines":6,
"age":5,
"DebtRatio":4,
"MonthlyIncome":3,
"NumberOfOpenCreditLinesAndLoans":5}
#不能使用自动分箱的变量
hand_bins = {"NumberOfTime30-59DaysPastDueNotWorse":[0,1,2,13]
,"NumberOfTimes90DaysLate":[0,1,2,17]
,"NumberRealEstateLoansOrLines":[0,1,2,4,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 = {}
# 生成自动分箱的分箱区间和分箱后的 IV 值
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
# 合并手动分箱数据
bins_of_col.update(hand_bins)#字典合并,把hand_bins加到bins_of_col里面去
print(bins_of_col)
data = model_data.copy()
# 函数pd.cut，可以根据已知的分箱间隔把数据分箱
# 参数为 pd.cut(数据，以列表表示的分箱间隔)
data = data[["age", "SeriousDlqin2yrs"]].copy()
data["cut"] = pd.cut(data["age"], [-np.inf, 48.49986200790144, 58.757170160044694, 64.0, 74.0, np.inf])
print(data.head())
# 将数据按分箱结果聚合，并取出其中的标签值
print(data.groupby("cut")["SeriousDlqin2yrs"].value_counts())
print(data.groupby("cut")["SeriousDlqin2yrs"].value_counts().unstack())# 使用unstack()来将树状结构变成表状结构,变成了columns为0,1的dataframe
bins_df = data.groupby("cut")["SeriousDlqin2yrs"].value_counts().unstack()
bins_df["woe"] = np.log((bins_df[0] / bins_df[0].sum()) / (bins_df[1] / bins_df[1].sum()))
print(bins_df)
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
woeall = {}
for col in bins_of_col:
woeall[col] = get_woe(model_data, col, "SeriousDlqin2yrs", bins_of_col[col])
print(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"])
# 对所有特征操作可以写成：
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"]
# 这就是我们的建模数据了
print(model_woe.head())
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]
X = model_woe.iloc[:, :-1]
y = model_woe.iloc[:, -1]
from sklearn.linear_model import LogisticRegression as LR#逻辑回归
lr = LR().fit(X, y)
lr.score(vali_X, vali_y) # 0.8641356370249832
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()
print(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)#max_iter为最大迭代次数
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#ROC曲线,ROC所囊括的面积越大,即AUC面积越大,效果越好
# %%cmd
# pip install scikit-plot
vali_proba_df = pd.DataFrame(lr.predict_proba(vali_X))#predict_proba是每个类别的概率
skplt.metrics.plot_roc(vali_y, vali_proba_df,
plot_micro=False, figsize=(6, 6),
plot_macro=False)
B = 20/np.log(2)
A = 600 + B*np.log(1/60)
print(B,A)
base_score = A - B * lr.intercept_ # lr.intercept_：截距
print(base_score) # array([481.56390143])
score_age = woeall["age"] * (-B * lr.coef_[0][1]) # lr.coef_：每一个特征建模之后得出的系数
print(score_age) # "age"特征中每个箱对应的分数
file = "./ScoreData.csv"
# open是用来打开文件的python命令，第一个参数是文件的路径+文件名，如果你的文件是放在根目录下，则你只需要文件名就好
# 第二个参数是打开文件后的用途，"w"表示用于写入，通常使用的是"r"，表示打开来阅读
# 首先写入基准分数
# 之后使用循环，每次生成一组score_age类似的分档和分数，不断写入文件之中
with open(file, "w") as fdata:#open用来打开文件
fdata.write("base_score,{}\n".format(base_score))
for i, col in enumerate(X.columns): # [*enumerate(X.columns)],enumerate将数字和对象组成一个个元组
score = woeall[col] * (-B * lr.coef_[0][i])
score.name = "Score"
score.index.name = col
score.to_csv(file, header=True, mode="a")
![[1.#]第一章 计算机系统概述——知识回顾](https://img-blog.csdnimg.cn/img_convert/f79b2cbf5c2dcb89130f46edf1187bcb.png)
