欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

机器学习——信用卡反欺诈案例

程序员文章站 2022-03-26 09:22:02
导入类库 作图函数 数据获取与解析 数据为结构化数据,不需要抽特征转化, 但特征Time和Amount的数据规格和其他特征不一样, 需要对其做特征做特征缩放 特征工程 特征转换 将时间从单位每秒化为单位每小时 divmod(7201,3600) 结果:(2, 1) 元组,2为商,1为余数 特征选择 ......

导入类库

 1 import numpy as np
 2 import pandas as pd
 3 from pandas import series, dataframe
 4 import matplotlib.pyplot as plt
 5 from sklearn.preprocessing import standardscaler
 6 from imblearn.over_sampling import smote
 7 from sklearn.ensemble import gradientboostingclassifier
 8 from sklearn.model_selection import train_test_split
 9 from sklearn.linear_model import logisticregression
10 from sklearn.metrics import confusion_matrix
11 import itertools
12 from sklearn.model_selection import gridsearchcv
13 from sklearn.metrics import auc, roc_curve

作图函数

 1 def plot_confusion_matrix(cm, classes,
 2                           title='confusion matrix',
 3                           cmap=plt.cm.blues):
 4     """
 5     this function prints and plots the confusion matrix.
 6     """
 7     plt.imshow(cm, interpolation='nearest', cmap=cmap)
 8     plt.title(title)
 9     plt.colorbar()
10     tick_marks = np.arange(len(classes))
11     plt.xticks(tick_marks, classes, rotation=0)
12     plt.yticks(tick_marks, classes)
13 
14     threshold = cm.max() / 2.
15     for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
16         plt.text(j, i, cm[i, j],
17                  horizontalalignment="center",
18                  color="white" if cm[i, j] > threshold else "black")  # 若对应格子上面的数量不超过阈值则,上面的字体为白色,为了方便查看
19 
20     plt.tight_layout()
21     plt.ylabel('true label')
22     plt.xlabel('predicted label')
23     plt.show()

数据获取与解析

数据为结构化数据,不需要抽特征转化, 但特征time和amount的数据规格和其他特征不一样, 需要对其做特征做特征缩放

1 credit = pd.read_csv('./creditcard.csv')
2 
3 print('原始行列 >>>>', credit.shape)  # (284807行, 31列)
4 # print(credit.head())  # 前5行
5 # print(credit.dtypes)  # 查看特征(列)类型。结果:数据类型只有float64和int64
6 # print(credit.isnull().any())    # 判断是否有缺失值。结果:无缺失值,方便后续处理
7 # print(credit.info())  # 查看数据集详细信息(类型,占用大小,缺失值,行列等)

特征工程

 

 1 # c_counts = credit['class'].value_counts()
 2 # print(c_counts, type(c_counts))  # 对class列分类统计,并判断类型
 3 # print(c_counts.index, c_counts.values)  # 提取索引和值
 4 '''
 5 结果:
 6 0    284315
 7 1       492
 8 name: class, dtype: int64
 9 name: class, dtype: int64 <class 'pandas.core.series.series'>
10 int64index([0, 1], dtype='int64') [284315    492]
11 '''
12 
13 # 对c_counts作图进行分析
14 # plt.figure(figsize=(10, 6))
15 # 饼图:两种作图方式
16 # ax = plt.subplot(121)
17 # c_counts是pandas的series类型,pandas可以使用plot快速作图
18 # c_counts.plot(kind='pie', autopct='%0.3f%%', ax=ax)
19 # plt.pie(c_counts, autopct='%0.3f%%')
20 
21 # 柱状图:两种作图方式
22 # ax = plt.subplot(122)
23 # c_counts.plot(kind='bar', ax=ax)
24 # plt.bar(c_counts.index, c_counts.values)
25 # plt.show()
26 '''
27 存在492例盗刷,占总样本的0.17%,
28 存在明显的数据类别不平衡问题,
29 可采用过采样(增加数据)的方法处理该问题
30 '''

 

特征转换

将时间从单位每秒化为单位每小时 divmod(7201,3600) 结果:(2, 1) 元组,2为商,1为余数

 

1 credit['time'] = credit['time'].map(lambda x: divmod(x, 3600)[0])
2 # print(credit['time'])  # map高级函数:将time中的每个元素作用于lambda函数

特征选择

 

 1 # class列中值为0的为true,值为1为false,生成的cond0行数不变
 2 # cond0 = credit['class'] == 0
 3 # class列中值为0的为false,值为1为true,生成的cond0行数不变
 4 # cond1 = credit['class'] == 1
 5 # print('cond0 >>>>', len(cond0))
 6 # print('cond1 >>>>', len(cond1))
 7 
 8 # 作图分析
 9 # credit['v1'][cond0].plot(kind='hist', bins=500)
10 # credit['v1'][cond1].plot(kind='hist', bins=50)
11 # plt.show()
12 
13 # 调试查看用
14 # print("credit['v1'] >>>>", credit['v1'])
15 # print('cond0 >>>>', cond0)
16 # print('cond1 >>>>', cond1)
17 
18 # 筛选出存在于v1列中且在cond0中为true的值(284315)
19 # print("credit['v1'][cond0] >>>>", credit['v1'][cond0])
20 # 筛选出存在于v1列中且在cond0中为true的值(492)
21 # print("credit['v1'][cond1] >>>>", credit['v1'][cond1])
22 
23 ''' 作图分析:将每一个特征根据class的真假进行划分, 图像中两种图形的重合度越大说明该特征对class的影响越小, 所以需要剔除掉无用的特征 '''
24 # cols = ['v1', 'v2', 'v3', 'v4', 'v5', 'v6', 'v7', 'v8', 'v9', 'v10',
25 #         'v11', 'v12', 'v13', 'v14', 'v15', 'v16', 'v17', 'v18', 'v19', 'v20',
26 #         'v21', 'v22', 'v23', 'v24', 'v25', 'v26', 'v27', 'v28']
27 # 作图:28行,1列,每一行显示一个特征对应的图
28 # plt.figure(figsize=(12, 2800))
29 # for i, col in enumerate(cols):
30 #     ax = plt.subplot(28, 1, i + 1)
31 # density(normed)标准化数据:将过大或过小的数据统一标准化
32 #     credit[col][cond0].plot(kind='hist', bins=500, density=true, ax=ax)
33 #     credit[col][cond1].plot(kind='hist', bins=50, density=true, ax=ax)
34 #
35 #     ax.set_title(col)
36 # plt.show()
37 
38 # 待剔除的列(10列)
39 drops = ['v13', 'v15', 'v20', 'v22', 'v23', 'v24', 'v25', 'v26', 'v27', 'v28']
40 # 删除指定列(axis=1按列,axis=0按行)
41 credit2 = credit.drop(labels=drops, axis=1)
42 print('人眼剔除无用列后 >>>>', credit2.shape)
43 ''' 不同变量在信用卡被盗刷和信用卡正常的不同分布情况, 选择在不同信用卡状态下的分布有明显区别的变量。 
因此剔除变量v13 、v15 、v20 、v22、 v23 、v24 、v25 、v26 、v27 和v28变量 '''

特征缩放

amount变量和time变量的取值范围与其他变量相差较大, 所以要对其进行特征缩放

 1 # print('原amount数据最大值', credit2['amount'].max())
 2 # print('原amount数据最小值', credit2['amount'].min())
 3 # print('原time数据最大值', credit2['time'].max())
 4 # print('原time数据最小值', credit2['time'].min())
 5 
 6 # 创建标准化对象
 7 standscaler = standardscaler()
 8 cols = ['time', 'amount']
 9 # 标准化数据
10 credit2[cols] = standscaler.fit_transform(credit2[cols])
11 # print('标准化amount后最大值 >>>>', credit2['amount'].max())
12 # print('标准化amount后最小值 >>>>', credit2['amount'].min())
13 # print('标准化time后最大值 >>>>', credit2['time'].max())
14 # print('标准化time后最小值 >>>>', credit2['time'].min())

特征重要性排序

对特征的重要性进行排序,以进一步减少变量 利用gbdt梯度提升决策树进行特征重要性排序

 1 # 创建gbdt对象
 2 # clf = gradientboostingclassifier()
 3 # 特征训练集:前20列
 4 # x_train = credit2.iloc[:, :-1]
 5 # print('x_train.shape >>>>', x_train.shape)
 6 # cols = x_train.columns
 7 # print('x_train.columns >>>>', x_train.columns)
 8 # 目标值训练集:class列
 9 # y_train = credit2['class']  # y_train = credit2.iloc[:,-1]
10 # print('y_train.shape >>>>', y_train.shape)
11 # 训练数据
12 # clf.fit(x_train, y_train)
13 # 得到特征重要性数据
14 # feature_importances_ = clf.feature_importances_
15 # print('feature_importances_ >>>>', feature_importances_)
16 # 从大到小对特征重要性进行排序,并作图分析
17 # argsort():对数组排序并返回排序后每个元素对应的未排序时自身所在的索引
18 # index = feature_importances_.argsort()[::-1]
19 # print('从大到小排列特征重要性,返回每个元素的原索引 >>>>', index, len(index))
20 
21 # plt.figure(figsize=(12, 9))
22 # 柱状图,第二个参数代表按从大到小排列的特征数据
23 # plt.bar(np.arange(len(index)), feature_importances_[index])
24 # 柱状图x坐标:第二个参数是按特征值从大到小排列后的特征名
25 # plt.xticks(np.arange(len(index)), cols[index])
26 # plt.show()
27 # 根据图像得到要删除的特征列(最小的后9列)
28 drops = ['v7', 'v21', 'v8', 'v5', 'v4', 'v11', 'v19', 'v1', 'amount']
29 credit3 = credit2.drop(labels=drops, axis=1)
30 print('通过gbdt分析剔除无用列后 >>>>', credit3.shape)
31 # print('credit3.columns >>>>', credit3.columns)

模型训练

 

处理样本不平衡问题
目标变量“class”正常和被盗刷两种类别的数量差别较大,会对模型学习造成困扰。
举例来说,假如有100个样本,其中只有1个是被盗刷样本,
其余99个全为正常样本,那么学习器只要制定一个简单的方法:
即判别所有样本均为正常样本,就能轻松达到99%的准确率。
而这个分类器的决策对我们的风险控制毫无意义。
因此,在将数据代入模型训练之前,我们必须先解决样本不平衡的问题。
现对该业务场景进行总结如下:
过采样(oversampling):
增加正样本使得正、负样本数目接近,然后再进行学习。
欠采样(undersampling):
去除一些负样本使得正、负样本数目接近,然后再进行学习。 
本次处理样本不平衡采用的方法是过采样,
具体操作使用smote(synthetic minority oversampling technique),
smoet的基本原理是:
采样最邻近算法,计算出每个少数类样本的k个近邻,
从k个近邻中随机挑选n个样本进行随机线性插值,
构造新的少数样本,同时将新样本与原数据合成,产生新的训练集。

  

 1 # smote 过采样
 2 x = credit3.iloc[:, :-1]
 3 y = credit3.class
 4 x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)
 5 x_train,y_train 作为训练数据 训练时,保证样本均衡,将x_train和y_train样本过采样处理 测试时候,可以样本不均衡
 6 # print('未均衡的y训练集分类统计(class) >>>>', y_train.value_counts())
 7 
 8 smote = smote()
 9 # ndarray
10 x_train_new, y_train_new = smote.fit_sample(x_train, y_train)
11 # print('均衡后的x训练集 >>>>', x_train_new, type(x_train_new))
12 # print('均衡后的y训练集(class) >>>>', y_train_new, type(y_train_new), len(y_train_new))
13 # y_train_new类型为numpy.ndarray,需转化为pandas.series类型才可分类统计
14 # print('均衡后的y训练集分类统计(class) >>>>', series(y_train_new).value_counts())

求召回率

单独的逻辑回归求得查全率recall rate,recall也叫召回率

 

 1 # 创建逻辑回归对象
 2 # logistic = logisticregression()
 3 # print(logistic)
 4 '''
 5 logisticregression(c=1.0, class_weight=none, dual=false, fit_intercept=true,
 6           intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,
 7           penalty='l2', random_state=none, solver='liblinear', tol=0.0001,
 8           verbose=0, warm_start=false)
 9 '''
10 # 训练均衡后的数据
11 # logistic.fit(x_train_new, y_train_new)
12 # 预测
13 # y_ = logistic.predict(x_test)
14 # print('y_test >>>>', y_test)
15 # print('预测的y_ >>>>', y_)
16 # 交叉表
17 # print('交叉表 >>>>', pd.crosstab(y_test, y_, margins=true))
18 
19 # 混合矩阵
20 # cm = confusion_matrix(y_test, y_)
21 # print('混合矩阵 >>>>', cm, type(cm))
22 # recall------“正确被检索的正样本item(tp)"占所有"应该检索到的item(tp+fn)"的比例
23 # plot_confusion_matrix(cm, [0, 1], title='recall:%0.3f' % (cm[1, 1] / (cm[1, 0] + cm[1, 1])))

交叉验证与调优

 

 1 logistic = logisticregression()
 2 clf = gridsearchcv(logistic, param_grid={'tol': [1e-3, 1e-4, 1e-5], 'c': [1, 0.1, 10, 100]}, cv=10, iid=false, n_jobs=1)
 3 print(clf.fit(x_train_new, y_train_new))
 4 # print('best_score_ >>>>', clf.best_score_)
 5 # print('best_params_ >>>>', clf.best_params_)
 6 # print('best_index_ >>>>', clf.best_index_)
 7 # print('best_estimator_ >>>>', clf.best_estimator_)
 8 
 9 # 预测
10 # y3_ = clf.best_estimator_.predict(x_test)
11 # print('y3_预测(best_estimator_) >>>>', confusion_matrix(y_test, y3_))
12 
13 # y2_ = clf.predict(x_test)
14 # print('y2_预测 >>>>', confusion_matrix(y_test, y2_))
15 
16 # cm2 = confusion_matrix(y_test, y2_)
17 
18 # 可视化,对比逻辑斯蒂回归和gridsearchcv结果
19 # plot_confusion_matrix(cm, [0, 1], title='logistic recall:%0.3f' % (cm[1, 1] / (cm[1, 0] + cm[1, 1])))
20 # plot_confusion_matrix(cm2, [0, 1], title='gridsearchcv recall:%0.3f' % (cm2[1, 1] / (cm2[1, 0] + cm2[1, 1])))

模型评估

解决不同的问题,通常需要不同的指标来度量模型的性能。
例如我们希望用算法来预测癌症是否是恶性的,
假设100个病人中有5个病人的癌症是恶性, 
对于医生来说,尽可能提高模型的查全率(recall)比提高查准率(precision)更为重要,
因为站在病人的角度,发生漏发现癌症为恶性比发生误 判为癌症是恶性更为严重
由此可见就上面的两个算法而言,明显lgb过拟合了,
考虑到样本不均衡问题,
故应该选用简单一点的算法(逻辑回归)来减少陷入过拟合的陷阱

  

1 y_proba = clf.predict_proba(x_test)
2 # 预测被盗刷的概率
3 print(y_proba)