信用卡欺诈检测建模分析

最新推荐文章于 2024-02-27 10:54:53 发布
最新推荐文章于 2024-02-27 10:54:53 发布
阅读量4.5k 收藏 104
点赞数 6
分类专栏： 数据挖掘
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39669739/article/details/115272406
版权

1 建模目的

信用卡欺诈检测，又叫异常检测。异常检测无非就是正常和异常，这是一个二分类任务，显然正常的占绝大部分，异常的只占很少的比例，我们要检测的就是这些异常的。利用信用卡历史数据进行建模，构建反欺诈模型，预测新的信用卡被盗刷的可能性。

2 数据集介绍

数据集包含由欧洲人于2013年9月使用信用卡进行交易的数据。此数据集显示两天内发生的交易，其中284807笔交易中有492笔被盗刷。数据集非常不平衡，正例（被盗刷）占所有交易的0.172％。，这是因为由于保密问题，我们无法提供有关数据的原始功能和更多背景信息。特征V1，V2，… V28是使用PCA获得的主要组件，没有用PCA转换的唯一特征是“Class”和“Amount”。特征’Time’包含数据集中每个刷卡时间和第一次刷卡时间之间经过的秒数。特征’Class’是响应变量，如果发生被盗刷，则取值1，否则为0。

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec
import numpy as np
import seaborn as sns
%matplotlib inline
import warnings
warnings.filterwarnings('ignore')  

data = pd.read_csv("creditcard.csv")
data.head()
TimeV1V2V3V4V5V6V7V8V9...V21V22V23V24V25V26V27V28AmountClass
00.0-1.359807-0.0727812.5363471.378155-0.3383210.4623880.2395990.0986980.363787...-0.0183070.277838-0.1104740.0669280.128539-0.1891150.133558-0.021053149.620
10.01.1918570.2661510.1664800.4481540.060018-0.082361-0.0788030.085102-0.255425...-0.225775-0.6386720.101288-0.3398460.1671700.125895-0.0089830.0147242.690
21.0-1.358354-1.3401631.7732090.379780-0.5031981.8004990.7914610.247676-1.514654...0.2479980.7716790.909412-0.689281-0.327642-0.139097-0.055353-0.059752378.660
31.0-0.966272-0.1852261.792993-0.863291-0.0103091.2472030.2376090.377436-1.387024...-0.1083000.005274-0.190321-1.1755750.647376-0.2219290.0627230.061458123.500
42.0-1.1582330.8777371.5487180.403034-0.4071930.0959210.592941-0.2705330.817739...-0.0094310.798278-0.1374580.141267-0.2060100.5022920.2194220.21515369.990

5 rows × 31 columns

data.shape

(284807, 31)

data.isnull().sum()

Time      0
V1        0
V2        0
V3        0
V4        0
V5        0
V6        0
V7        0
V8        0
V9        0
V10       0
V11       0
V12       0
V13       0
V14       0
V15       0
V16       0
V17       0
V18       0
V19       0
V20       0
V21       0
V22       0
V23       0
V24       0
V25       0
V26       0
V27       0
V28       0
Amount    0
Class     0
dtype: int64

此数据集无缺失值。

3 探索性分析

3.1 交易时间分布

f, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(16,4))

bins = 50

ax1.hist(data["Time"][data["Class"]== 1], bins = bins,facecolor='pink',alpha=0.75)
ax1.set_title('Fraud')

ax2.hist(data["Time"][data["Class"] == 0], bins = bins,facecolor= '#ADD8E6',alpha=0.75)
ax2.set_title('Normal')

plt.xlabel('Time')
plt.ylabel('Number of Transactions')
plt.show()

在这里插入图片描述

可以看到，欺诈交易的时间离散度高，出现2个峰值迹象；正常交易分布聚集度明显，可以看到在两个时间段里，用户交易频率高。

3.2 交易金额分布

f, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(16,4))

bins = 50

ax1.hist(data["Amount"][data["Class"]== 1], bins = bins,facecolor='#4682B4',alpha=0.75)
ax1.set_title('Fraud')

ax2.hist(data["Amount"][data["Class"] == 0], bins = bins,facecolor='#FF8C00',alpha=0.75)
ax2.set_title('Normal')

plt.xlabel('Amount')
plt.ylabel('Number of Transactions')
plt.yscale('log')
plt.show()

在这里插入图片描述

信用卡被盗刷交易的金额比信用卡正常用户交易的金额小，这说明信用卡盗刷者为了不引起信用卡卡主的注意，更偏向选择小金额消费。

3.3 查看数据标签分布

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")
data.groupby('Class').size()

Class
0    284315
1       492
dtype: int64

在这里插入图片描述

可以看到0样本的个数远远多于1样本的个数，出现样本分布不均衡的情况。

4 数据预处理

4.1特征缩放

在对样本处理之前，需要先处理下数据，对数据规格较大的amount列做归一化处理，使其均值为0，方差为1，使不同维度的特征对模型的重要程度相同。

from sklearn.preprocessing import StandardScaler
normAmount= StandardScaler().fit_transform(data['Amount'].values.reshape(-1, 1))
normTime= StandardScaler().fit_transform(data['Time'].values.reshape(-1, 1))
data.insert(1,'normAmount',normAmount)
data.insert(2,'normTime',normTime)

data = data.drop(['Time','Amount'],axis=1)
data.head()
normAmountnormTimeV1V2V3V4V5V6V7V8...V20V21V22V23V24V25V26V27V28Class
00.244964-1.996583-1.359807-0.0727812.5363471.378155-0.3383210.4623880.2395990.098698...0.251412-0.0183070.277838-0.1104740.0669280.128539-0.1891150.133558-0.0210530
1-0.342475-1.9965831.1918570.2661510.1664800.4481540.060018-0.082361-0.0788030.085102...-0.069083-0.225775-0.6386720.101288-0.3398460.1671700.125895-0.0089830.0147240
21.160686-1.996562-1.358354-1.3401631.7732090.379780-0.5031981.8004990.7914610.247676...0.5249800.2479980.7716790.909412-0.689281-0.327642-0.139097-0.055353-0.0597520
30.140534-1.996562-0.966272-0.1852261.792993-0.863291-0.0103091.2472030.2376090.377436...-0.208038-0.1083000.005274-0.190321-1.1755750.647376-0.2219290.0627230.0614580
4-0.073403-1.996541-1.1582330.8777371.5487180.403034-0.4071930.0959210.592941-0.270533...0.408542-0.0094310.798278-0.1374580.141267-0.2060100.5022920.2194220.2151530

5 rows × 31 columns

4.2 特征选择

利用GBDT梯度提升决策树进行特征重要性排序

columns = data.columns
features_columns = columns.delete(len(columns) - 1)
 
features = data[features_columns]
labels = data['Class']
# The labels are in the last column ('Class'). Simply remove it to obtain features columns

from sklearn.ensemble import GradientBoostingClassifier
gbdt = GradientBoostingClassifier()
gbdt.fit(features, labels)

GradientBoostingClassifier()

# 找到重要特征
feature_importances = gbdt.feature_importances_
# 重要特征下标排序
# argsort返回的排序之后的下标
inds = feature_importances.argsort()[::-1]
# 重要特征降序排列
data.columns[inds]

Index(['V17', 'V14', 'V26', 'V8', 'V10', 'normTime', 'V12', 'V7', 'V20', 'V27',
       'V4', 'V16', 'V18', 'V21', 'V23', 'V24', 'V9', 'V6', 'V11', 'V25',
       'V15', 'V1', 'V13', 'V3', 'V2', 'V28', 'V5', 'V19', 'V22',
       'normAmount'],
      dtype='object')

plt.figure(figsize=(15,9))
plt.bar(np.arange(30), feature_importances[inds])
_ = plt.xticks(np.arange(30), data.columns[inds])

在这里插入图片描述

根据上图可以发现，v9,v1,v6,v11,v25,v15,v13,v3,v2,v28,v5,v19,v22,normAmount列可以删除

data.drop(columns=['V9', 'V1', 'V6', 'V11', 'V25','V15', 'V13', 'V3', 'V2', 'V28', 'V5', 'V19', 'V22', 'normAmount'], inplace=True)

4.3 样本不均衡处理

  • 下采样处理，让正常样本和异常样本一样少。
  • 过采样处理，让异常样本和正常样本一样多。

这两种方案的效果如何？下面我们首先采用下采样对数据进行处理。

下采样处理

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)

# 将0样本和1样本的索引合并，形成新的数据集
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']

# 0样本和1样本的个数
print("Percentage of normal transactions: ", len(under_sample_data[under_sample_data.Class == 0])/len(under_sample_data))
print("Percentage of fraud transactions: ", len(under_sample_data[under_sample_data.Class == 1])/len(under_sample_data))
print("Total number of transactions in resampled data: ", len(under_sample_data))

Percentage of normal transactions:  0.5
Percentage of fraud transactions:  0.5
Total number of transactions in resampled data:  984

4.4 数据切分

对下采样数据进行切分是为了训练模型时使用，并且对原始数据进行一定比例的切分，以备测试时使用，不选用下采样数据测试是因为下采样样本数据较少，不具有原始数据的分布特征。

 from sklearn.model_selection import train_test_split

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

print("Number transactions train dataset: ", len(X_train))
print("Number transactions test dataset: ", len(X_test))
print("Total number of transactions: ", len(X_train)+len(X_test))

# Undersampled dataset
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("")
print("Number transactions train dataset: ", len(X_train_undersample))
print("Number transactions test dataset: ", len(X_test_undersample))
print("Total number of transactions: ", len(X_train_undersample)+len(X_test_undersample))

Number transactions train dataset:  199364
Number transactions test dataset:  85443
Total number of transactions:  284807

Number transactions train dataset:  688
Number transactions test dataset:  296
Total number of transactions:  984

5 逻辑回归建模

from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import KFold,cross_val_score
from sklearn.metrics import confusion_matrix,recall_score,classification_report

5.1 模型选择

使用同一个算法，当使用不同的参数时，也会产生不同的模型，这就涉及到模型的选择问题，一般而言，应该选择泛化误差最小的模型，但是我们事先不知道新样本是未知的，通过使用一个测试集来测试对新样本的判别能力，然后以测试集上的测试误差作为泛化误差的近似，常用的有k折交叉验证，
它的基本思路是首先将原始数据按照8：2的比例切分成训练集和测试集，然后再在训练集上进行切分，即训练数据分成K组(K-Fold)，将每个子集数据分别做一次验证集，其余的K-1组子集数据作为训练集，这样会得到K个模型。这K个模型分别在验证集中评估结果，将求得的MSE(Mean Squared Error)加和平均就得到交叉验证误差，作为评价当前参数下模型的好坏。再用测试集在最终选择的模型上测试，用来评估模最终模型的泛化能力。

在这里插入图片描述

这里仅对正则化惩罚力度进行调参实验，正则化的意义是防止过拟合，所谓过拟合，指的是模型在训练集上表现的很好，但是在交叉验证集合测试集上表现较差，也就是说模型对未知样本的预测表现一般。正则化是指去限制参数的空间，减少特征的数量，控制模型的复杂度。参数选择l1正则化范式，比较适合模型的特征非常多，同时希望将一些不重要的特征系数归零，从而让模型系数更加稀疏，权重值更低。

def printing_Kfold_scores(x_train_data,y_train_data):
    fold = KFold(5,shuffle=False) 
    # 会得到一个可迭代对象（可以用 for 循环遍历取出），可以遍历5次，每次遍历出来的会是一个2值列表，
    # 存放每一次的训练集和验证集的索引
 
    # 不同的正则化惩罚力度
    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_param in c_param_range:
        print('-------------------------------------------')
        print('C parameter: ', c_param)
        print('-------------------------------------------')
        print('')

        recall_accs = []
        for iteration, indices in enumerate(fold.split(y_train_data),start=1):
            # enumerate 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中
            # iteration 表示第几次循环，indices 是一个列表里面有两个元素，indices[0]表示训练集索引，indices[1] 表示验证集索引

            lr = LogisticRegression(C = c_param, penalty='l1', solver='liblinear',max_iter=10000)

            #使用训练数据拟合模型，x和y的索引都为0
            lr.fit(x_train_data.iloc[indices[0],:],y_train_data.iloc[indices[0],:].values.ravel())

            # Predict values using the test indices in the training data
            #建立好模型后，预测模型结果，使用验证集
            y_pred_undersample = lr.predict(x_train_data.iloc[indices[1],:].values)

            # Calculate the recall score and append it to a list for recall scores representing the current c_parameter
            #对预测结果进行评估，recall_score需要传入真实值和预测值
            recall_acc = recall_score(y_train_data.iloc[indices[1],:].values,y_pred_undersample)
            recall_accs.append(recall_acc)
            print('Iteration ', iteration,': recall score = ', recall_acc)

        # The mean value of those recall scores is the metric we want to save and get hold of.
        results_table.loc[j,'Mean recall score'] = np.mean(recall_accs)
        j += 1
        print('')
        print('Mean recall score ', np.mean(recall_accs))
        print('')

    best_c = results_table.loc[results_table['Mean recall score'].astype('float').idxmax()]['C_parameter'] 
    
    # Finally, we can check which C parameter is the best amongst the chosen.
    print('*********************************************************************************')
    print('Best model to choose from cross validation is with C parameter = ', best_c)
    print('*********************************************************************************')
    
    return best_c

best_c = printing_Kfold_scores(X_train_undersample,y_train_undersample)

-------------------------------------------
C parameter:  0.01
-------------------------------------------

Iteration  1 : recall score =  0.958904109589041
Iteration  2 : recall score =  0.9178082191780822
Iteration  3 : recall score =  1.0
Iteration  4 : recall score =  0.972972972972973
Iteration  5 : recall score =  0.9545454545454546

Mean recall score  0.96084615125711

-------------------------------------------
C parameter:  0.1
-------------------------------------------

Iteration  1 : recall score =  0.8356164383561644
Iteration  2 : recall score =  0.863013698630137
Iteration  3 : recall score =  0.9322033898305084
Iteration  4 : recall score =  0.9324324324324325
Iteration  5 : recall score =  0.8787878787878788

Mean recall score  0.8884107676074242

-------------------------------------------
C parameter:  1
-------------------------------------------

Iteration  1 : recall score =  0.8493150684931506
Iteration  2 : recall score =  0.863013698630137
Iteration  3 : recall score =  0.9661016949152542
Iteration  4 : recall score =  0.9459459459459459
Iteration  5 : recall score =  0.8939393939393939

Mean recall score  0.9036631603847762

-------------------------------------------
C parameter:  10
-------------------------------------------

Iteration  1 : recall score =  0.8493150684931506
Iteration  2 : recall score =  0.863013698630137
Iteration  3 : recall score =  0.9661016949152542
Iteration  4 : recall score =  0.9459459459459459
Iteration  5 : recall score =  0.8939393939393939

Mean recall score  0.9036631603847762

-------------------------------------------
C parameter:  100
-------------------------------------------

Iteration  1 : recall score =  0.8493150684931506
Iteration  2 : recall score =  0.863013698630137
Iteration  3 : recall score =  0.9661016949152542
Iteration  4 : recall score =  0.9459459459459459
Iteration  5 : recall score =  0.8939393939393939

Mean recall score  0.9036631603847762

*********************************************************************************
Best model to choose from cross validation is with C parameter =  0.01
*********************************************************************************

通过交叉验证，效果最好的模型参数为0.01

5.2 模型评估

混淆矩阵

混淆矩阵是统计真实值和实际值的分布情况，来计算用来评价模型好坏的指标，比如recall值，准确率等 二分类预测的混淆矩阵中，行向量为观测的实际类别，列向量为预测类别值。其中(TP True Positive)为真正，表示实际值为 1 预测值也为 1，FN (False Negative)为假负，表示实际值为 1 预测值为 0，FP (False Positive)为假正，表示实际值为 0，预测值为 1，TN （True Negative）为真负，表示实际值为 0，预测值也为 0。

在这里插入图片描述

评价指标

  • 准确率：TP/(FP+TP),表示分类器预测为正例的所有样本中真正为正例的样本的比重。
  • 召回率(recall值）：TP/(TP+FN) ,反映了被正确预测的正例的样本占总的正例样本的比重。
  • 精确率：TP/(TP+FP),反映了真正为正例的样本占预测为正例的样本的比重。
  • F1score:2(精确率+召回率）/(精确率+召回率）

ROC曲线 ：对于二分类的模型，很多时候并不是给出每个样本预测为哪一类，而是给出其中一类的概率预测，需要选取一个阈值，当这个预测大于这个阈值时，我们将该观测预测为这一类，否则为另一类。而 ROC 曲线通过阈值从 0 到 1 移动，获得多对 FPR=FP/ (TN+FP)和 TPR=TP/ (FN+TP)，且当样本出现不均衡的时候，ROC曲线具有不变形，所以选用ROC曲线来比较不同分类器分类效果。

  • 纵轴表示TPR=TP/(FN+TP)（真正例率），表示在所有正例中，预测出来的正例样本有多少。
  • 横轴表示FPR=FP/(TN+FP)（假正例率）表示在所有负例中，被预测为正例的样本有多少。
    显然我们希望TPR越大越好，FPR越小越好。
  • AUC表示ROC曲线下的面积，不同的模型对应的ROC曲线中，AUC值大的模型性能自然相对较好。

下面来定义混淆矩阵的画法，代码如下

def plot_confusion_matrix(cm, classes,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):
    """
    This function prints and plots the confusion matrix.
    """
    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],
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

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

import itertools
lr = LogisticRegression(C=best_c, penalty='l1', solver='liblinear')
lr.fit(X_train_undersample,y_train_undersample.values.ravel())
y_pred_undersample = lr.predict(X_test_undersample.values)

# Compute confusion matrix
cnf_matrix = confusion_matrix(y_test_undersample,y_pred_undersample)
np.set_printoptions(precision=2)

print("Recall metric in the testing dataset: ", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))

# Plot non-normalized confusion matrix
class_names = [0,1]
plt.figure()
plot_confusion_matrix(cnf_matrix
                      , classes=class_names
                      , title='Confusion matrix')
plt.show()

Recall metric in the testing dataset:  0.9319727891156463

在这里插入图片描述

可以看到得到的召回率的值为0.9319727891156463，可以看到分类效果是比较好的，但是这里是用下采样的数据集进行建模，并且测试集采用的也是下采样的数据。

计算指标

from sklearn.metrics import f1_score,precision_score,recall_score,auc,roc_auc_score,accuracy_score,roc_curve
def metrics_score(y_test,y_pred):
    Accuracy=accuracy_score(y_test,y_pred)
    Recall=recall_score(y_test,y_pred)
    Pre=precision_score(y_test,y_pred)
    F1_score=f1_score(y_test,y_pred)
    AUC=roc_auc_score(y_test,y_pred)
    return Accuracy,Recall,Pre,F1_score,AUC

#计算指标得分
y_pred_undersample = lr.predict(X_test_undersample.values)
Accuracy,Recall,Pre,F1_score,AUC=metrics_score(y_test_undersample,y_pred_undersample)
print('准确率:%.2f|召回率:%.2f|精确率:%.2f|F1_score:%.2f|AUC:%.2f'%(Accuracy,Recall,Pre,F1_score,AUC))

准确率:0.89|召回率:0.93|精确率:0.85|F1_score:0.89|AUC:0.89

#ROC曲线图
y_pred_proba=lr.predict_proba(X_test_undersample.values)
fpr, tpr, thresholds = roc_curve(y_test_undersample,y_pred_proba[:,1])
plt.plot(fpr,tpr,label='AUC = %0.2f'% AUC)
plt.legend(loc='lower right')
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
plt.plot([0,1],[0,1],'r--')
plt.show()

在这里插入图片描述

只在小规模的数据集进行测试，不具有代表性，所以我们在测试时应该采用原始数据集进行测试，代码如下

lr = LogisticRegression(C = best_c, penalty='l1', solver='liblinear')
lr.fit(X_train_undersample,y_train_undersample.values.ravel())
y_pred = lr.predict(X_test.values)

# Compute confusion matrix
cnf_matrix = confusion_matrix(y_test,y_pred)
np.set_printoptions(precision=2)

print("Recall metric in the testing dataset: ", cnf_matrix[1,1]/(cnf_matrix[1,0]+cnf_matrix[1,1]))

# Plot non-normalized confusion matrix
class_names = [0,1]
plt.figure()
plot_confusion_matrix(cnf_matrix
                      , classes=class_names
                      , title='Confusion matrix')
plt.show()

Recall metric in the testing dataset:  0.9183673469387755

在这里插入图片描述

#计算指标得分
Accuracy,Recall,Pre,F1_score,AUC=metrics_score(y_test,y_pred)
print('准确率:%.2f|召回率:%.2f|精确率:%.2f|F1_score:%.2f|AUC:%.2f'%(Accuracy,Recall,Pre,F1_score,AUC))

准确率:0.90|召回率:0.92|精确率:0.01|F1_score:0.03|AUC:0.91

可以看到召回率=135/(135+12)=0.9183673469387755较高，准确率0.90也比较高，但是精确率较低，这是因为误抓的样本10624比较多，并且还给我们增加了工作量，根据实际业务需求，后续肯定要对这些异常样本做一些处理，比如冻结账号、电话询问等。这是用下采样处理数据所存在的问题。

6 模型改进-过采样处理

在采用下采样的方案中，可以看到召回率较高的同时，误抓的样本也非常多。于是采用过采样处理方案看效果是否会好一些。

smote算法

SMOTE（Synthetic Minority Oversampling Technique），合成少数类过采样技术．它是基于随机过采样算法的一种改进方案，由于随机过采样采取简单复制样本的策略来增加少数类样本，这样容易产生模型过拟合的问题，即使得模型学习到的信息过于特别(Specific)而不够泛化(General)，SMOTE算法的基本思想是对少数类样本进行分析并根据少数类样本人工合成新样本添加到数据集中，具体如下图所示，算法流程如下。

(1)对于少数类中每一个样本x，以欧氏距离为标准计算它到少数类样本集中所有样本的距离，得到其k近邻。

(2)根据样本不平衡比例设置一个采样比例以确定采样倍率N，对于每一个少数类样本x，从其k近邻中随机选择若干个样本，假设选择的近邻为xn。

(3)对于每一个随机选出的近邻 x n x_n xn​，分别与原样本按照如下的公式构建新的样本。
x n e w = x + r a n d ( 0 , 1 ) ∗ ( x n − x ) x_{new}=x+rand(0,1)*(x_n-x) xnew​=x+rand(0,1)∗(xn​−x)

import pandas as pd
from imblearn.over_sampling import SMOTE  # pip  install imblearn
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split

columns = data.columns
features_columns = columns.delete(len(columns) - 1)
features = data[features_columns]
labels = data['Class']

划分训练集和测试集

features_train, features_test, labels_train, labels_test = train_test_split(
    features, labels, test_size=0.2, random_state=0)

smote算法生成过采样数据

oversampler = SMOTE(random_state=0)
os_features,os_labels = oversampler.fit_resample(features_train,labels_train) # OS  oversampler
print('过采样后label为1的数据为:',len(os_labels[os_labels==1]))

过采样后label为1的数据为: 227454

k折交叉验证选择最优参数

os_features = pd.DataFrame(os_features)
os_labels = pd.DataFrame(os_labels)

os_features = pd.DataFrame(os_features)
os_labels = pd.DataFrame(os_labels)
best_c = printing_Kfold_scores(os_features, os_labels)

-------------------------------------------
C parameter:  0.01
-------------------------------------------

Iteration  1 : recall score =  0.9161290322580645
Iteration  2 : recall score =  0.9078947368421053
Iteration  3 : recall score =  0.9026004204935266
Iteration  4 : recall score =  0.8831844011386993
Iteration  5 : recall score =  0.8844923665380684

Mean recall score  0.8988601914540928

-------------------------------------------
C parameter:  0.1
-------------------------------------------

Iteration  1 : recall score =  0.9161290322580645
Iteration  2 : recall score =  0.9078947368421053
Iteration  3 : recall score =  0.9032200951643244
Iteration  4 : recall score =  0.8835251316208879
Iteration  5 : recall score =  0.8848880535496423

Mean recall score  0.8991314098870049

-------------------------------------------
C parameter:  1
-------------------------------------------

Iteration  1 : recall score =  0.9161290322580645
Iteration  2 : recall score =  0.9078947368421053
Iteration  3 : recall score =  0.9033528825937811
Iteration  4 : recall score =  0.8837889229619371
Iteration  5 : recall score =  0.8849320187731504

Mean recall score  0.8992195186858076

-------------------------------------------
C parameter:  10
-------------------------------------------

Iteration  1 : recall score =  0.9161290322580645
Iteration  2 : recall score =  0.9078947368421053
Iteration  3 : recall score =  0.9033528825937811
Iteration  4 : recall score =  0.8837009925149207
Iteration  5 : recall score =  0.8849540013849045

Mean recall score  0.8992063291187552

-------------------------------------------
C parameter:  100
-------------------------------------------

Iteration  1 : recall score =  0.9161290322580645
Iteration  2 : recall score =  0.9078947368421053
Iteration  3 : recall score =  0.9033307513555383
Iteration  4 : recall score =  0.8838658621030765
Iteration  5 : recall score =  0.8849540013849045

Mean recall score  0.8992348767887378

*********************************************************************************
Best model to choose from cross validation is with C parameter =  100.0
*********************************************************************************

使用过采样数据训练模型，并用测试集测试

lr = LogisticRegression(C = best_c, penalty = 'l1', solver='liblinear')
lr.fit(os_features,os_labels.values.ravel())
y_pred = lr.predict(features_test.values)
 
# Compute confusion matrix
cnf_matrix = confusion_matrix(labels_test,y_pred)
np.set_printoptions(precision=2)

Accuracy,Recall,Pre,F1_score,AUC=metrics_score(labels_test,y_pred)
print('准确率:%.2f|召回率:%.2f|精确率:%.2f|F1_score:%.2f|AUC:%.2f'%(Accuracy,Recall,Pre,F1_score,AUC))

# Plot non-normalized confusion matrix
class_names = [0,1]
plt.figure()
plot_confusion_matrix(cnf_matrix
                      , classes=class_names
                      , title='Confusion matrix')
plt.show()

#ROC曲线图
y_pred_proba=lr.predict_proba(features_test.values)
fpr, tpr, thresholds = roc_curve(labels_test,y_pred_proba[:,1])
plt.plot(fpr,tpr,label='AUC = %0.2f'% AUC)
plt.legend(loc='lower right')
plt.ylabel('True Positive Rate')
plt.xlabel('False Positive Rate')
plt.plot([0,1],[0,1],'r--')
plt.show()

准确率:0.97|召回率:0.93|精确率:0.06|F1_score:0.11|AUC:0.95

在这里插入图片描述

在这里插入图片描述

可以看到过采样对比下采样，在准确率，召回率和精确率上都有提高，虽然过采样的准确率和召回率都很高，但是精确率还是非常低，也就是误抓的样本偏多，尽管过采样比欠采样的效果要好，但是此模型的选择方面还有待进一步优化。

7 随机森林建模

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score
clf_RF=RandomForestClassifier(n_estimators=10,random_state=123)#构建分类随机森林分类器
clf_RF.fit(os_features,os_labels.values.ravel())

#交叉验证
scores_RF=cross_val_score(clf_RF,os_features,os_labels.values.ravel())
print('RandomForestClassifier交叉验证准确率为:'+str(scores_RF.mean()))

RandomForestClassifier交叉验证准确率为:0.9997933645851017

# 生成混淆矩阵
cnf_matrix_RF= confusion_matrix(labels_test,y_RFpred)  
np.set_printoptions(precision=2)
Accuracy,Recall,Pre,F1_score,AUC=metrics_score(labels_test,y_RFpred)
print('准确率:%.3f|召回率:%.2f|精确率:%.2f|F1_score:%.2f|AUC:%.2f'%(Accuracy,Recall,Pre,F1_score,AUC))
#画混淆矩阵
class_names = [0,1]
plt.figure(figsize=(6,6))
plot_confusion_matrix(cnf_matrix_RF,classes=class_names,title='Confusion matrix')
plt.show()

准确率:0.999|召回率:0.83|精确率:0.84|F1_score:0.84|AUC:0.92

在这里插入图片描述

在过采样处理下，随机森林虽然召回率（0.83）没有逻辑回归模型的召回率（0.93）高，但是精确率却有很大提升，也就是说针对后续的欺诈行为，可能会去冻结顾客的银行卡帐户，或者打电话向这些怀疑对象要一些额外资料如信用卡银行对账单，用以核对部分卡号等措施，那为了尽可能少的去打扰到“无辜”客户，所以选择随机森林模型对信用卡欺诈预测效果会更好一些。

Jelly-ha
关注
  • 6
    点赞
  • 踩
  • 104
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
机器学习案例实战之信用卡欺诈检测（逻辑回归）
huahuaxiaoshao的博客
12-24 4950
机器学习案例实战之信用卡欺诈检测 1.实战案例背景：这是一份个人交易记录，因为其中涉及到了隐私的内容，进行了类似PCA的处理，我们的数据已经把特征数据提取出来了，接下来，通过逻辑回归进行检测。 2.拿到数据千万不要忙着去建立模型，一定要先观察数据 import pandas as pd import numpy as np import matplotlib.pyplot as plt %matp...
Kaggle经典案例—信用卡诈骗检测的完整流程(学习笔记)
12-22
本文此案例的完整流程和涉及知识 首先先看数据 import pandas as pd import matplotlib.pyplot as plt import numpy as np %matplotlib inline data = pd.read_csv("creditcard.csv") data.head() data.shape 好的，它长这个样子。大致解释一下V1-V28都是一系列的指标(具体是什么不用知道)，Amount是交易金额，Class＝0表示是正常操作，而=1表示异常操作。 明确目标：检测是否异常，也就是说是一个二分类问题，接着想到用逻辑回归建模。 1.观察数据特
数据挖掘—逻辑回归分类—信用卡欺诈分析
weixin_45902007的博客
12-26 2240
文章目录1、分析目的：2、掌握要点：3、构建逻辑回归分类器4、模型评估指标5、精确度和召回率（不平衡数据衡量指标）6、案例分析： 1、分析目的： 信用卡欺诈的危害性大，如何通过遗忘的交易数据分析出每笔交易是否在正常是分析的主要目的 2、掌握要点： 了解逻辑回归分类，以及如何在 sklearn 中使用它； 信用卡欺诈属于二分类问题，欺诈交易在所有交易中的比例很小，对于这种数据不平衡的情况，到底采用什么样的模型评估标准会更准确； 完成信用卡欺诈分析的实战项目，并通过数据可视化对数据探索和模型结果评估进一步加强
SPSS Modeler操作步骤：信用卡诈骗风险判别建模
最新发布
m0_68701027的博客
02-27 442
使用SPSS Modeler，建立判别信用卡是否存在诈骗风险的预测模型，并评估其准确度
信用卡欺诈检测分析案例
weixin_30357231的博客
11-21 417
data = pd.read_csv("creditcard.csv") data.head()count_classes = pd.value_counts(data['class'],sort = True).sort_index() # value_count:计算数值的个数count_classes.plot(kind = 'bar') # 绘制条形图plt.title("...
python之逻辑回归项目实战——信用卡欺诈检测
weixin_45666566的博客
11-29 5175
信用卡欺诈检测1、项目介绍2、分析项目3、数据读取与分析3.1 加载数据3.2 查看数据的标签分布4、数据预处理4.1 特征标准化4.2. 使用下采样解决样本数据不均衡6、总结6.1 样本不均衡解决方案 1、项目介绍 \quad \quad原始数据为银行的个人交易记录，每一条信息代表一次交易，原始数据已经进行了类似PCA的处理，现在已经把特征数据提取好了，检测的目的是通过数据找出那些交易存在潜在的欺诈行为。 2、分析项目 \quad \quad基于信用卡交易记录数据建立分类模型来预测哪些交易记录是异常的哪些
机器学习预测实战 -- 信用卡交易欺诈数据监测（含方案和代码思路）
a_Loki的博客
03-27 6838
项目背景 一批交易数据，数据总量28万，其中正常交易数据量占比99.83%，欺诈交易数据量仅占比0.17%。 目标 训练出一个模型，能判断出交易数据是正常数据还是欺诈数据 方案一：下采样的方法训练模型 获取数据 import pandas as pd import numpy as np import seaborn as sns import matplotlib.pyplot as plt import time import warnings warnings.filterwarning
【机器学习】数据挖掘实战-信用卡欺诈建模全流程！
fengdu78的博客
06-29 872
公众号：尤而小屋作者：Peter编辑：Peter今天给大家分享一篇关于机器学习建模实战的文章：基于机器学习树模型的信用卡欺诈检测。导入库首先导入建模所需要的各种库，包含：可视化、数据预处理、特征工作、模型评估等In [2]:importpandasaspd importnumpyasnp importmatplotlib importmatplotlib.pyplotaspl...
数据分析案例-基于随机森林模型对信用卡欺诈检测
m0_64336780的博客
06-20 8133
信用卡欺诈是指故意使用伪造、作废的信用卡，冒用他人的信用卡骗取财物，或用本人信用卡进行恶意透支的行为,信用卡欺诈形式分为3种：失卡冒用、假冒申请、伪造信用卡。欺诈案件中，有60%以上是伪造信用卡诈骗，其特点是团伙性质，从盗取卡资料、制造假卡、贩卖假卡，到用假卡作案，牟取暴利。而信用卡欺诈检测是银行减少损失的重要手段。数据介绍部分数据如下 查看数据大小原始数据共有284807行，31列删除缺失值和重复值 经过数据清洗后还有283726行，31列数据查看是否欺诈的数量比例 我们发现原
钉钉杯初赛A题建模-多模型融合预测银行卡诈骗模型（详细代码、解释）
shine_Lee_的博客
08-13 3936
使用多种用于数据挖掘的机器学习模型对给定数据集进行建模； 2) 对样本数据进一步挖掘分析，通过交叉验证、网格调优对不同模型的参 数进行调整，寻找最优解，将多个最优模型进行进一步比较； 3) 通过对 precision（预测精度）、recall（召回率）、f1-score（F1 分 数值）进行计算，给出选择某一种预测模型的理由； 4) 将模型性能评价通过多种作图方式进行可视化......
python信用卡欺诈检（数据清洗，数据分析，数学建模， 模型预测和比较）
涛涛不淘
10-27 2776
信用卡欺诈检测文件记录了2013年9月欧洲信用卡持有者所发生的交易。 数据集的整体特征 经过事后分析判断，在数据文件记录的284807次交易行为中，有492次虚假交易行为。 因为涉及到商业秘密和客户隐私，数据文件是原始记录经过主成分分析法PCA（从较多维度数据中提取出有价值的较少维度的数据，从而降低数据挖掘算法的计算难度）以后提取出来的。 一共有284807条记录，每条记录对应一次交易的持卡人信息或者交易信息。
机器学习项目-金融反欺诈模型
10-09
机器学习项目，金融反欺诈模型，完整例程，python编写，已测试通过
信用卡欺诈检测.rar
10-02
此资料里面的内容主要是解决如何在大数据集（本资料中是28w）中检测出欺诈数据集（本资料中是500）,通过对原始数据集的处理之后，利用机器学习的方法，对其进行建模处理，然后不断进行模型的调优，最后达到检测效果...
SVM_信用卡欺诈
12-21
信用卡欺诈问题概述实现过程SVM介绍数据源下载代码实现代码解释总结 概述 初衷是因为引用卡欺诈问题相对与其他机器学习问题略有不同，因为二分类数据量差距过大，导致以往的评价方法对其不适用，如下图的284807 笔...
基于HMM模型的信用卡欺诈检测-研究论文
06-09
信用卡欺诈是一个严重且日益严重的问题。 由于电子商务技术的飞速发展，信用卡的使用急剧增加。 随着信用卡成为最流行的在线支付方式和常规支付方式，与之相关的欺诈案件也在增加。 在本文中，我们使用隐马尔可夫...
机器学习应用实例-使用逻辑回归算法（Logistic Regression）实现信用卡欺诈检测
05-07
本资源使用基于Sklearn实现逻辑回归算法，同时提供了用于模型训练的数据集（信用卡数据集合），实现对是否存在信用卡欺诈行为进行检测。资源包括以下内容： 1、jupyter notebook程序源码 2、用于模型训练的数据集...
基于大数据分析技术实现对信用卡盗刷的预防
CSDNFly1的博客
07-08 1880
原文地址： 摘 要 近年来信用卡已成为我国社会公众使用最广泛的非现金支付工具,然而在带给人们生活便利的同时,被盗刷的现象也在增多。好在随着信息技术的不断发展,近年来金融行业的数据存储已基本实现全数字化,积累了庞大的数据量，为大数据技术的应用提供先天条件。随着大数据技术应用方面的不断探索,通过数据分析实现审计功能,“让数据说话”,极大的提高了审计的质量和效率。 本文将通过数据分析，对银行消费进行分析，判断用户的信用卡的消费是否非本人所为即是否存在盗刷行为，我们将采用二分类——逻辑回归算法对海...
基于随机森林、svm、CNN机器学习的风控欺诈识别模型
拓端研究室TRL
11-28 1754
最后，在线上信用贷场景实践下来，经过多批次多个跨时间段的验证，可以看到，效果上还是有非常直接的提升，模型性能相比传统模型提升了大约30%。
信用卡欺诈检测：2021 年顶级机器学习解决方案
fulk6667g78o8的专栏
12-01 2671
信用卡欺诈检测：2021 年顶级机器学习解决方案
信用卡欺诈检测python_python数据分析－信用卡欺诈行为检测
05-25
信用卡欺诈检测是一种非常重要的应用场景，可以帮助银行和客户识别和预防欺诈行为。在Python中，我们可以使用各种机器学习和深度学习算法来构建欺诈检测模型。 首先，我们需要了解数据集。信用卡欺诈检测数据集通常包含大量的交易数据，其中只有少数是欺诈交易。我们需要使用机器学习算法来识别这些欺诈交易。 接下来，我们可以使用Python中的各种机器学习库来构建模型，例如Scikit-learn，TensorFlow和Keras等。我们可以使用分类算法（例如逻辑回归，决策树和随机森林等）来构建模型，也可以使用深度学习算法（例如神经网络和卷积神经网络等）来构建模型。 在实现模型之前，我们还需要进行数据预处理和特征工程。我们需要对数据进行清洗，处理缺失值和异常值，并进行特征选择和降维等操作，以提高模型的性能。 最后，我们可以使用交叉验证和网格搜索等技术来优化模型，并评估模型的性能。我们可以使用各种性能指标（例如准确率，召回率和F1分数等）来评估模型的性能，并选择最佳模型来预测新的欺诈交易。 总之，信用卡欺诈检测是一项非常重要的任务，Python提供了各种机器学习和深度学习算法来实现。通过数据预处理，特征工程和模型优化，我们可以构建高效的欺诈检测模型，帮助银行和客户识别和预防欺诈行为。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值