机器学习实战(一)：信用卡异常交易识别人工智能weixin43880241的博客-

1.数据处理

1.1 数据集初始可视化与问题查询

数据集处理是机器学习中极其重要的一步，不同的测试集与训练集构建方法会对机器学习的效果带来巨大的影响。因此，常常在开始训练模型之前，我们就做好不同重点的测试集与训练集构建方法。

在处理数据集之前，可以针对感兴趣的变量进行初步的可视化（直方图、密度图、时许图等），并查询数据集存在的问题（数据分布有偏、量级差距过大、有缺失值等）

1.1.1 数据集查看与初始可视化

>>>data.head()    Time        V1        V2        V3  ...       V27       V28  Amount  Class 0 0.0 -1.359807 -0.072781 2.536347 ... 0.133558 -0.021053 149.62 0 1 0.0 1.191857 0.266151 0.166480 ... -0.00898》3 0.014724 2.69 0 2 1.0 -1.358354 -1.340163 1.773209 ... -0.055353 -0.059752 378.66 0 # 查看Class分布 data['Class'].value_counts() 0 284315 1 492 Name: Class, dtype: int64  # 查看数据集中是否存在确实值 data.isnull().all() data.isnull().any() # 数据标签直方图 count_classes = pd.value_counts(data['Class'],sort = True).sort_index() count_classes.plot(kind = 'bar') plt.title('Fraud class histogram') plt.xlabel('Class') plt.ylabel('Frequency') plt.show() 

该数据集有包含Time在内的30个变量，其中Class中，0为正样本，1为负样本；
初步判断Time对本问题是不重要的变量，Amount变量与其他变量数量级差别过大，需进行标准化操作；
无缺失值；
正样本与负样本差距过大，考虑采取下采样、过采样两种训练集与测试集划分方式。

1.1.2 数据处理

针对在上一步得到的问题进行数据处理，标准化处理是常见的必须操作。

# 数据标准化处理 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  ...       V28  Class  normAmount 0 -1.359807 -0.072781 2.536347 ... -0.021053 0 0.244964 1 1.191857 0.266151 0.166480 ... 0.014724 0 -0.342475 2 -1.358354 -1.340163 1.773209 ... -0.059752 0 1.160686 3 -0.966272 -0.185226 1.792993 ... 0.061458 0 0.140534 4 -1.158233 0.877737 1.548718 ... 0.215153 0 -0.073403 

2.训练集与测试集的构建

测试集与训练集的不同构建方式会对模型结果产生非常大的影响。在划分数据集时，常见的流程是，先进行数据切片，在训练集中对模型进行训练，得到最优的模型之后，将该模型应用于测试集中进一步完善，最后将此模型应用于实践。

2.1 预备工作

将特征与标签、正样本与负样本区分开来，以便后续操作。同时设置好测试集。

X = data.iloc[:,data.columns!='Class'] y = data.iloc[:,data.columns =='Class']  positve_indices = np.array(data[data.Class==0].index) negative_indices = np.array(data[data.Class ==1].index) # 得到有效测试集X_test,y_test X_train,X_test,y_train,y_test =  train_test_split(X,y,test_size=0.3,random_state = 0) 

2.1 下采样方式

下采样方式是使得训练集中的正样本与负样本个数相同（削减正样本的数量）。

from sklearn.model_selection import train_test_split  # 随机抽样得到正样本索引 random_positive_indices = np.random.choice(positve_indices,len(negative_indices),replace = False) # 得到下采样数据集索引 undersample_indices = np.array(list(random_positive_indices)+list(negative_indices)).flatten()  X_undersample = X.iloc[undersample_indices,:] y_undersample = y.iloc[undersample_indices,:] # 得到有效训练集X_undersample_train,y_undersample_train X_undersample_train,X_undersample_test,y_undersample_train,y_undersample_test = train_test_split(X_undesample,y_undersample,test_size=0.3,random_state = 0) 

有效训练集X_undersample_train,y_undersample_train用于训练模型
有效测试集y_test用于测试模型
为什么不用y_undersample_test来测试？首先，应当放到真实环境中去测试。其次，y_undersample_test中，正样本与负样本的个数比与原数据集的情况差别过大。

2.2 过采样方式

SMOTE方式是使得训练集中的正样本与负样本个数相同（增加负样本的数量）。

# 保证每一次生成的样本是一样的 oversampler = SMOTE(random_state=0) # 从训练集中生成，使得数据集中正样本数量与负样本数量一致 os_features, os_labels = oversampler.fit_sample(X_train,y_train) # 得到训练集os_features_train,os_labels_train os_features_train,os_features_test,os_labels_train,os_features_test=train_test_split(os_features,os_features,test_size=0.3,random_state=0) # 生成数据框方便矩阵运算 os_features_train = pd.DataFrame(os_features_train) os_labels_train = pd.DataFrame(os_labels_train) 

3.KFold交叉验证

3.1 K折交叉验证的流程

首先，在设定好测试集之后，就需要对其再次划分进行K折交叉验证。生成交叉验证的代码如下：

from sklearn.model_selection import KFold # 交叉验证：在训练集中进一步拆分出训练集与验证集 # shuffle为False时，无须设置随机种子  fold = KFold(n_splits=5,shuffle=False) fold = fold.split(X_train_data) # 查看fold的输出结果,前者是测试集的index，后者是验证集的index for iteration, indices in fold.split(X_train_data): print(iteration) print(indices) 

接着，应将选择好的模型放入到K折交叉训练集之中进行训练。一次训练的代码如下（本项目使用逻辑回归进行分类）：

# 指定算法模型，并且给定参数 lr = LogisticRegression(C = c_param,penalty='l1',solver='liblinear') # 训练模型 lr.fit(X_train_data.iloc[iteration,:],y_train_data.iloc[iteration,:].values.ravel()) # 建立好模型后，预测模型结果，使用验证集 y_pred_undersample = lr.predict(X_train_data.iloc[indices,:].values) # 有了预测结果之后就可以进行评估了 recall_acc = recall_score(y_train_data.iloc[indices,:].values,y_pred_undersample) recall_accs.append(recall_acc) 

最后，应将每次的结果进行平均，找到最适合的模型，将上述过程封装成函数为：

def printing_Kfold_scores(X_train_data,y_train_data):     fold = KFold(n_splits=5,shuffle=True,random_state = 10) # 定义不同力度的正则化惩罚力度     c_param_range = [0.01,0.1,1,10,100] # 生成一个储存结果的数据框     results_table = pd.DataFrame(index = range(len(c_param_range),2),columns=['C_parameter','Mean recall score'])     results_table['C_parameter'] = c_param_range     j = 0 for c in c_param_range:         c_param = c         print('--------------------------------------') print('正则化惩罚力度：',c) print('--------------------------------------') print('')         s = 1         recall_accs = [] for iteration,indices in fold.split(X_train_data): # 指定好模型             lr = LogisticRegression(C = c_param ,penalty='l1',solver='liblinear') # 使用训练集训练模型             lr.fit(X_train_data.iloc[iteration,:],y_train_data.iloc[iteration,:].values.ravel()) # 使用验证集进行验证             y_pred = lr.predict(X_train_data.iloc[indices,:]) # 评估预测结果             recall_acc = recall_score(y_train_data.iloc[indices, :].values, y_pred) print('iteration:',s,'召回率为:',recall_acc)             s = s+1             recall_accs.append(recall_acc) # 执行完所有的交叉验证之后，计算平均值         recall_accs_avg =np.mean(recall_accs) print('') print('平均召回率为:',recall_accs_avg) print('')         results_table.iloc[j,1]=recall_accs_avg         j = j+1 # 找到最优模型     best_c = results_table.loc[results_table['Mean recall score'].astype('float32').idxmax()]['C_parameter'] print('*************************************************************') print('效果最好的模型所选参数=',best_c) print('*************************************************************') return best_c 

下采样数据集结果：

-------------------------------------- 正则化惩罚力度： 0.01 -------------------------------------- iteration: 1 召回率为: 0.9428571428571428 iteration: 2 召回率为: 0.9264705882352942 iteration: 3 召回率为: 0.9523809523809523 iteration: 4 召回率为: 0.953125 iteration: 5 召回率为: 0.9743589743589743 平均召回率为: 0.9498385315664727 -------------------------------------- 正则化惩罚力度： 0.1 -------------------------------------- iteration: 1 召回率为: 0.9 iteration: 2 召回率为: 0.8529411764705882 iteration: 3 召回率为: 0.8888888888888888 iteration: 4 召回率为: 0.90625 iteration: 5 召回率为: 0.9230769230769231 平均召回率为: 0.89423139768728 -------------------------------------- 正则化惩罚力度： 1 -------------------------------------- iteration: 1 召回率为: 0.9 iteration: 2 召回率为: 0.8676470588235294 iteration: 3 召回率为: 0.9365079365079365 iteration: 4 召回率为: 0.90625 iteration: 5 召回率为: 0.9102564102564102 平均召回率为: 0.9041322811175754 -------------------------------------- 正则化惩罚力度： 10 -------------------------------------- iteration: 1 召回率为: 0.9285714285714286 iteration: 2 召回率为: 0.8823529411764706 iteration: 3 召回率为: 0.9365079365079365 iteration: 4 召回率为: 0.890625 iteration: 5 召回率为: 0.9102564102564102 平均召回率为: 0.9096627433024492 -------------------------------------- 正则化惩罚力度： 100 -------------------------------------- iteration: 1 召回率为: 0.9285714285714286 iteration: 2 召回率为: 0.8970588235294118 iteration: 3 召回率为: 0.9365079365079365 iteration: 4 召回率为: 0.890625 iteration: 5 召回率为: 0.9102564102564102 平均召回率为: 0.9126039197730375 ************************************************************* 效果最好的模型所选参数= 0.01 ************************************************************* 

SMOTE过采样方案结果：

-------------------------------------- 正则化惩罚力度： 0.01 -------------------------------------- iteration: 1 召回率为: 0.9153998203054807 iteration: 2 召回率为: 0.9141990724224046 iteration: 3 召回率为: 0.9115085480807139 iteration: 4 召回率为: 0.9114050411779386 iteration: 5 召回率为: 0.9098122284852619 平均召回率为: 0.9124649420943598 -------------------------------------- 正则化惩罚力度： 0.1 -------------------------------------- iteration: 1 召回率为: 0.917340521114106 iteration: 2 召回率为: 0.9166250445950767 iteration: 3 召回率为: 0.913909895702663 iteration: 4 召回率为: 0.9136867624514243 iteration: 5 召回率为: 0.9121459088787564 平均召回率为: 0.9147416265484052 -------------------------------------- 正则化惩罚力度： 1 -------------------------------------- iteration: 1 召回率为: 0.9184905660377358 iteration: 2 召回率为: 0.9170174812700678 iteration: 3 召回率为: 0.9143399878140569 iteration: 4 召回率为: 0.9147919711932689 iteration: 5 召回率为: 0.9129716727103006 平均召回率为: 0.9155223358050861 -------------------------------------- 正则化惩罚力度： 10 -------------------------------------- iteration: 1 召回率为: 0.9178796046720575 iteration: 2 召回率为: 0.9170888333927935 iteration: 3 召回率为: 0.9144116698326225 iteration: 4 召回率为: 0.9147919711932689 iteration: 5 召回率为: 0.912325422755179 平均召回率为: 0.9152995003691844 -------------------------------------- 正则化惩罚力度： 100 -------------------------------------- iteration: 1 召回率为: 0.9187061994609165 iteration: 2 召回率为: 0.917160185515519 iteration: 3 召回率为: 0.9148417619440163 iteration: 4 召回率为: 0.9148989268779636 iteration: 5 召回率为: 0.9124331310810325 平均召回率为: 0.9156080409758897 ************************************************************* 效果最好的模型所选参数= 100.0 ************************************************************* 

可以看到，针对不同的数据方式，其得到的结果可能会产生非常的差异。

3.2 K折交叉验证模型结果的可视化

针对分类问题有许多模型效果评估指标，比如混淆矩阵，ROC，AUC等等。这里仅使用混淆矩阵作为示范。

import itertools  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 itertools.product(range(cm.shape[0]),range(cm.shape[1])):         plt.text(j,i,cm[i,j],                  color = 'white' if cm[i,j]>thresh                  else 'black')     plt.tight_layout()     plt.ylabel('True label')     plt.xlabel('Predicted label') 

下采样方法的混淆矩阵

class_names = [0,1] lr = LogisticRegression(C=best_c1,penalty='l1',solver='liblinear') lr.fit(X_undersample_train,y_undersample_train.values.ravel()) y_pred_undersample = lr.predict(X_undersample_test.values) cnf_matrix = confusion_matrix(y_undersample_test,y_pred_undersample) np.set_printoptions(precision =2) plot_confusion_matrix(cnf_matrix,classes=class_names,title = 'Confusion matrix') plt.show() 

SMOTE过采样方法的混淆矩阵

4.问题查询

可以从混淆矩阵中找到合适的阈值，来影响分类效果。

# 阈值对结果的影响 lr = LogisticRegression(C=0.01,penalty='l1',solver='liblinear') # 训练模型 lr.fit(X_train_undersample,y_train_undersample.values.ravel()) # 为了控制阈值，因此返回概率值 y_pred_undersample_proba = lr.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] #0.4稍微异常就被抓，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('给定阈值为:',i,'时测试集召回率：',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) plt.show() 

参考：唐宇迪python实战课；周志华《机器学习》