一个信用评分案例看机器学习建模基本过程

[TOC]

machine learning for credit scoring

一个信用评分案例看机器学习建模基本过程

Banks play a crucial role in market economies. They decide who can get finance and on what terms and can make or break investment decisions. For markets and society to function, individuals and companies need access to credit.

Credit scoring algorithms, which make a guess at the probability of default, are the method banks use to determine whether or not a loan should be granted. This competition requires participants to improve on the state of the art in credit scoring, by predicting the probability that somebody will experience financial distress in the next two years. Dataset

Attribute Information:

Variable Name	Description	Type
SeriousDlqin2yrs	Person experienced 90 days past due delinquency or worse	Y/N
RevolvingUtilizationOfUnsecuredLines	Total balance on credit divided by the sum of credit limits	percentage
age	Age of borrower in years	integer
NumberOfTime30-59DaysPastDueNotWorse	Number of times borrower has been 30-59 days past due	integer
DebtRatio	Monthly debt payments	percentage
MonthlyIncome	Monthly income	real
NumberOfOpenCreditLinesAndLoans	Number of Open loans	integer
NumberOfTimes90DaysLate	Number of times borrower has been 90 days or more past due.	integer
NumberRealEstateLoansOrLines	Number of mortgage and real estate loans	integer
NumberOfTime60-89DaysPastDueNotWorse	Number of times borrower has been 60-89 days past due	integer
NumberOfDependents	Number of dependents in family	integer

Read the data into Pandas 将数据读进pandas

import pandas as pd
pd.set_option('display.max_columns', 500)
import zipfile
with zipfile.ZipFile('KaggleCredit2.csv.zip', 'r') as z:
    f = z.open('KaggleCredit2.csv')
    data = pd.read_csv(f, index_col=0)
data.head()

	SeriousDlqin2yrs	RevolvingUtilizationOfUnsecuredLines	age	NumberOfTime30-59DaysPastDueNotWorse	DebtRatio	MonthlyIncome	NumberOfOpenCreditLinesAndLoans	NumberOfTimes90DaysLate	NumberRealEstateLoansOrLines	NumberOfDependents
0	1	0.766127	45.0	2.0	0.802982	9120.0	13.0	0.0	6.0	2.0
1	0	0.957151	40.0	0.0	0.121876	2600.0	4.0	0.0	0.0	1.0
2	0	0.658180	38.0	1.0	0.085113	3042.0	2.0	1.0	0.0	0.0
3	0	0.233810	30.0	0.0	0.036050	3300.0	5.0	0.0	0.0	0.0
4	0	0.907239	49.0	1.0	0.024926	63588.0	7.0	0.0	1.0	0.0

data.shape

(112915, 11)

去除异常值 Drop na

data.isnull().sum(axis=0)

SeriousDlqin2yrs                           0
RevolvingUtilizationOfUnsecuredLines       0
age                                     4267
NumberOfTime30-59DaysPastDueNotWorse       0
DebtRatio                                  0
MonthlyIncome                              0
NumberOfOpenCreditLinesAndLoans            0
NumberOfTimes90DaysLate                    0
NumberRealEstateLoansOrLines               0
NumberOfTime60-89DaysPastDueNotWorse       0
NumberOfDependents                      4267
dtype: int64

data.dropna(inplace=True)
data.shape

(108648, 11)

创建X 和 y Create X and y

y = data['SeriousDlqin2yrs']
X = data.drop('SeriousDlqin2yrs', axis=1)

y.mean()

0.06742876076872101

import seaborn as sns
import matplotlib.pyplot as plt
%matplotlib inline

sns.countplot(x='SeriousDlqin2yrs',data=data)

<matplotlib.axes._subplots.AxesSubplot at 0x24081eb9828>

png

#从样本中可以看出：label为1的样本偏少，可见样本失衡

练习1：数据集准备

把数据切分成训练集和测试集

切分数据集

# Added version check for recent scikit-learn 0.18 checks
from distutils.version import LooseVersion as Version
from sklearn import __version__ as sklearn_version

if Version(sklearn_version) < '0.18':
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=0)

对连续值特征做幅度缩放

from sklearn.preprocessing import StandardScaler

stdsc=StandardScaler()
X_train_std=stdsc.fit_transform(X_train)
X_test_std=stdsc.transform(X_test)

练习2

使用logistic regression/决策树/SVM/KNN…等sklearn分类算法进行分类，尝试查sklearn API了解模型参数含义，调整不同的参数。

logistic regression

from sklearn.linear_model import LogisticRegression

lr = LogisticRegression(penalty='l1',C=1000.0, random_state=0)
lr.fit(X_train_std, y_train)
lr

LogisticRegression(C=1000.0, class_weight=None, dual=False,
          fit_intercept=True, intercept_scaling=1, max_iter=100,
          multi_class='ovr', n_jobs=1, penalty='l1', random_state=0,
          solver='liblinear', tol=0.0001, verbose=0, warm_start=False)

LogisticRegression(C=1000.0, class_weight=None, dual=False,
          fit_intercept=True, intercept_scaling=1, max_iter=100,
          multi_class='ovr', n_jobs=1, penalty='l1', random_state=0,
          solver='liblinear', tol=0.0001, verbose=0, warm_start=False)

LogisticRegression(C=1000.0, class_weight=None, dual=False,
          fit_intercept=True, intercept_scaling=1, max_iter=100,
          multi_class='ovr', n_jobs=1, penalty='l1', random_state=0,
          solver='liblinear', tol=0.0001, verbose=0, warm_start=False)

print('训练集准确度：%f'%lr.score(X_train_std,y_train))

训练集准确度：0.933126

##### 逻辑回归模型的系数

import numpy as np
feat_labels=data.columns[1:]
coefs=lr.coef_
indices=np.argsort(coefs[0])[::-1]

for f in range(X_train.shape[1]):
    print('%2d) %-*s %f'%(f,30,feat_labels[indices[f]],coefs[0,indices[f]]))

 0) NumberOfTime30-59DaysPastDueNotWorse 1.728754
 1) NumberOfTimes90DaysLate        1.689046
 2) DebtRatio                      0.312098
 3) NumberOfDependents             0.116383
 4) RevolvingUtilizationOfUnsecuredLines -0.014289
 5) NumberOfOpenCreditLinesAndLoans -0.091911
 6) MonthlyIncome                  -0.115234
 7) NumberRealEstateLoansOrLines   -0.196422
 8) age                            -0.364305
 9) NumberOfTime60-89DaysPastDueNotWorse -3.247876

#我的理解是权重绝对值大的特征标签比较重要

#### 决策树

from sklearn.tree import DecisionTreeClassifier

tree = DecisionTreeClassifier(criterion='entropy', max_depth=3, random_state=0)
tree.fit(X_train_std, y_train)

DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=3,
            max_features=None, max_leaf_nodes=None,
            min_impurity_decrease=0.0, min_impurity_split=None,
            min_samples_leaf=1, min_samples_split=2,
            min_weight_fraction_leaf=0.0, presort=False, random_state=0,
            splitter='best')

DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=3,
            max_features=None, max_leaf_nodes=None,
            min_impurity_split=1e-07, min_samples_leaf=1,
            min_samples_split=2, min_weight_fraction_leaf=0.0,
            presort=False, random_state=0, splitter='best')

DecisionTreeClassifier(class_weight=None, criterion='entropy', max_depth=3,
            max_features=None, max_leaf_nodes=None,
            min_impurity_decrease=0.0, min_impurity_split=1e-07,
            min_samples_leaf=1, min_samples_split=2,
            min_weight_fraction_leaf=0.0, presort=False, random_state=0,
            splitter='best')

print('训练集准确度：%f'%tree.score(X_train_std,y_train))

训练集准确度：0.934217

SVM(支持向量机)

太耗时间了，只取了“NumberOfTime60-89DaysPastDueNotWorse”这一项特征标签

X_train_std=pd.DataFrame(X_train_std,columns=feat_labels)
X_test_std=pd.DataFrame(X_test_std,columns=feat_labels)

X_train_std[['NumberOfTime60-89DaysPastDueNotWorse']].head()

	NumberOfTime60-89DaysPastDueNotWorse
0	-0.054381
1	-0.054381
2	-0.054381
3	-0.054381
4	-0.054381

from sklearn.svm import SVC

svm = SVC()
svm.fit(X_train_std[['NumberOfTime60-89DaysPastDueNotWorse']], y_train)

SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

SVC(C=1.0, cache_size=200, class_weight=None, coef0=0.0,
  decision_function_shape=None, degree=3, gamma='auto', kernel='rbf',
  max_iter=-1, probability=False, random_state=None, shrinking=True,
  tol=0.001, verbose=False)

print('训练集准确度：%f'%svm.score(X_train_std[['NumberOfTime60-89DaysPastDueNotWorse']],y_train))

训练集准确度：0.932876

KNN

from sklearn.neighbors import KNeighborsClassifier

knn = KNeighborsClassifier(n_neighbors=5, p=2, metric='minkowski')
knn.fit(X_train, y_train)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_jobs=1, n_neighbors=5, p=2,
           weights='uniform')

练习3

在测试集上进行预测，计算准确度

logistic regression

y_pred_lr=lr.predict(X_test)
print('错误分类数: %d' % (y_test != y_pred_lr).sum())
print('测试集准确度：%f'%lr.score(X_test_std,y_test))

错误分类数: 2171
测试集准确度：0.933886

决策树

y_pred_tree=tree.predict(X_test)
print('错误分类数: %d' % (y_test != y_pred_tree).sum())
print('测试集准确度：%f'%tree.score(X_test_std,y_test))

错误分类数: 2498
测试集准确度：0.935021

SVM

y_pred_svm=svm.predict(X_test[['DebtRatio']])
print('错误分类数: %d' % (y_test != y_pred_svm).sum())
print('测试集准确度：%f'%svm.score(X_test_std[['NumberOfTime60-89DaysPastDueNotWorse']],y_test))

错误分类数: 4619
测试集准确度：0.934100

KNN

y_pred_knn=knn.predict(X_test)
print('错误分类数: %d' % (y_test != y_pred_knn).sum())
print('测试集准确度：%f'%knn.score(X_test,y_test))

错误分类数: 2213
测试集准确度：0.932106

练习4

查看sklearn的官方说明，了解分类问题的评估标准，并对此例进行评估。

y的类别

class_names=np.unique(data['SeriousDlqin2yrs'].values)
class_names

array([0, 1], dtype=int64)

4种方法的confusion matrix

from sklearn.metrics import confusion_matrix

cnf_matrix_lr=confusion_matrix(y_test, y_pred_lr)
cnf_matrix_lr

array([[30424,     0],
       [ 2171,     0]], dtype=int64)

cnf_matrix_tree=confusion_matrix(y_test, y_pred_tree)
cnf_matrix_tree

array([[29346,  1078],
       [ 1420,   751]], dtype=int64)

cnf_matrix_svm=confusion_matrix(y_test, y_pred_svm)
cnf_matrix_svm

array([[27661,  2763],
       [ 1856,   315]], dtype=int64)

cnf_matrix_knn=confusion_matrix(y_test, y_pred_knn)
cnf_matrix_knn

array([[30351,    73],
       [ 2140,    31]], dtype=int64)

一个绘制混淆矩阵的函数

import itertools
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix

def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):
    """
    This function prints and plots the confusion matrix.
    Normalization can be applied by setting `normalize=True`.
    """
    if normalize:
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
        print("Normalized confusion matrix")
    else:
        print('Confusion matrix, without normalization')

    print(cm)

    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)

    fmt = '.2f' if normalize else 'd'
    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, format(cm[i, j], fmt),
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')

可视化

以logistic regression 为例

np.set_printoptions(precision=2)

# Plot non-normalized confusion matrix
plt.figure()
plot_confusion_matrix(cnf_matrix_lr, classes=class_names,
                      title='Confusion matrix, without normalization')

# Plot normalized confusion matrix
plt.figure()
plot_confusion_matrix(cnf_matrix_lr, classes=class_names, normalize=True,
                      title='Normalized confusion matrix')
plt.show()

Confusion matrix, without normalization
[[30424     0]
 [ 2171     0]]
Normalized confusion matrix
[[1. 0.]
 [1. 0.]]

png

#可见，真实标签为“0”的分类准确率很高。 
#真实标签为“1”的分类准确率很低。

练习5

银行通常会有更严格的要求，因为fraud带来的后果通常比较严重，一般我们会调整模型的标准。

比如在logistic regression当中，一般我们的概率判定边界为0.5，但是我们可以把阈值设定低一些，来提高模型的“敏感度”，试试看把阈值设定为0.3，再看看这时的评估指标(主要是准确率和召回率)。

tips:sklearn的很多分类模型，predict_prob可以拿到预估的概率，可以根据它和设定的阈值大小去判断最终结果(分类类别)

from sklearn.linear_model import LogisticRegression

lr = LogisticRegression(penalty='l2',C=1000.0, random_state=0,class_weight={1:0.3,0:0.7})
lr.fit(X_train, y_train)
lr

LogisticRegression(C=1000.0, class_weight={1: 0.3, 0: 0.7}, dual=False,
          fit_intercept=True, intercept_scaling=1, max_iter=100,
          multi_class='ovr', n_jobs=1, penalty='l2', random_state=0,
          solver='liblinear', tol=0.0001, verbose=0, warm_start=False)

y_pred_lr=lr.predict(X_test)
print('错误分类数: %d' % (y_test != y_pred_lr).sum())
print('训练集准确度：%f'%lr.score(X_test,y_test))

错误分类数: 2169
训练集准确度：0.933456

from sklearn.metrics import confusion_matrix

cnf_matrix_lr=confusion_matrix(y_test, y_pred_lr)
cnf_matrix_lr

array([[30410,    14],
       [ 2155,    16]], dtype=int64)

练习6：特征选择、重新建模

尝试对不同特征的重要度进行排序，通过特征选择的方式，对特征进行筛选。并重新建模，观察此时的模型准确率等评估指标。

用随机森林的方法进行特征筛选

from sklearn.ensemble import RandomForestClassifier
feat_labels = data.columns[1:]
forest=RandomForestClassifier(n_estimators=10000,random_state=0,n_jobs=-1)
forest.fit(X_train,y_train)
importances=forest.feature_importances_

import numpy as np
feat_labels=data.columns[1:]
indices=np.argsort(importances)[::-1]

for f in range(X_train.shape[1]):
    print('%2d) %-*s %f'%(f,30,feat_labels[indices[f]],importances[indices[f]]))

0) NumberOfDependents 0.188808
1) NumberOfTime60-89DaysPastDueNotWorse 0.173198
2) NumberRealEstateLoansOrLines 0.165334
3) NumberOfTimes90DaysLate 0.122311
4) NumberOfOpenCreditLinesAndLoans 0.089278
5) MonthlyIncome 0.087939
6) DebtRatio 0.051493
7) NumberOfTime30-59DaysPastDueNotWorse 0.045888
8) age 0.043824
9) RevolvingUtilizationOfUnsecuredLines 0.031928

选取4个特征，建立逻辑回归模型

X_train_4feat=X_train_std[['NumberOfDependents','NumberOfTime60-89DaysPastDueNotWorse','NumberRealEstateLoansOrLines','NumberOfTimes90DaysLate']]
X_test_4feat=X_test_std[['NumberOfDependents','NumberOfTime60-89DaysPastDueNotWorse','NumberRealEstateLoansOrLines','NumberOfTimes90DaysLate']]

from sklearn.linear_model import LogisticRegression

lr = LogisticRegression(penalty='l1',C=1000.0, random_state=0)
lr.fit(X_train_4feat, y_train)
lr

LogisticRegression(C=1000.0, class_weight=None, dual=False,
          fit_intercept=True, intercept_scaling=1, max_iter=100,
          multi_class='ovr', n_jobs=1, penalty='l1', random_state=0,
          solver='liblinear', tol=0.0001, verbose=0, warm_start=False)

print('训练集准确度：%f'%lr.score(X_train_4feat,y_train))

训练集准确度：0.933086

y_pred_lr=lr.predict(X_test_4feat)
print('错误分类数: %d' % (y_test != y_pred_lr).sum())
print('测试集准确度：%f'%lr.score(X_test_4feat,y_test))

错误分类数: 2161
测试集准确度：0.933701

cnf_matrix_lr=confusion_matrix(y_test, y_pred_lr)
cnf_matrix_lr

array([[30381, 43],
[ 2118, 53]])

从最后的结果看,虽然经过特征选择和模型参数调整，但依然未能解决混淆矩阵指标太差的问题。

一个完整机器学习项目流程总结
1. 实际问题抽象成数学问题
这里的抽象成数学问题，指的我们明确我们可以获得什么样的数据，目标是一个分类还是回归或者是聚类的问题，如果都不是的话，如果划归为其中的某类问题。

2. 获取数据
获取数据包括获取原始数据以及从原始数据中经过特征工程从原始数据中提取训练、测试数据。机器学习比赛中原始数据都是直接提供的，但是实际问题需要自己获得原始数据。“ 数据决定机器学习结果的上限，而算法只是尽可能的逼近这个上限”，可见数据在机器学习中的作用。总的来说数据要有具有“代表性”，对于分类问题，数据偏斜不能过于严重，不同类别的数据数量不要有数个数量级的差距。不仅如此还要对评估数据的量级，样本数量、特征数量，估算训练模型对内存的消耗。如果数据量太大可以考虑减少训练样本、降维或者使用分布式机器学习系统。

3. 特征工程
特征工程包括从原始数据中特征构建、特征提取、特征选择。特征工程做的好能发挥原始数据的最大效力，往往能够使得算法的效果和性能得到显著的提升，有时能使简单的模型的效果比复杂的模型效果好。数据挖掘的大部分时间就花在特征工程上面，是机器学习非常基础而又必备的步骤。数据预处理、数据清洗、筛选显著特征、摒弃非显著特征等等都非常重要。

4. 训练模型、诊断、调优
模型诊断中至关重要的是判断过拟合、欠拟合，常见的方法是绘制学习曲线，交叉验证。通过增加训练的数据量、降低模型复杂度来降低过拟合的风险，提高特征的数量和质量、增加模型复杂来防止欠拟合。诊断后的模型需要进行进一步调优，调优后的新模型需要重新诊断，这是一个反复迭代不断逼近的过程，需要不断的尝试，进而达到最优的状态。

5. 模型验证、误差分析
通过测试数据，验证模型的有效性，观察误差样本，分析误差产生的原因，往往能使得我们找到提升算法性能的突破点。误差分析主要是分析出误差来源与数据、特征、算法。

6. 模型融合
提升算法的准确度主要方法是模型的前端（特征工程、清洗、预处理、采样）和后端的模型融合。在机器学习比赛中模型融合非常常见，基本都能使得效果有一定的提升。

7. 上线运行
这一部分内容主要跟工程实现的相关性比较大。工程上是结果导向，模型在线上运行的效果直接决定模型的成败。 不单纯包括其准确程度、误差等情况，还包括其运行的速度(时间复杂度)、资源消耗程度（空间复杂度）、稳定性是否可接受。

值得注意的是，以上流程只是一个指导性的机器学习流程经验，并不是每个项目都包含完整的流程。

该博文主要参考资料： 
[1] 机器学习项目流程； 
[2] 一个完整机器学习项目的流程。

机器学习项目流程

   在微博上看到七月算法寒老师总结的完整机器的学习项目的工作流程，结合天池比赛的经历写的。现在机器学习应用非常流行，了解机器学习项目的流程，能帮助我们更好的使用机器学习工具来处理实际问题。

1. 理解实际问题，抽象为机器学习能处理的数学问题

        理解实际业务场景问题是机器学习的第一步，机器学习中特征工程和模型训练都是非常费时的，深入理解要处理的问题，能避免走很多弯路。理解问题，包括明确可以获得的数据，机器学习的目标是分类、回归还是聚类。如果都不是的话，考虑将它们转变为机器学习问题。参考机器学习分类能帮助从问题提炼出一个合适的机器学习方法。

2. 获取数据
       获取数据包括获取原始数据以及从原始数据中经过特征工程从原始数据中提取训练、测试数据。机器学习比赛中原始数据都是直接提供的，但是实际问题需要自己获得原始数据。“ 数据决定机器学习结果的上限，而算法只是尽可能的逼近这个上限”，可见数据在机器学习中的作用。总的来说数据要有具有“代表性”，对于分类问题，数据偏斜不能过于严重，不同类别的数据数量不要有数个数量级的差距。不仅如此还要对评估数据的量级，样本数量、特征数量，估算训练模型对内存的消耗。如果数据量太大可以考虑减少训练样本、降维或者使用分布式机器学习系统。

3. 特征工程

       特征工程是非常能体现一个机器学习者的功底的。特征工程包括从原始数据中特征构建、特征提取、特征选择，非常有讲究。深入理解实际业务场景下的问题，丰富的机器学习经验能帮助我们更好的处理特征工程。特征工程做的好能发挥原始数据的最大效力，往往能够使得算法的效果和性能得到显著的提升，有时能使简单的模型的效果比复杂的模型效果好。数据挖掘的大部分时间就花在特征工程上面，是机器学习非常基础而又必备的步骤。数据预处理、数据清洗、筛选显著特征、摒弃非显著特征等等都非常重要，建议深入学习。

4. 模型训练、诊断、调优

        现在有很多的机器学习算法的工具包，例如sklearn，使用非常方便，真正考验水平的根据对算法的理解调节参数，使模型达到最优。当然，能自己实现算法的是最牛的。模型诊断中至关重要的是判断过拟合、欠拟合，常见的方法是绘制学习曲线，交叉验证。通过增加训练的数据量、降低模型复杂度来降低过拟合的风险，提高特征的数量和质量、增加模型复杂来防止欠拟合。诊断后的模型需要进行进一步调优，调优后的新模型需要重新诊断，这是一个反复迭代不断逼近的过程，需要不断的尝试，进而达到最优的状态。

5. 模型验证、误差分析

        模型验证和误差分析也是机器学习中非常重要的一步，通过测试数据，验证模型的有效性，观察误差样本，分析误差产生的原因，往往能使得我们找到提升算法性能的突破点。误差分析主要是分析出误差来源与数据、特征、算法。

6 . 模型融合

       一般来说实际中，成熟的机器算法也就那么些，提升算法的准确度主要方法是模型的前端（特征工程、清洗、预处理、采样）和后端的模型融合。在机器学习比赛中模型融合非常常见，基本都能使得效果有一定的提升。这篇博客中提到了模型融合的方法，主要包括一人一票的统一融合，线性融合和堆融合。

参考：http://ask.julyedu.com/question/7013