机器学习Sklearn Day6
2.3 梯度下降：重要参数max_iter
逻辑回归的数学目的是求解能够让模型最优化，拟合程度最好的参数θ的值，即求解能够让损失函数J（θ）最小化的θ值。对于二元逻辑回归来说，有多种方法可以用来求解参数θ ，最常见的有梯度下降法(Gradient Descent)，坐标下降法(Coordinate Descent)，牛顿法(Newton-Raphson method)等，其中又以梯度下降法最为著名。每种方法都涉及复杂的数学原理，但这些计算在执行的任务其实是类似的。
2.3.1 梯度下降求解逻辑回归
那我们怎么做呢？我在这个图像上随机放一个小球，当我松手，这个小球就会顺着这个华丽的平面滚落，直到滚到 深蓝色的区域——损失函数的最低点。为了严格监控这个小球的行为，我让小球每次滚动的距离有限，不让他一次性滚到最低点，并且最多只允许它滚动100步，还要记下它每次滚动的方向，直到它滚到图像上的最低点。
可以看见，小球从高处滑落，在深蓝色的区域中来回震荡，最终停留在了图像凹陷处的某个点上。非常明显，我们 可以观察到几个现象：
首先，小球并不是一开始就直向着最低点去的，它先一口气冲到了蓝色区域边缘，后来又折回来，我们已经规定了 小球是多次滚动，所以可见，小球每次滚动的方向都是不同的。
另外，小球在进入深蓝色区域后，并没有直接找到某个点，而是在深蓝色区域中来回震荡了数次才停下。这有两种 可能：1) 小球已经滚到了图像的最低点，所以停下了，2) 由于我设定的步数限制，小球还没有找到最低点，但也只好在100步的时候停下了。也就是说，小球不一定滚到了图像的最低处。
但无论如何，小球停下的就是我们在现有状况下可以获得的唯一点了。如果我们够幸运，这个点就是图像的最低 点，那我们只要找到这个点的对应坐标(θ*1，θ*2，Jmin )，就可以获取能够让损失函数最小的参数取值
[θ*1，θ*2]了。如此，梯度下降的过程就已经完成。
在这个过程中，小球其实就是一组组的坐标点 （θ1，θ2，J）；小球每次滚动的方向就是那一个坐标点的梯度向量的方向，因为每滚动一步，小球所在的位置都发生变化，坐标点和坐标点对应的梯度向量都发生了变化，所以每次滚动的方向也都不一样；人为设置的100次滚动限制，就是sklearn中逻辑回归的参数max_iter，代表着能走的最大步数，即最大迭代次数。
所以梯度下降，其实就是在众多（θ1，θ2）可能的值中遍历，一次次求解坐标点的梯度向量，不断让损失函数J的取值逐渐逼近最小值，再返回这个最小值对应的参数取值[θ*1，θ*2]的过程。
2.3.2 梯度下降的概念与解惑
那梯度有什么含义呢？梯度是一个向量，因此它有大小也有方向。它的大小，就是偏导数组成的向量的大小，又叫 做向量的模，
记作d 。它的方向，几何上来说，就是损失函数J(θ) 的值增加最快的方向，就是小球每次滚动的方向的反方向。只要沿着梯度向量的反动坐标，损失函数的取值就会减少得最快，也就最容易找到损失函数的最小值。
在逻辑回归中，我们的损失函数如下所示：
2.3.3 步长的概念与解惑
所以，步长不是任何物理距离，它甚至不是梯度下降过程中任何距离的直接变化,它是梯度向量的大小 d 上的一个比例，影响着参数向量 θ 每次迭代后改变的部分。
不难发现，
既然参数迭代是靠梯度向量的大小d * α步长 来实现的，J（θ）而的降低又是靠调节θ 来实现的，所以步长可以调节损失函数下降的速率。在损失函数降低的方向上，步长越长， θ 的变动就越大。相对的，步长如果很短， θ的每次变动就很小。具体地说，如果步长（α）太大，损失函数J（θ）下降得就非常快，需要的迭代次数就很少，但梯度下降过程可能跳过损失函数的最低点，无法获取最优值。而步长太小，虽然函数会逐渐逼近我们需要的最低点，但迭代的 速度却很缓慢，迭代次数就需要很多。
记得我们在看小球运动时注意到，小球在进入深蓝色区域后，并没有直接找到某个点，而是在深蓝色区域中来回震 荡了数次才停下，这种”震荡“其实就是因为我们设置的步长太大的缘故。但是在我们开始梯度下降之前，我们并不 知道什么样的步长才合适，但梯度下降一定要在某个时候停止才可以，否则模型可能会无限地迭代下去。因此，在sklearn当中，我们设置参数max_iter最大迭代次数来代替步长，帮助我们控制模型的迭代速度并适时地让模型停下。max_iter越大，代表步长越小，模型迭代时间越长，反之，则代表步长设置很大，模型迭代时间很短。
迭代结束，获取到J（θ） 的最小值后，我们就可以找出这个最小值对应的参数向量 θ ，逻辑回归的预测函数也就可以根据这个参
数向量θ 来建立了。
来看看乳腺癌数据集下，max_iter的学习曲线：
| #导库 from sklearn.linear_model import LogisticRegression as LR #导入线性模型中的逻辑回归 from sklearn.datasets import load_breast_cancer #导入乳腺癌数据集 import numpy as np import matplotlib.pyplot as plt from sklearn.model_selection import train_test_split #分测试集和训练集的类 from sklearn.metrics import accuracy_score #矩阵模块导入精确性分数 data = load_breast_cancer() #数据实例化 X = data.data #特征矩阵 y = data.target #标签矩阵 X.shape #569行，30个特征 l2 = [] l2test = [] #划分训练集测试集 Xtrain, Xtest, Ytrain, Ytest = train_test_split(X,y,test_size=0.3,random_state=420) for i in np.arange(1,201,10): #max_iter最大迭代次数，l2正则化 lrl2 = LR(penalty="l2",solver="liblinear",C=0.8,max_iter=i) #实例化 lrl2 = lrl2.fit(Xtrain,Ytrain) l2.append(accuracy_score(lrl2.predict(Xtrain),Ytrain)) #训练集表现结果 l2test.append(accuracy_score(lrl2.predict(Xtest),Ytest)) #测试集表现结果 graph = [l2,l2test] color = ["black","gray"] label = ["L2","L2test"] plt.figure(figsize=(20,5)) for i in range(len(graph)): plt.plot(np.arange(1,201,10),graph[i],color[i],label=label[i]) plt.legend(loc=4) plt.xticks(np.arange(1,201,10)) plt.show() #我们可以使用属性.n_iter_来调用本次求解中真正实现的迭代次数 #最多可以迭代300次，看究竟迭代几次就找到最佳值 lr = LR(penalty="l2",solver="liblinear",C=0.9,max_iter=300).fit(Xtrain,Ytrain) lr.n_iter_ -->array([25], dtype=int32) |
模型最大迭代次数21左右
当max_iter中限制的步数已经走完了，逻辑回归却还没有找到损失函数的最小值，θ参数 的值还没有被收敛，
sklearn就会弹出这样的红色警告：
当参数solver="liblinear"：
当参数solver="sag"：
虽然写法看起来略有不同，但其实都是一个含义，这是在提醒我们：参数没有收敛，请增大max_iter中输入的数字。但我们不一定要听sklearn的。max_iter很大，意味着步长小，模型运行得会更加缓慢。虽然我们在梯度下降中追求的是损失函数的最小值，但这也可能意味着我们的模型会过拟合（在训练集上表现得太好，在测试集上却不 一定），因此，如果在max_iter报红条的情况下，模型的训练和预测效果都已经不错了，那我们就不需要再增大max_iter中的数目了，毕竟一切都以模型的预测效果为基准——只要最终的预测效果好，运行又快，那就一切都好，无所谓是否报红色警告了。
2.4 二元回归与多元回归：重要参数solver & multi_class
之前我们对逻辑回归的讨论，都是针对二分类的逻辑回归展开，其实sklearn提供了多种可以使用逻辑回归处理多 分类问题的选项。比如说，我们可以把某种分类类型都看作1，其余的分类类型都为0值，和”数据预处理“中的二值 化的思维类似，这种方法被称为"一对多"(One-vs-rest)，简称OvR，在sklearn中表示为“ovr"。又或者，我们可以把好几个分类类型划为1，剩下的几个分类类型划为0值，这是一种”多对多“(Many-vs-Many)的方法，简称MvM，在sklearn中表示为"Multinominal"。每种方式都配合L1或L2正则项来使用。
在sklearn中，我们使用参数multi_class来告诉模型，我们的预测标签是什么样的类型。
multi_class
输入"ovr", "multinomial", "auto"来告知模型，我们要处理的分类问题的类型。默认是"ovr"。
'ovr':表示分类问题是二分类，或让模型使用"一对多"的形式来处理多分类问题。
'multinomial'：表示处理多分类问题，这种输入在参数solver是'liblinear'（专门处理二分类的）时不可用。
"auto"：表示会根据数据的分类情况和其他参数来确定模型要处理的分类问题的类型。比如说，如果数据是二分类，或者solver的取值为"liblinear"，"auto"会默认选择"ovr"。反之，则会选择"nultinomial"。
注意：默认值将在0.22版本中从"ovr"更改为"auto"。
我们之前提到的梯度下降法，只是求解逻辑回归参数θ 的一种方法，并且我们只讲解了求解二分类变量的参数时的各种原理。sklearn为我们提供了多种选择，让我们可以使用不同的求解器来计算逻辑回归。求解器的选择，由参数"solver"控制，共有五种选择。其中“liblinear”是二分类专用（不支持多分类），也是现在的默认求解器。
来看看鸢尾花数据集上，multinomial和ovr的区别怎么样：
| from sklearn.linear_model import LogisticRegression as LR #导入线性模型中的逻辑回归 from sklearn.datasets import load_iris #鸢尾花数据集 import numpy as np from sklearn.metrics import accuracy_score iris = load_iris() for multi_class in ('multinomial', 'ovr'): #两种参数'multinomial', 'ovr' lr = LR(solver='sag', max_iter=100, random_state=42, multi_class=multi_class).fit(iris.data, iris.target) #打印两种multi_class模式下的训练分数 print("training score : %.3f (%s)" % (lr.score(iris.data, iris.target), multi_class)) #%的用法，用%来代替打印的字符串中，想由变量替换的部分。%.3f表示，保留三位小数的浮点数。%s表示，字符串。 #字符串后的%后使用元祖来容纳变量，字符串中有几个%，元祖中就需要有几个变量 |
2.5 样本不平衡与参数class_weight
样本不平衡是指在一组数据集中，标签的一类天生占有很大的比例，或误分类的代价很高，即我们想要捕捉出某种 特定的分类的时候的状况。
什么情况下误分类的代价很高？例如，我们现在要对潜在犯罪者和普通人进行分类，如果没有能够识别出潜在犯罪 者，那么这些人就可能去危害社会，造成犯罪，识别失败的代价会非常高，但如果，我们将普通人错误地识别成了 潜在犯罪者，代价却相对较小。所以我们宁愿将普通人分类为潜在犯罪者后再人工甄别，但是却不愿将潜在犯罪者 分类为普通人，有种"宁愿错杀不能放过"的感觉。
再比如说，在银行要判断“一个新客户是否会违约”，通常不违约的人vs违约的人会是99：1的比例，真正违约的人 其实是非常少的。这种分类状况下，即便模型什么也不做，全把所有人都当成不会违约的人，正确率也能有99%， 这使得模型评估指标变得毫无意义，根本无法达到我们的“要识别出会违约的人”的建模目的。
因此我们要使用参数class_weight对样本标签进行一定的均衡，给少量的标签更多的权重，让模型更偏向少数类，向捕获少数类的方向建模。该参数默认None，此模式表示自动给与数据集中的所有标签相同的权重，即自动1：1。当误分类的代价很高的时候，我们使用”balanced“模式，我们只是希望对标签进行均衡的时候，什么都不填就可以解决样本不均衡问题。
但是，sklearn当中的参数class_weight变幻莫测，大家用模型跑一跑就会发现，我们很难去找出这个参数引导的模型趋势，或者画出学习曲线来评估参数的效果，因此可以说是非常难用。我们有着处理样本不均衡的各种方法，其 中主流的是采样法，是通过重复样本的方式来平衡标签，可以进行上采样（增加少数类的样本），比如SMOTE， 或者下采样（减少多数类的样本）。对于逻辑回归来说，上采样是最好的办法。在案例中，会给大家详细来讲如何 在逻辑回归中使用上采样。
3 案例：用逻辑回归制作评分卡
在银行借贷场景中，评分卡是一种以分数形式来衡量一个客户的信用风险大小的手段，它衡量向别人借钱的人（受 信人，需要融资的公司）不能如期履行合同中的还本付息责任，并让借钱给别人的人（授信人，银行等金融机构） 造成经济损失的可能性。一般来说，评分卡打出的分数越高，客户的信用越好，风险越小。
这些”借钱的人“，可能是个人，有可能是有需求的公司和企业。对于企业来说，我们按照融资主体的融资用途，分 别使用企业融资模型，现金流融资模型，项目融资模型等模型。而对于个人来说，我们有”四张卡“来评判个人的信 用程度：A卡，B卡，C卡和F卡。而众人常说的“评分卡”其实是指A卡，又称为申请者评级模型，主要应用于相关融 资类业务中新用户的主体评级，即判断金融机构是否应该借钱给一个新用户，如果这个人的风险太高，我们可以拒 绝贷款。
一个完整的模型开发，需要有以下流程：
今天我们以个人消费类贷款数据，来为大家简单介绍A卡的建模和制作流程，由于时间有限，我们的核心会在”数据 清洗“和“模型开发”上。模型检验与评估也非常重要，但是在今天的课中，内容已经太多，我们就不再去赘述了。
3.1导库，获取数据
| #导库，获取数据 %matplotlib inline import numpy as np import pandas as pd from sklearn.linear_model import LogisticRegression as LR #逻辑回归 #其实日常在导库的时候，并不是一次性能够知道我们要用的所有库的。通常都是在建模过程中逐渐导入需要的库。 #读取数据 data = pd.read_csv(r"E:\拜师教育学习\机器学习Sklearn\逻辑回归\rankingcard.csv",index_col=0) |
在银行系统中，这个数据通常使来自于其他部门的同事的收集，因此千万别忘记抓住给你数据的人，问问她/他各 个项都是什么含义。通常来说，当特征非常多的时候（比如几百个），都会有一个附带的excel或pdf文档给到你， 备注了各个特征都是什么含义。这种情况下其实要一个个去看还是非常困难，所以如果特征很多，建议先做降维， 具体参考“2.2.2 逻辑回归中的特征工程”。
3.2 探索数据与数据预处理
在这一步我们要样本总体的大概情况，比如查看缺失值，量纲是否统一，是否需要做哑变量等等。其实数据的探索 和数据的预处理并不是完全分开的，并不一定非要先做哪一个，因此这个顺序只是供大家参考。
| #观察数据类型 data.head()
#观察数据结构 data.shape #150000行，11列（有一列为标签，所以10个特征） -->(150000, 11) data.info() --> Int64Index: 150000 entries, 1 to 150000 Data columns (total 11 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 SeriousDlqin2yrs 150000 non-null int64 1 RevolvingUtilizationOfUnsecuredLines 150000 non-null float64 2 age 150000 non-null int64 3 NumberOfTime30-59DaysPastDueNotWorse 150000 non-null int64 4 DebtRatio 150000 non-null float64 5 MonthlyIncome 120269 non-null float64 6 NumberOfOpenCreditLinesAndLoans 150000 non-null int64 7 NumberOfTimes90DaysLate 150000 non-null int64 8 NumberRealEstateLoansOrLines 150000 non-null int64 9 NumberOfTime60-89DaysPastDueNotWorse 150000 non-null int64 10 NumberOfDependents 146076 non-null float64 |
| 特征/标签 |
含义 |
| SeriousDlqin2yrs |
出现 90 天或更长时间的逾期行为（即定义好坏客户） |
| RevolvingUtilizationOfUnsecuredLines |
贷款以及信用卡可用额度与总额度比例 |
| age |
借款人借款年龄 |
| NumberOfTime30-59DaysPastDueNotWorse |
过去两年内出现35-59天逾期但是没有发展得更坏的次数 |
| DebtRatio |
每月偿还债务，赡养费，生活费用除以月总收入 |
| MonthlyIncome |
月收入 |
| NumberOfOpenCreditLinesAndLoans |
开放式贷款和信贷数量 |
| NumberOfTimes90DaysLate |
过去两年内出现90天逾期或更坏的次数 |
| NumberRealEstateLoansOrLines |
抵押贷款和房地产贷款数量，包括房屋净值信贷额度 |
| NumberOfTime60-89DaysPastDueNotWorse |
过去两年内出现60-89天逾期但是没有发展得更坏的次数 |
| NumberOfDependents |
家庭中不包括自身的家属人数（配偶，子女等） |
3.2.1 去除重复值
现实数据，尤其是银行业数据，可能会存在的一个问题就是样本重复，即有超过一行的样本所显示的所有特征都一 样。有时候可能时人为输入重复，有时候可能是系统录入重复，总而言之我们必须对数据进行去重处理。可能有人 会说，难道不可能出现说两个样本的特征就是一模一样，但他们是两个样本吗？比如，两个人，一模一样的名字， 年龄，性别，学历，工资……当特征量很少的时候，这的确是有可能的，但一些指标，比如说家属人数，月收入,已借有的房地产贷款数量等等，几乎不可能都出现一样。尤其是银行业数据经常是几百个特征，所有特征都一样的可能性是微乎其微的。即便真的出现了如此极端的情况，我们也可以当作是少量信息损失，将这条记录当作重复值除去。
| #去除重复值 #drop_duplicates(inplace=True) 删除重复的行，并且覆盖原数据 data.drop_duplicates(inplace=True) data.info() #数据从150000删除到149391，此事索引还是150000 -->Int64Index: 149391 entries, 1 to 150000 #删除之后千万不要忘记，恢复索引 data.shape[0] -->149391 data.index = range(data.shape[0]) data.info() -->Int64Index: 149391 entries, 1 to 149390 |
3.2.2 填补缺失值
| #探索缺失值data.info() data.isnull().sum() #是空值的数 -->SeriousDlqin2yrs 0 RevolvingUtilizationOfUnsecuredLines 0 age 0 NumberOfTime30-59DaysPastDueNotWorse 0 DebtRatio 0 MonthlyIncome 29221 NumberOfOpenCreditLinesAndLoans 0 NumberOfTimes90DaysLate 0 NumberRealEstateLoansOrLines 0 NumberOfTime60-89DaysPastDueNotWorse 0 NumberOfDependents 3828 dtype: int64 #方式二 data.isnull().mean() --> SeriousDlqin2yrs 0.000000 RevolvingUtilizationOfUnsecuredLines 0.000000 age 0.000000 NumberOfTime30-59DaysPastDueNotWorse 0.000000 DebtRatio 0.000000 MonthlyIncome 0.195601 NumberOfOpenCreditLinesAndLoans 0.000000 NumberOfTimes90DaysLate 0.000000 NumberRealEstateLoansOrLines 0.000000 NumberOfTime60-89DaysPastDueNotWorse 0.000000 NumberOfDependents 0.025624 dtype: float64 |
第二个要面临的问题，就是缺失值。在这里我们需要填补的特征是“收入”和“家属人数”。“家属人数”缺失很少，仅缺 失了大约2.5%，可以考虑直接删除，或者使用均值来填补。“收入”缺失了几乎20%，并且我们知道，“收入”必然是 一个对信用评分来说很重要的因素，因此这个特征必须要进行填补。在这里，我们使用均值填补“家属人数”。
| #填补家属人数 data["NumberOfDependents"].fillna(int(data["NumberOfDependents"].mean()),inplace=True) #如果你选择的是删除那些缺失了2.5%的特征，千万记得恢复索引哟~ data.info() data.isnull().sum() #完成家属人数填补 -->SeriousDlqin2yrs 0 RevolvingUtilizationOfUnsecuredLines 0 age 0 NumberOfTime30-59DaysPastDueNotWorse 0 DebtRatio 0 MonthlyIncome 29221 NumberOfOpenCreditLinesAndLoans 0 NumberOfTimes90DaysLate 0 NumberRealEstateLoansOrLines 0 NumberOfTime60-89DaysPastDueNotWorse 0 NumberOfDependents 0 |
那字段"收入"怎么办呢？对于银行数据来说，我们甚至可以有这样的推断：一个来借钱的人应该是会知道，“高收 入”或者“稳定收入”于他/她自己而言会是申请贷款过程中的一个助力，因此如果收入稳定良好的人，肯定会倾向于 写上自己的收入情况，那么这些“收入”栏缺失的人，更可能是收入状况不稳定或收入比较低的人。基于这种判断， 我们可以用比如说，四分位数来填补缺失值，把所有收入为空的客户都当成是低收入人群。当然了，也有可能这些 缺失是银行数据收集过程中的失误，我们并无法判断为什么收入栏会有缺失，所以我们的推断也有可能是不正确 的。具体采用什么样的手段填补缺失值，要和业务人员去沟通，观察缺失值是如何产生的。在这里，我们使用随机 森林填补“收入”。
还记得我们用随机森林填补缺失值的案例么？随机森林利用“既然我可以使用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(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) #找出我们的训练集和测试集 Ytrain = fill[fill.notnull()] #特征T不缺失的值 Ytest = fill[fill.isnull()] #特征T缺失的值 Xtrain = df.iloc[Ytrain.index,:] #特征T不缺失的值对应的其他n-1个特征 + 本来的标签 Xtest = df.iloc[Ytest.index,:] #特征T缺失的值对应的其他n-1个特征 + 本来的标签 #用随机森林回归来填补缺失值 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"] X.shape -->(149391, 10) #=====【TIME WARNING：1 min】=====# y_pred = fill_missing_rf(X,y,"MonthlyIncome") #随机森林（X，y，要填的列名） #确认我们的结果合理之后，我们就可以将数据覆盖了 #取出所有 data.loc[data.loc[:,"MonthlyIncome"].isnull(),"MonthlyIncome"] = y_pred y_pred #预测的值 -->array([0.14, 0.26, 0.11, ..., 0.23, 0.12, 0. ]) data.loc[data.loc[:,"MonthlyIncome"].isnull(),"MonthlyIncome"] #就是“月收入”为缺失值的行 -->Series([], Name: MonthlyIncome, dtype: float64) data.info() #完成月收入缺失值填补 -->5 MonthlyIncome 149391 non-null float64 |
3.2.3 描述性统计处理异常值
现实数据永远都会有一些异常值，首先我们要去把他们捕捉出来，然后观察他们的性质。注意，我们并不是要排除 掉所有异常值，相反很多时候，异常值是我们的重点研究对象，比如说，双十一中购买量超高的品牌，或课堂上让 很多学生都兴奋的课题，这些是我们要重点研究观察的。
日常处理异常值，我们使用箱线图或者法则来找到异常值（千万不要说依赖于眼睛看，我们是数据挖掘工程师， 除了业务理解，我们还要有方法）。但在银行数据中，我们希望排除的“异常值”不是一些超高或超低的数字，而是 一些不符合常理的数据：比如，收入不能为负数，但是一个超高水平的收入却是合理的，可以存在的。所以在银行业中，我们往往就使用普通的描述性统计来观察数据的异常与否与数据的分布情况。注意，这种方法只能在特征量有限的情况下进行，如果有几百个特征又无法成功降维或特征选择不管用，那还是用比较好。
| #描述性统计 data.describe([0.01,0.1,0.25,.5,.75,.9,.99]).T -->
#异常值也被我们观察到，年龄的最小值居然有0，这不符合银行的业务需求，即便是儿童账户也要至少8岁，我们可以查看一下年龄为0的人有多少 (data["age"] == 0).sum() -->1 #发现只有一个人年龄为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次的客户，应该都是坏客户。在我们无法询问他们情况下，我们查看一下有多少个样本存在这种异常： """ #违约了98次的标签 data[data.loc[:,"NumberOfTimes90DaysLate"] > 90].count() -->SeriousDlqin2yrs 225 RevolvingUtilizationOfUnsecuredLines 225 age 225 NumberOfTime30-59DaysPastDueNotWorse 225 DebtRatio 225 MonthlyIncome 225 NumberOfOpenCreditLinesAndLoans 225 NumberOfTimes90DaysLate 225 NumberRealEstateLoansOrLines 225 NumberOfTime60-89DaysPastDueNotWorse 225 NumberOfDependents 225 #有225个样本存在这样的情况，并且这些样本，我们观察一下，标签并不都是1，他们并不都是坏客户。 #因此，我们基本可以判断，这些样本是某种异常，应该把它们删除。 #删除数据，只剩下小于90的 data = data[data.loc[:,"NumberOfTimes90DaysLate"] < 90] #恢复索引 data.index = range(data.shape[0]) #149165 data.info() -->RangeIndex: 149165 entries, 0 to 149164 #只剩下149165条数据，记得要恢复索引 |
3.2.4 为什么不统一量纲，也不标准化数据分布？
在描述性统计结果中，我们可以观察到数据量纲明显不统一，而且存在一部分极偏的分布，虽然逻辑回归对于数据 没有分布要求，但是我们知道如果数据服从正态分布的话梯度下降可以收敛得更快。但在这里，我们不对数据进行 标准化处理，也不进行量纲统一，为什么？
无论算法有什么样的规定，无论统计学中有什么样的要求，我们的最终目的都是要为业务服务。现在我们要制作评 分卡，评分卡是要给业务人员们使用的基于新客户填写的各种信息为客户打分的一张卡片，而为了制作这张卡片， 我们需要对我们的数据进行一个“分档”，比如说，年龄20~30岁为一档，年龄30~50岁为一档，月收入1W以上为一 档，5000~1W为一档，每档的分数不同。
一旦我们将数据统一量纲，或者标准化了之后，数据大小和范围都会改变，统计结果是漂亮了，但是对于业务人员 来说，他们完全无法理解，标准化后的年龄在0.00328~0.00467之间为一档是什么含义。并且，新客户填写的信息，天生就是量纲不统一的，我们的确可以将所有的信息录入之后，统一进行标准化，然后导入算法计算，但是最 终落到业务人员手上去判断的时候，他们会完全不理解为什么录入的信息变成了一串统计上很美但实际上根本看不 懂的数字。由于业务要求，在制作评分卡的时候，我们要尽量保持数据的原貌，年龄就是8~110的数字，收入就是 大于0，最大值可以无限的数字，即便量纲不统一，我们也不对数据进行标准化处理。
3.2.5 样本不均衡问题
| #探索标签的分布 X = data.iloc[:,1:] y = data.iloc[:,0] y.value_counts() #查看每个类别的值有多少 -->0 139292 1 9873 n_sample = X.shape[0] #总数 n_1_sample = y.value_counts()[1] #提取9873 n_0_sample = y.value_counts()[0] #提取139292 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,10） pd.Series(y).value_counts() #1 139292 0 139292 n_1_sample = pd.Series(y).value_counts()[1] #提取1 n_0_sample = pd.Series(y).value_counts()[0] #提取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% |
如此，我们就实现了样本平衡，样本量也增加了
3.2.6 分训练集和测试集
| #分训练集和测试集 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 #改列索引 model_data.shape #（104415,11） #验证集 vali_data = pd.concat([Y_vali, X_vali], axis=1) vali_data.index = range(vali_data.shape[0]) vali_data.columns = data.columns #保存成csv文件 model_data.to_csv(r"E:\拜师教育学习\机器学习Sklearn\逻辑回归\model_data.csv") vali_data.to_csv(r"E:\拜师教育学习\机器学习Sklearn\逻辑回归\vali_data.csv") |
3.3 分箱
前面提到过，我们要制作评分卡，是要给各个特征进行分档，以便业务人员能够根据新客户填写的信息为客户打 分。因此在评分卡制作过程中，一个重要的步骤就是分箱。可以说，分箱是评分卡最难，也是最核心的思路，分箱 的本质，其实就是离散化连续变量，好让拥有不同属性的人被分成不同的类别（打上不同的分数），其实本质比较 类似于聚类。那我们在分箱中要回答几个问题：
· 首先，要分多少个箱子才合适？
最开始我们并不知道，但是既然是将连续型变量离散化，想也知道箱子个数必然不能太多，最好控制在十个以下。 而用来制作评分卡，最好能在4~5个为最佳。我们知道，离散化连续变量必然伴随着信息的损失，并且箱子越少， 信息损失越大。为了衡量特征上的信息量以及特征对预测函数的贡献，银行业定义了概念Information value(IV)：
其中N是这个特征上箱子的个数，i代表每个箱子， good% 是这个箱内的优质客户（标签为0的客户）占整个特征中 所有优质客户的比例，bad% 是这个箱子里的坏客户（就是那些会违约，标签为1的那些客户）占整个特征中所有坏客户的比例，而 WOE则写作：
这是我们在银行业中用来衡量违约概率的指标，中文叫做证据权重(weight of Evidence)，本质其实就是优质客户比上坏客户的比例的对数。WOE是对一个箱子来说的，WOE越大，代表了这个箱子里的优质客户越多。而IV是对 整个特征来说的，IV代表的意义是我们特征上的信息量以及这个特征对模型的贡献，由下表来控制：
| IV |
特征对预测函数的贡献 |
| < 0.03 |
特征几乎不带有效信息，对模型没有贡献，这种特征可以被删除 |
| 0.03 ~ 0.09 |
有效信息很少，对模型的贡献度低 |
| 0.1 ~ 0.29 |
有效信息一般，对模型的贡献度中等 |
| 0.3 ~ 0.49 |
有效信息较多，对模型的贡献度较高 |
| >=0.5 |
有效信息非常多，对模型的贡献超高并且可疑 |
可见，IV并非越大越好，我们想要找到IV的大小和箱子个数的平衡点。箱子越多，IV必然越小，因为信息损失会非
常多，所以，我们会对特征进行分箱，然后计算每个特征在每个箱子数目下的WOE值，利用IV值的曲线，找出合适的分箱个数。
· 其次，分箱要达成什么样的效果？
我们希望不同属性的人有不同的分数，因此我们希望在同一个箱子内的人的属性是尽量相似的，而不同箱子的人的 属性是尽量不同的，即业界常说的”组间差异大，组内差异小“。对于评分卡来说，就是说我们希望一个箱子内的人 违约概率是类似的，而不同箱子的人的违约概率差距很大，即WOE差距要大，并且每个箱子中坏客户所占的比重（bad%）也要不同。那我们，可以使用卡方检验来对比两个箱子之间的相似性，如果两个箱子之间卡方检验的P值很 大，则说明他们非常相似，那我们就可以将这两个箱子合并为一个箱子。
基于这样的思想，我们总结出我们对一个特征进行分箱的步骤：
1）我们首先把连续型变量分成一组数量较多的分类型变量，比如，将几万个样本分成100组，或50组
2）确保每一组中都要包含两种类别的样本，否则IV值会无法计算
3）我们对相邻的组进行卡方检验，卡方检验的P值很大的组进行合并，直到数据中的组数小于设定的N箱为止
4）我们让一个特征分别分成[2,3,4 20]箱，观察每个分箱个数下的IV值如何变化，找出最适合的分箱个数
5）分箱完毕后，我们计算每个箱的WOE值，bad%，观察分箱效果
这些步骤都完成后，我们可以对各个特征都进行分箱，然后观察每个特征的IV值，以此来挑选特征。
接下来，我们就以"age"为例子，来看看分箱如何完成。
3.3.1 等频分箱
| #等频分箱 #按照等频对需要分箱的列进行分箱 #qcut把离散型变量连续化 model_data["qcut"], updown = pd.qcut(model_data["age"], retbins=True, q=20) #生成“qcut”新的列，元素为分到的箱子的Series """ dataframe["列名"] #当这个列存在的时候，就是索引 #当这个列名不存在的时候，DataFrame会自动生成叫做这个列名的一个新的列 pd.qcut，基于分位数的分箱函数，本质是将连续型变量离散化 只能够处理一维数据。返回箱子的上限和下限 参数q：要分箱的个数 参数retbins=True来要求同时返回结构为索引为样本索引，元素为分到的箱子的Series 现在返回两个值：每个样本属于哪个箱子，以及所有箱子的上限和下限 """ #在这里时让model_data新添加一列叫做“分箱”，这一列其实就是每个样本所对应的箱子 model_data["qcut"] #所有箱子的上限和下限 updown #20个 -->array([ 21., 29., 33., 36., 39., 41., 44., 46., 48., 50., 52., 54., 56., 58., 60., 63., 65., 68., 72., 78., 109.]) # 统计每个分箱中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 |
3.3.2 【选学】 确保每个箱中都有0和1
| #【选学】 确保每个箱中都有0和1 for i in range(20): #如果第一个组没有包含正样本或负样本，向后合并 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 """ 合并了之后，第一行的组是否一定有两种样本了呢？不一定 如果原本的第一组和第二组都没有包含正样本，或者都没有包含负样本，那即便合并之后，第一行的组也还是没有 包含两种样本 所以我们在每次合并完毕之后，还需要再检查，第一组是否已经包含了两种样本 这里使用continue跳出了本次循环，开始下一次循环，所以回到了最开始的for i in range(20), 让i+1 这就跳过了下面的代码，又从头开始检查，第一组是否包含了两种样本 如果第一组中依然没有包含两种样本，则if通过，继续合并，每合并一次就会循环检查一次，最多合并20次 如果第一组中已经包含两种样本，则if不通过，就开始执行下面的代码 """ #已经确认第一组中肯定包含两种样本了，如果其他组没有包含两种样本，就向前合并 #此时的num_bins已经被上面的代码处理过，可能被合并过，也可能没有被合并 #但无论如何，我们要在num_bins中遍历，所以写成in range(len(num_bins)) 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 #如果对第一组和对后面所有组的判断中，都没有进入if去合并，则提前结束所有的循环 else: break """ 这个break，只有在if被满足的条件下才会被触发 也就是说，只有发生了合并，才会打断for i in range(len(num_bins))这个循环为什么要打断这个循环？因为我们是在range(len(num_bins))中遍历 但合并发生后，len(num_bins)发生了改变，但循环却不会重新开始 举个例子，本来num_bins是5组，for i in range(len(num_bins))在第一次运行的时候就等于for i in range(5) range中输入的变量会被转换为数字，不会跟着num_bins的变化而变化，所以i会永远在[0,1,2,3,4]中遍历 进行合并后，num_bins变成了4组，已经不存在=4的索引了，但i却依然会取到4，循环就会报错 因此在这里，一旦if被触发，即一旦合并发生，我们就让循环被破坏，使用break跳出当前循环 循环就会回到最开始的for i in range(20)中 此时判断第一组是否有两种标签的代码不会被触发，但for i in range(len(num_bins))却会被重新运行这样就更新了i的取值，循环就不会报错了 """ |
3.3.3 定义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%"]) #ln(good%/bad%) return df #计算IV值 def get_iv(df): rate = df["good%"] - df["bad%"] iv = np.sum(rate * df.woe) return iv |
3.3.4 卡方检验，合并箱体，画出IV曲线
| num_bins_ = num_bins.copy() #不影响原数组 import matplotlib.pyplot as plt import scipy IV = [] axisx = [] while len(num_bins_) > 2: #不知道循环几次的时候用while pvs = [] #存放pvalue # 获取 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] #x1,x2的差别 # 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], #第i列第0个值 num_bins_[i+1][1], #第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)) plt.figure() plt.plot(axisx,IV) plt.xticks(axisx) plt.xlabel("number of box") plt.ylabel("IV") plt.show() |
随着箱子数量增多IV值越来越大，6是转折点
3.3.5 用最佳分箱个数分箱，并验证分箱结果
将合并箱体的部分定义为函数，并实现分箱：
| 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,4) afterbins bins_df = get_woe(num_bins) bins_df |
3.3.6 将选取最佳分箱个数的过程包装为函数
| 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 |
3.3.7 对所有特征进行分箱选择
| model_data.columns for i in model_data.columns[1:-1]: print(i) graphforbestbin(model_data,i,"SeriousDlqin2yrs",n=2,q=20) |
我们发现，不是所有的特征都可以使用这个分箱函数，比如说有的特征，像家人数量，就无法分出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替换最小值 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) bins_of_col |
3.4 计算各箱的WOE并映射到数据中
我们现在已经有了我们的箱子，接下来我们要做的是计算各箱的WOE，并且把WOE替换到我们的原始数据model_data中，因为我们将使用WOE覆盖后的数据来建模，我们希望获取的是”各个箱”的分类结果，即评分卡上 各个评分项目的分类结果。
| 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]) data #将数据按分箱结果聚合，并取出其中的标签值data.groupby("cut")["SeriousDlqin2yrs"].value_counts() #使用unstack()来将树状结构变成表状结构data.groupby("cut")["SeriousDlqin2yrs"].value_counts().unstack() 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())) |
把以上过程包装成函数：
| 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 |
接下来，把所有WOE映射到原始数据中：
| #不希望覆盖掉原本的数据，创建一个新的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"] #这就是我们的建模数据了model_woe.head() |
3.5 建模与模型验证
终于弄完了我们的训练集，接下来我们要处理测试集，在已经有分箱的情况下，测试集的处理就非常简单了，我们 只需要将已经计算好的WOE映射到测试集中去就可以了：
| #处理测试集 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) |
返回的结果一般，我们可以试着使用C和max_iter的学习曲线把逻辑回归的效果调上去。
| c_1 = np.linspace(0.01,1,20) c_2 = np.linspace(0.01,0.2,20) score = [] for i in c_2: lr = LR(solver='liblinear',C=i).fit(X,y) score.append(lr.score(vali_X,vali_y)) plt.figure() plt.plot(c_2,score) plt.show() lr.n_iter_ 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() |
尽管从准确率来看，我们的模型效果属于一般，但我们可以来看看ROC曲线上的结果。
| 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) |
3.6 制作评分卡
建模完毕，我们使用准确率和ROC曲线验证了模型的预测能力。接下来就是要讲逻辑回归转换为标准评分卡了。评分卡中的分数，由以下公式计算：
用numpy可以很容易求出A和B的值：
| B = 20/np.log(2) A = 600 + B*np.log(1/60) B,A |
有了A和B，分数就很容易得到了。其中不受评分卡中各特征影响的基础分，就是将截距作为 带入公式进行计算，而其他各个特征各个分档的分数，也是将系数带入进行计算：
| base_score = A - B*lr.intercept_ base_score score_age = woeall["age"] * (-B*lr.coef_[0][0]) score_age |
我们可以通过循环，将所有特征的评分卡内容全部一次性写往一个本地文件ScoreData.csv：
| file = "C:/work/learnbetter/micro-class/week 5 logit regression/ScoreData.csv" #open是用来打开文件的python命令，第一个参数是文件的路径+文件名，如果你的文件是放在根目录下，则你只需要 文件名就好 #第二个参数是打开文件后的用途，"w"表示用于写入，通常使用的是"r"，表示打开来阅读 #首先写入基准分数 #之后使用循环，每次生成一组score_age类似的分档和分数，不断写入文件之中 with open(file,"w") as fdata: fdata.write("base_score,{}\n".format(base_score)) for i,col in 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") |
至此，我们评分卡的内容就全部结束了。由于时间有限，我无法给大家面面俱到这个很难的模型，如果有时间，还 会给大家补充更多关于模型验证和评估的内容。其实大家可以发现，真正建模的部分不多，更多是我们如何处理数 据，如何利用统计和机器学习的方法将数据调整成我们希望的样子，所以除了算法，更加重要的是我们能够达成数 据目的的工程能力。这份代码也还有很多细节可以改进，大家在使用的时候可以多找bug多修正，敢于挑战现有的 内容，写出属于自己的分箱函数和评分卡模型。
2.附录：
2.1 逻辑回归的参数表
2.2 逻辑回归的属性列表
2.3 逻辑回归的接口列表
