【python3】基于逻辑回归的信用卡欺诈检测

前言

这个项目实战系列主要是跟着网络上的教程来做的，主要参考《跟着迪哥学习机器学习》中的思路和具体实现代码，但是书中使用到的应该是python2的版本，有一些代码也有问题，有的是省略了一些关键的步骤，有的是语法的问题，总之就是并不是直接照着敲就能够一路运行下来的。这里整理了能够运行的代码和数据集(链接容易挂，需要请私聊)。

系列导航

• 基于逻辑回归的信用卡欺诈
• 基于随机森林的气温预测
• 基于贝叶斯的新闻分类
• 基于推荐系统的音乐推荐平台
• …

导入数据

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
data = pd.read_csv("creditcard.csv")
data.head()

	Time	V1	V2	V3	V4	V5	V6	V7	V8	V9	...	V21	V22	V23	V24	V25	V26	V27	V28	Amount	Class
0	0.0	-1.359807	-0.072781	2.536347	1.378155	-0.338321	0.462388	0.239599	0.098698	0.363787	...	-0.018307	0.277838	-0.110474	0.066928	0.128539	-0.189115	0.133558	-0.021053	149.62	0
1	0.0	1.191857	0.266151	0.166480	0.448154	0.060018	-0.082361	-0.078803	0.085102	-0.255425	...	-0.225775	-0.638672	0.101288	-0.339846	0.167170	0.125895	-0.008983	0.014724	2.69	0
2	1.0	-1.358354	-1.340163	1.773209	0.379780	-0.503198	1.800499	0.791461	0.247676	-1.514654	...	0.247998	0.771679	0.909412	-0.689281	-0.327642	-0.139097	-0.055353	-0.059752	378.66	0
3	1.0	-0.966272	-0.185226	1.792993	-0.863291	-0.010309	1.247203	0.237609	0.377436	-1.387024	...	-0.108300	0.005274	-0.190321	-1.175575	0.647376	-0.221929	0.062723	0.061458	123.50	0
4	2.0	-1.158233	0.877737	1.548718	0.403034	-0.407193	0.095921	0.592941	-0.270533	0.817739	...	-0.009431	0.798278	-0.137458	0.141267	-0.206010	0.502292	0.219422	0.215153	69.99	0

5 rows × 31 columns

拿到数据

1. 思考异常值和正常值的比例，考虑样本分布是否均匀

count_classes = pd.value_counts(data['Class'], sort=True).sort_index()
count_classes.plot(kind='bar')
plt.title("class analysis")
plt.xlabel("classes")
plt.ylabel("frequency")

Text(0, 0.5, 'frequency')

2. 观察发现数据集中异常值过少，而我们的模型要重视异常数据

数据预处理

解决数据标签不平衡问题

1. 下采样，正常样本和异常样本一样少
2. 过采样，假造异常数据使其数据量达到正常数据程度
   两种情况需要进行对比试验

特征标准化

各个列的单位不一样，变化程度不一样，需要对数据进行改善。数据经过处理之后得到的每一个特征的数值都在较小的范围内浮动
$$Z=\frac{X-X_{mean}}{std(X)}$$

from sklearn.preprocessing import StandardScaler
data['normAmount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1,1))
data = data.drop(['Time','Amount'],axis=1)
data.head()

	V1	V2	V3	V4	V5	V6	V7	V8	V9	V10	...	V21	V22	V23	V24	V25	V26	V27	V28	Class	normAmount
0	-1.359807	-0.072781	2.536347	1.378155	-0.338321	0.462388	0.239599	0.098698	0.363787	0.090794	...	-0.018307	0.277838	-0.110474	0.066928	0.128539	-0.189115	0.133558	-0.021053	0	0.244964
1	1.191857	0.266151	0.166480	0.448154	0.060018	-0.082361	-0.078803	0.085102	-0.255425	-0.166974	...	-0.225775	-0.638672	0.101288	-0.339846	0.167170	0.125895	-0.008983	0.014724	0	-0.342475
2	-1.358354	-1.340163	1.773209	0.379780	-0.503198	1.800499	0.791461	0.247676	-1.514654	0.207643	...	0.247998	0.771679	0.909412	-0.689281	-0.327642	-0.139097	-0.055353	-0.059752	0	1.160686
3	-0.966272	-0.185226	1.792993	-0.863291	-0.010309	1.247203	0.237609	0.377436	-1.387024	-0.054952	...	-0.108300	0.005274	-0.190321	-1.175575	0.647376	-0.221929	0.062723	0.061458	0	0.140534
4	-1.158233	0.877737	1.548718	0.403034	-0.407193	0.095921	0.592941	-0.270533	0.817739	0.753074	...	-0.009431	0.798278	-0.137458	0.141267	-0.206010	0.502292	0.219422	0.215153	0	-0.073403

5 rows × 30 columns

数据下采样

X = data.iloc[:,data.columns!='Class']
y = data.iloc[:,data.columns=='Class']
number_records_fraud = len(data[data.Class==1]) # 异常值数据长度
fraud_indices = np.array(data[data.Class==1].index) # 异常值的数据的索引
normal_indices = data[data.Class==0].index
# 对正常样本随即采用指定长度
random_normal_indices = np.random.choice(normal_indices,number_records_fraud,replace=False)
random_normal_indices = np.array(random_normal_indices)
# 合并新的索引项
under_sample_indices = np.concatenate([fraud_indices,random_normal_indices])
# 根据索引得到下采样的所有的样本点
under_sample_data = data.iloc[under_sample_indices,:]
X_undersample = under_sample_data.iloc[:,under_sample_data.columns!='Class']
y_undersample = under_sample_data.iloc[:,under_sample_data.columns=='Class']
#打印比例
print("正常样本比例:",len(under_sample_data[under_sample_data.Class==0])/len(under_sample_data))
print("异常样本比例:",len(under_sample_data[under_sample_data.Class==1])/len(under_sample_data))
print("下采样的总样本:",len(under_sample_data))

正常样本比例: 0.5
异常样本比例: 0.5
下采样的总样本: 984

数据集划分

目的：交叉验证

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)
print("原始数据集包含样本:",len(X_train))
print("原始测试集包含样本数量:",len(X_test))
print("原始样本总数:",len(X_train)+len(X_test))

# 对下采样的数据集进行划分
X_train_undersample,X_test_undersample,y_train_undersample,y_test_undersample = train_test_split(X_undersample,y_undersample,test_size=0.3,random_state=0)
print("下采样训练集包含样本:",len(X_train_undersample))
print("下采样测试集包含样本数量:",len(X_test_undersample))
print("下采样总数:",len(X_train_undersample)+len(X_test_undersample))

原始数据集包含样本: 199364
原始测试集包含样本数量: 85443
原始样本总数: 284807
下采样训练集包含样本: 688
下采样测试集包含样本数量: 296
下采样总数: 984

选择模型评估方法

• 准确率：分类问题中做对的占总体的百分比
• 召回率：正例中有多少能够预测，覆盖面的大小
• 精确度，被分为正例中实际为正例的比例

模型建立

from sklearn.model_selection import KFold
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import recall_score
def printing_Kfold_scores(x_train_data,y_train_data):
    fold = KFold(n_splits=5,shuffle=False)
    c_param_range = [0.01,0.1,1,10,100] # 惩罚力度
    result_table = pd.DataFrame(index = range(len(c_param_range),2),columns=['C_parameter','Mean recall score'])
    result_table['C_parameter'] = c_param_range
    j = 0
    for c_param in c_param_range:
        print("==================")
        print('正则化惩罚力度：',c_param)
        print('==================')
        print()
        recall_accs = []
        for iteration,indices in enumerate(fold.split(x_train_data),start=1):
            Ir = LogisticRegression(C = c_param, penalty='l2')
            Ir.fit(x_train_data.iloc[indices[0],:],y_train_data.iloc[indices[0],:].values.ravel())
            y_pred_undersample = Ir.predict(x_train_data.iloc[indices[1],:].values)
            recall_acc = recall_score(y_train_data.iloc[indices[1],:].values,y_pred_undersample)
            recall_accs.append(recall_acc)
            print('Iteration',iteration,':召回率 = ',recall_accs[-1])
        result_table.loc[j,'Mean recall score'] = np.mean(recall_accs)
        j += 1
        print()
        print("平均召回率:",np.mean(recall_accs))
        print()
    best_c = result_table.iloc[result_table['Mean recall score'].astype('float32').idxmax()]['C_parameter']            
    print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
    print('效果最好的模型选择的参数=',best_c)
    print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
    return best_c
best_c = printing_Kfold_scores(X_train_undersample,y_train_undersample)

==================
正则化惩罚力度： 0.01
==================

Iteration 1 :召回率 =  0.821917808219178
Iteration 2 :召回率 =  0.8493150684931506
Iteration 3 :召回率 =  0.9152542372881356
Iteration 4 :召回率 =  0.9324324324324325
Iteration 5 :召回率 =  0.8939393939393939

平均召回率: 0.882571788074458

==================
正则化惩罚力度： 0.1
==================

Iteration 1 :召回率 =  0.8493150684931506
Iteration 2 :召回率 =  0.863013698630137
Iteration 3 :召回率 =  0.9322033898305084
Iteration 4 :召回率 =  0.9459459459459459
Iteration 5 :召回率 =  0.8939393939393939

平均召回率: 0.8968834993678272

==================
正则化惩罚力度： 1
==================

Iteration 1 :召回率 =  0.863013698630137
Iteration 2 :召回率 =  0.8904109589041096
Iteration 3 :召回率 =  0.9830508474576272
Iteration 4 :召回率 =  0.9459459459459459
Iteration 5 :召回率 =  0.9090909090909091

平均召回率: 0.9183024720057457

==================
正则化惩罚力度： 10
==================

Iteration 1 :召回率 =  0.8767123287671232
Iteration 2 :召回率 =  0.8767123287671232
Iteration 3 :召回率 =  0.9830508474576272
Iteration 4 :召回率 =  0.9459459459459459
Iteration 5 :召回率 =  0.9090909090909091

平均召回率: 0.9183024720057457

==================
正则化惩罚力度： 100
==================

Iteration 1 :召回率 =  0.8767123287671232
Iteration 2 :召回率 =  0.8767123287671232
Iteration 3 :召回率 =  0.9830508474576272
Iteration 4 :召回率 =  0.9459459459459459
Iteration 5 :召回率 =  0.9090909090909091

平均召回率: 0.9183024720057457

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
效果最好的模型选择的参数= 1.0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

猜想这里为什么和书上得出了不一样的答案：

1. python3改版，C值越大，由原来的力度小改为了力度大
2. 数据集不同，随机抽样获取的数据不一样，参数也不一样

混淆矩阵

from sklearn.metrics import confusion_matrix
from itertools import product as product
def plot_confusion_matrix(cm,classes,title='Confusion matrix',cmap=plt.cm.Blues):
    plt.imshow(cm,interpolation='nearest',cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks,classes,rotation=0)
    plt.yticks(tick_marks,classes)
    
    thresh = cm.max() / 2.
    for i, j in product(range(cm.shape[0]),range(cm.shape[1])):
        plt.text(j,i,cm[i,j],
                horizontalalignment="center",
                color="white" if cm[i,j] > thresh else "black")
        
    plt.tight_layout()
    plt.ylabel("True label")
    plt.xlabel("Predicted label")

Ir = LogisticRegression(C=best_c,penalty='l2')
Ir.fit(X_train_undersample,y_train_undersample.values.ravel())
y_pred_undersample = Ir.predict(X_test_undersample.values)

cnf_matrix = confusion_matrix(y_test_undersample,y_pred_undersample)
np.set_printoptions(precision=2)
print("召回率：",cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))
class_names = [0,1]
plt.figure()
plot_confusion_matrix(cnf_matrix,
                     classes=class_names,
                     title='Confusion matrix')
plt.show()

召回率： 0.9251700680272109

Ir = LogisticRegression(C=best_c,penalty='l2')
Ir.fit(X_train_undersample,y_train_undersample.values.ravel())
y_pred = Ir.predict(X_test.values)

cnf_matrix = confusion_matrix(y_test,y_pred)
np.set_printoptions(precision=2)
print("模型应用于原始数据的召回率：",cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))
class_names = [0,1]
plt.figure()
plot_confusion_matrix(cnf_matrix,
                     classes=class_names,
                     title='Confusion matrix')
plt.show()

模型应用于原始数据的召回率： 0.9319727891156463

分析：左下角说明了遗漏分类Neg数据的数目可以接受，而右上角的数目代表错误分类为Neg的数目过多，需要改正！

改正策略

1. 模型调整参数/优化算法？
   正解：先从数据层面下手，可以考虑之前没考虑的过采样方案

分类阈值对结果的影响

Ir = LogisticRegression(C=best_c,penalty='l2')
Ir.fit(X_train_undersample,y_train_undersample.values.ravel())
y_pred_undersample_proba = Ir.predict_proba(X_test_undersample.values)
thresholds = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
plt.figure(figsize=(10,10))
j = 1
for i in thresholds:
    y_test_predictions_high_recall = y_pred_undersample_proba[:,1] > i
    plt.subplot(3,3,j)
    j+=1
    cnf_matrix = confusion_matrix(y_test_undersample,y_test_predictions_high_recall)      
    np.set_printoptions(precision=2)
    print("Recall metric in the testing dataset: ", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))
    class_names = [0,1]
    plot_confusion_matrix(cnf_matrix,
                         classes=class_names,
                         title="Threshold >= %s"%i)

Recall metric in the testing dataset:  0.9591836734693877
Recall metric in the testing dataset:  0.9455782312925171
Recall metric in the testing dataset:  0.9319727891156463
Recall metric in the testing dataset:  0.9319727891156463
Recall metric in the testing dataset:  0.9251700680272109
Recall metric in the testing dataset:  0.891156462585034
Recall metric in the testing dataset:  0.8775510204081632
Recall metric in the testing dataset:  0.8707482993197279
Recall metric in the testing dataset:  0.8571428571428571

对于混淆矩阵，可以如此记忆：

左上：追求最大的（代表分类为真的正确的样本）

右上：追求最小的（代表分类为假的错误的样本）分类错误 误杀的样本

右下：追求最大的（代表分类为假的正确的样本)

左下：追求最小的（代表分类为真的错误的样本）分类错误 捡漏的样本

过采样策略

自己生成不够的样本

SMOTE数据生成

具体流程

1. 对于少数中的每一个样本，以欧氏距离计算它到少数类样本集中所有样本的距离，经过排序得到的近邻样本
2. 根据样本不平衡比例设置一个采样倍率N，对于每一个少数样本x，从其近邻开始依次选择N个样本
3. 对于每一个选出的近邻样本，分别与原样本按照公式构建新的样本数据。

• 一句话概括：首先找到距离其最近的同类样本，然后在它们距离的基础上取0·1中的随机数作为比例加到原始数据点成为新的异常样本。

# 过采样， 使用 smote算法生成样本
# 引入逻辑回归模型
# 加载数据
data = pd.read_csv("creditcard.csv")
 
# Amount特征值太大，进行正规化
data['normAmount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1, 1))
# 删除无用的Time列和原 Amount列
data = data.drop(['Time', 'Amount'], axis=1)
 
# 获取特征列,所有行，列名不是Class的列
features = data.loc[:, data.columns != 'Class']
 
# 获取标签列，所有行，列名是Class的列
labels = data.loc[:, data.columns == 'Class']
 
# 分离训练集和测试集
features_train, features_test, labels_train, labels_test = train_test_split(features, labels, test_size=0.2, random_state=0)

from imblearn.over_sampling import SMOTE
oversampler = SMOTE(random_state=0)
os_features,os_labels=oversampler.fit_resample(features_train,labels_train)
os_features = pd.DataFrame(os_features)
os_labels = pd.DataFrame(os_labels)
best_c = printing_Kfold_scores(os_features,os_labels)

==================
正则化惩罚力度： 0.01
==================

Iteration 1 :召回率 =  0.9161290322580645
Iteration 2 :召回率 =  0.9144736842105263
Iteration 3 :召回率 =  0.9105676662609273
Iteration 4 :召回率 =  0.8931754981809389
Iteration 5 :召回率 =  0.893626141721898

平均召回率: 0.905594404526471

==================
正则化惩罚力度： 0.1
==================

Iteration 1 :召回率 =  0.9161290322580645
Iteration 2 :召回率 =  0.9144736842105263
Iteration 3 :召回率 =  0.9115857032200951
Iteration 4 :召回率 =  0.8943295852980293
Iteration 5 :召回率 =  0.895120959321177

平均召回率: 0.9063277928615785

==================
正则化惩罚力度： 1
==================

Iteration 1 :召回率 =  0.9161290322580645
Iteration 2 :召回率 =  0.9144736842105263
Iteration 3 :召回率 =  0.911807015602523
Iteration 4 :召回率 =  0.8945384201096932
Iteration 5 :召回率 =  0.8952528549917016

平均召回率: 0.9064402014345017

==================
正则化惩罚力度： 10
==================

Iteration 1 :召回率 =  0.9161290322580645
Iteration 2 :召回率 =  0.9144736842105263
Iteration 3 :召回率 =  0.9118734093172512
Iteration 4 :召回率 =  0.8945713940273244
Iteration 5 :召回率 =  0.8952528549917016

平均召回率: 0.9064600749609737

==================
正则化惩罚力度： 100
==================

Iteration 1 :召回率 =  0.9161290322580645
Iteration 2 :召回率 =  0.9144736842105263
Iteration 3 :召回率 =  0.9118734093172512
Iteration 4 :召回率 =  0.8945713940273244
Iteration 5 :召回率 =  0.8952638462975786

平均召回率: 0.906462273222149

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
效果最好的模型选择的参数= 100.0
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Ir = LogisticRegression(C=best_c,penalty='l2')
Ir.fit(os_features,os_labels.values.ravel())
y_pred = Ir.predict(features_test.values)
cnf_matrix = confusion_matrix(labels_test,y_pred)
np.set_printoptions(precision=2)

print("混淆矩阵：",cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))

class_names = [0,1]
plt.figure()
plot_confusion_matrix(cnf_matrix,
                     classes=class_names,
                     title="confusion matrix")
plt.show()

混淆矩阵： 0.9405940594059405

发现：这次的模型结果的误杀比例大大下降，因为可以利用的数据信息更多，使得模型更加符合实际的任务需求，对于不同的任务和数据源来说，并没有一成不变的答案，任何结果都需要通过实验证明。

总结

1. 开始任务之前，首先要检查数据，发现数据有什么问题
2. 针对问题提出多种方案，并对这些方案进行对比，找到最合适的方案来解决问题
3. 建模之前，需要对数据进行处理，比如数据的标准化、缺失值处理等
4. 先选好评估方法再进行建模，因为建模不可能一次就可以得到一个最好的结果，一定要尝试很多次，需要一个合适的评估方案，可以使用的通用方法：召回率、准确率，也可以根据实际问题自己指定合适的评估标准
5. 选择合适的算法
6. 模型调参，在调参之前要查阅API文档，知道每一个参数的意义
7. 测试的结果不能代表最终结果，一定要将建立的模型运用到原始数据中去。