一、数据预处理
1、读入数据
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
data=pd.read_csv(r'rankingcard.csv',index_col=0)
data.head()
看一下冰山一角的真实数据，像年龄，收入这样连续型的数据，肯定是需要先做个分箱操作的(先提一下)。
2 、简单的预处理
- 去重
- 重置索引
- 填补缺失值
这里家庭成员数（NumberOfDependents）直接使用的众数填充，方法比较简单粗暴。
data.drop_duplicates(inplace=True)
data.index=range(data.shape[0])
data['NumberOfDependents'].fillna(value=0,inplace=True)
3、使用随机森林填补缺失的月收入值
缺失的收入值都填充同样的值，肯定会对模型的准确率造成一定的影响。使用随机森林反向预测填补缺失值不失为一个好主意！
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()]
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).fit(Xtrain, Ytrain)
Ypredict = rfr.predict(Xtest)
return Ypredict
定义评分卡模型本身的特征和标签：
X = data.iloc[:,1:]
y = data["SeriousDlqin2yrs"]
X.shape
利用自定义函数计算缺失值：
#求得需要填补的缺失值
y_pred = fill_missing_rf(X,y,"MonthlyIncome")
#确认得到y_pred个数
y_pred.shape
#确认实际缺失值的个数
data.loc[:,"MonthlyIncome"].isnull().sum()
将得到的结果覆盖原始表格：
#确认个数没有问题，我们就可以将数据覆盖了
data.loc[data.loc[:,"MonthlyIncome"].isnull(),"MonthlyIncome"] = y_pred
data.info()
4、异常值处理
发现有年龄为0的用户，查看一下个数。
只有一个，直接删掉。
(data["age"] == 0).sum()
data = data[data["age"] != 0]
其他指标也有些奇奇怪怪的值，因为不懂业务，可以问一下业务人员，这里还是先统计一下，删除异常值。
# 有225个样本存在这样的情况，并且这些样本，我们观察一下，标签并不都是1，他们并不都是坏客户。
data[data.loc[:,"NumberOfTimes90DaysLate"] > 90]
data[data.loc[:,"NumberOfTimes90DaysLate"] > 90].count()
# 98 96 为异常值，应该把它们删除。
data.loc[:,"NumberOfTimes90DaysLate"].value_counts()
data = data[data.loc[:,"NumberOfTimes90DaysLate"] < 90]
# 一定要恢复索引
data.index = range(data.shape[0])
data.info()
# 查看各个分位数的数据情况
# 不做量纲统一和标准化，因为业务人员需要原本量纲作为参考。
data.describe([0.01,0.1,0.25,0.5,0.75,0.9,0.99]).T
5、处理标签分布不均
银行借贷，违约的人毕竟是相对少数。在样本严重分布不均的情况下，模型不做任何判断，准确率也可以高达99%。
为了使得样本分布均匀，可以使用
下采样
和
上采样
。
因为这里的违约数据本来就不多，所以采用上采样了。
# imblearn是专门用来处理不平衡数据集的库，在处理样本不均衡问题中性能高过sklearn很多
import imblearn
# 导入上采样 SMOTE方法
from imblearn.over_sampling import SMOTE
sm = SMOTE(random_state=42)
# 返回已经上采样完毕过后的特征矩阵和标签
X,y = sm.fit_sample(X,y)
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 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")
7、特征处理-分箱
1.分箱的个数
连续数据集的分箱有两种方式:
- 等距分箱(cut)
- 等频分箱(qcut)
分箱很简单，给参数就完了。问题是：参数应该给多少，分成多少个箱子？能达到最好的分箱效果？
离散化连续变量必然伴随着信息的损失，并且箱子越少， 信息损失越大。为了衡量特征上的信息量以及特征对预测函数的贡献，定义了概念Information value(IV)。
| IV | 特征对预测函数的贡献度 |
|---|---|
| <0.03 | 特征几乎不带有效信息，对模型没有贡献，这种特征可以被删除 |
| 0.03~0.09 | 有效信息很少，对模型的贡献度低 |
| 0.1~0.29 | 有效信息一般，对模型的贡献度中等 |
| 0.3~0.49 | 有效信息较多，对模型的贡献度较高 |
| >=0.5 | 有效信息非常多，对模型的贡献超高并且可疑 |
分箱的步骤：
- 可以先分很多个箱子，比如20个，
- 每个箱子中都要包含两种类别，否则无法计算IV值，
- 分别计算不同数量(2~20)分箱下的IV值，选取分箱的个数。
整个分箱过程封装到一个函数中：
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
将需要分箱的特征放入model_data中，调用刚刚写好的函数，得到每种特征合适的分箱数。
for i in model_data.columns[1:-1]:
print(i)
graphforbestbin(model_data,i,"SeriousDlqin2yrs",n=1,q=20,graph=True)
得到这样的图片，分箱数选在拐点的位置。
将上一步得到的每种特征的合适分箱数
#可以使用分箱的特征
auto_col_bins = {"RevolvingUtilizationOfUnsecuredLines":5
,
"age":5,
"DebtRatio":4,
"MonthlyIncome":7,
"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()}
生成自动分箱的分箱区间和分箱后的 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)
开始分箱 箱内填充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()
bins_df['woe']=np.log((bins_df[0]/bins_df[0].sum())/bins_df[1]/bins_df[1].sum())
woe=bins_df['woe']
return woe
#将所有特征的WOE存储到字典当中
woe_all={}
for col in bins_of_col:
woe_all[col]=get_woe(model_data,col,'SeriousDlqin2yrs',bins_of_col[col])
不希望覆盖掉原本的数据，创建一个副本
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()
得到最终特征矩阵
#对所有特征操作可以写成：
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()
处理测试集
xtrain=model_woe
ytrain=model_data['SeriousDlqin2yrs']
xtest=test_woe
ytest=test_data['SeriousDlqin2yrs']
建模
from sklearn.linear_model import LogisticRegression as LR
lr=LogisticRegression().fit(xtrain,ytrain)
lr.score(xtest,ytest)
对其他参数尝试做一些优化
c_1 = np.linspace(0.01,1,20)
score = []
for i in c_1:
lr = LR(solver='liblinear',C=i).fit(xtrain,ytrain)
score.append(lr.score(xtest,ytest))
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(xtrain,ytrain)
score.append(lr.score(xtest,ytest))
plt.figure()
plt.plot([1,2,3,4,5,6],score)
plt.show()
C
参数与
score
的关系
max_iter
与
score
的关系
可以用这种笨办法尽可能的对模型进行优化
ROC曲线
import scikitplot as skplt
test_proba_df = pd.DataFrame(lr.predict_proba(xtest))
skplt.metrics.plot_roc(ytest, test_proba_df,
figsize=(6,6),plot_macro=False,plot_micro=False)
曲线下的面积就是AUC值
制作评分卡
例如，假设对数几率为1/60 时设定的特定分数为600，PDO=20，那么对数几率为1/30时的分数就是
620。带入以上线性表达式，可以得到：
#用numpy求A、B的值
B = 20/np.log(2)
A = 600 + B*np.log(1/60)
B,A
计算分数
base_score = A - B*lr.intercept_ base_score
score_age = woeall["age"] * (-B*lr.coef_[0][0]) score_age
我们可以通过循环，将所有特征的评分卡内容全部一次性写往一个本地文件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 = woe_all[col] * (-B*lr.coef_[0][i])
score.name = "Score"
score.index.name = col
score.to_csv(file,header=True,mode="a")
版权声明：本文为echo666原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。