信用卡欺诈检测

  • 1、项目介绍
  • 2、项目背景
  • 3、分析项目
  • 4、数据读取与分析
    • 4.1 加载数据
    • 4.2 查看数据的标签分布
  • 5、数据预处理
    • 5.1 特征标准化
    • 5.2. 使用下采样解决样本数据不均衡
  • 6、训练数据即划分数据集
  • 7、模型建立
    • 7.1 sklearn LR工具包
    • 7.2 模型调参，初步建立模型
  • 8、模型评估
    • 8.1 分类模型常用评估方法
    • 8.2 模型评估——混淆矩阵
  • 9、改进模型——过采样方案
    • 9.1 SMOTE数据生成策略
    • 9.2 构造过采样数据
    • 9.3 构建模型
  • 10、总结
    • 10.1 样本不均衡解决方案
    • 10.2 其他

1、项目介绍

\quad \quad本项目通过利用信用卡的历史交易数据，进行机器学习，构建信用卡反欺诈预测模型，提前发现客户信用卡被盗刷的事件。

2、项目背景

\quad \quad 该项目所使用的数据集包含持卡人在两天内使用信用卡的交易情况，共有284807笔交易，其中有492笔交易为盗刷。数据集中的数据是经过了PCA降维，并且出于保密原因，这些特征都进行了脱敏处理，数据以秒为单位记录。通过对这些数据的分析，建模，可以对信用卡盗刷情况进行预测。有利于银行对存在风险的交易采取措施，减小银行和持卡人的损失。并设置合理的阈值，使得银行在减小盗刷损失的前提下，更好的提升使用信用卡的体验。

3、分析项目

\quad \quad基于信用卡交易记录数据建立分类模型来预测哪些交易记录是异常的哪些是正常的。

4、数据读取与分析

4.1 加载数据

# 导入工具包
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
# 魔法指令，在Notebook画图展示使用的
%matplotlib inline
data = pd.read_csv("creditcard.csv")
# 展示数据前前五行，查看数据
data.head()


此图为截取部分数据，原始数据集共有31列，其中数据特征有30列，Amount列表示贷款的金额（其数值变化幅度很大，后续处理时可进行标准化处理），Class列表示分类结果，若Class为0代表该条交易记录正常，若Class为1代表该条交易记录异常。

4.2 查看数据的标签分布

这里看看异常数据和正常数据各自的数量:

count_classes=pd.value_counts(data['Class'],sort=True).sort_index()
print(count_classes)
count_classes.plot(kind='bar')# 柱形图
plt.title("Fraud class histogram")
plt.xlabel("class")
plt.ylabel("Frequency")

out:
0 284315
1 492
Name: Class, dtype: int64

从图中可以看出标签为0的很多，而标签为1的却很少，说明样本的分布情况是非常不均衡的，所以在构建分类器的时候要特别注意一个误区，即使将结果全部预测为0也会出现很好的分类结果，这是在数据处理中需要着重考虑的一点。

5、数据预处理

5.1 特征标准化

1、首先对Amount的值进行标准化处理，从机器学习库Scikit-Learn引入标准化函数即可。

from sklearn.preprocessing import StandardScaler
# 在数据集中加入Amount标准化的一列数据,reshape(-1,1)的含义是将传入数据转换成一列的形式
data['normAmount']=StandardScaler().fit_transform(data['Amount'].values.reshape(-1,1))
# drop操作去掉无用特征
data = data.drop(['Time','Amount'],axis=1)
data.head()

5.2. 使用下采样解决样本数据不均衡

\quad \quad首先计算异常样本的个数并取其索引，接下来在正常样本中随机选择指定个数样本，最后把所有样本索引拼接在一起即可。

#取出所有属性，不包含class的这一列
X = data.iloc[:, data.columns != 'Class']
#取出class这一列
y = data.iloc[:, data.columns == 'Class']#计算出class==1（存在欺诈行为）元素有多少个
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)
# 转换成numpy的格式
random_normal_indices = np.array(random_normal_indices)# 有了正常和异常样本后把它们的索引都拿到手，将class=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']
#下采样数据集的label
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

6、训练数据即划分数据集

疑问？ 为什么进行了下采样，还要把原始数据进行切分呢？
这是因为 对数据集的训练是通过下采样的训练集，对数据的测试的是通过原始的数据集的测试集，下采样的测试集可能没有原始部分当中的一些特征，不能充分进行测试。

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("")
print("下采样训练集包含样本数量: ", len(X_train_undersample))
print("下采样测试集包含样本数量: ", len(X_test_undersample))
print("下采样样本总数: ", len(X_train_undersample)+len(X_test_undersample))

7、模型建立

7.1 sklearn LR工具包

官方文档

class
sklearn.linear_model.LogisticRegression(penalty='l2', *, dual=False, tol=0.0001, C=1.0, fit_intercept=True, intercept_scaling=1, class_weight=None,
random_state=None, solver='lbfgs', max_iter=100, multi_class='auto', verbose=0, warm_start=False, n_jobs=None, l1_ratio=None)

7.2 模型调参，初步建立模型

1、正则化惩罚参数调一调

\quad \quad使用逻辑回归模型构建分类器，通过k折交叉验证寻找最优正则化惩罚参数C。

\quad \quad由于本文数据的特殊性，分类模型的评估的方法十分钟重要，通常采用的评价指标有准确率、召回率和F值（F-Measure）等。本文采用recall（召回率）作为评估标准。原因是具体举个例子介绍：假设我们在医院中有1000个病人，其中990个为正样本（正常），10个为负样本（癌症），我们的目的是找出其中的10个负样本，假如我们的模型将多有的1000个病人都预测为正样本，虽然精度有99%，但是并没有找到我们所要的10个负样本，所以这个模型是没用的，因为一个癌症病人都找不出来。而recall是对于想找的东西，找到了多少个，而不是所有样本的精度。
\quad \quad在构造权重参数的时候，为了防止过拟合的现象发生，要引入正则化惩罚项，使这些权重参数处于比较平滑的趋势，具体参数选择在代码中会给出解释。

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
def printing_Kfold_scores(x_train_data,y_train_data):#k折交叉验证fold = KFold(n_splits=5,shuffle=False)#不同的惩罚参数C的参数集，因为不知道哪一种惩罚参数的力度好，通过验证集结果来选择c_param_range = [0.01,0.1,1,10,100]#创建一个5行两列的空的DataFrame框，用于存放数据results_table = pd.DataFrame(index = range(len(c_param_range),2), columns = ['C_parameter','Mean recall score'])#将'C_parameter'列设置为惩罚参数集中的值results_table['C_parameter'] = c_param_range#k折操作将会给出两个列表：train_indices = indices[0], test_indices = indices[1]j = 0for c_param in c_param_range:print('-------------------------------------------')print('C parameter: ', c_param)print('-------------------------------------------')print('')recall_accs = []#enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。for iteration,indices in enumerate(fold.split(x_train_data)):#把c_param_range代入到逻辑回归模型中，并使用了l1正则化lr = LogisticRegression(C = c_param,penalty = 'l1',solver='liblinear')#使用indices[0]的数据进行拟合曲线，使用indices[1]的数据进行误差测试lr.fit(x_train_data.iloc[indices[0],:],y_train_data.iloc[indices[0],:].values.ravel())#在indices[1]数据上预测值y_pred_undersample = lr.predict(x_train_data.iloc[indices[1],:].values)#根据不同的c_parameter计算召回率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)#求出我们想要的召回平均值results_table.loc[j,'Mean recall score'] = np.mean(recall_accs)j += 1print('')print('Mean recall score ', np.mean(recall_accs))print('')best_c = results_table.loc[results_table['Mean recall score'].values.argmax()]['C_parameter']#最后选择最好的 C parameterprint('*********************************************************************************')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  0 : recall score =  0.9315068493150684
Iteration  1 : recall score =  0.9178082191780822
Iteration  2 : recall score =  1.0
Iteration  3 : recall score =  0.972972972972973
Iteration  4 : recall score =  0.9545454545454546Mean recall score  0.9553666992023157-------------------------------------------
C parameter:  0.1
-------------------------------------------Iteration  0 : recall score =  0.8493150684931506
Iteration  1 : recall score =  0.863013698630137
Iteration  2 : recall score =  0.9322033898305084
Iteration  3 : recall score =  0.9459459459459459
Iteration  4 : recall score =  0.9090909090909091Mean recall score  0.8999138023981302-------------------------------------------
C parameter:  1
-------------------------------------------Iteration  0 : recall score =  0.863013698630137
Iteration  1 : recall score =  0.863013698630137
Iteration  2 : recall score =  0.9661016949152542
Iteration  3 : recall score =  0.9459459459459459
Iteration  4 : recall score =  0.8939393939393939Mean recall score  0.9064028864121736-------------------------------------------
C parameter:  10
-------------------------------------------Iteration  0 : recall score =  0.8767123287671232
Iteration  1 : recall score =  0.8767123287671232
Iteration  2 : recall score =  0.9661016949152542
Iteration  3 : recall score =  0.9324324324324325
Iteration  4 : recall score =  0.9090909090909091Mean recall score  0.9122099387945685-------------------------------------------
C parameter:  100
-------------------------------------------Iteration  0 : recall score =  0.8767123287671232
Iteration  1 : recall score =  0.9041095890410958
Iteration  2 : recall score =  0.9661016949152542
Iteration  3 : recall score =  0.9324324324324325
Iteration  4 : recall score =  0.9090909090909091Mean recall score  0.9176893908493631*********************************************************************************
Best model to choose from cross validation is with C parameter =  0.01
*********************************************************************************

从输出结果中可以看出最佳的惩罚参数C为0.01。

8、模型评估

8.1 分类模型常用评估方法

1、 准确度
\quad \quad表示在分类问题中，做对的占总体的百分比
Accuracy=TP+TNTP+FP+FN+TNAccuracy=\frac{TP+TN}{TP+FP+FN+TN}Accuracy=TP+FP+FN+TNTP+TN​

2、 召回率
\quad \quad表示在正例中有多少能预测到，覆盖面的
大小，一般作为检测类题目的评估标准。简言之，就是实际筛选出来的/本应该筛选出来的。

Recall=TPTP+FNRecall=\frac{TP}{TP+FN}Recall=TP+FNTP​

3、精确度
\quad \quad表示被分为正例中实际为正例的比例。

Precision=TPTP+FPPrecision=\frac{TP}{TP+FP}Precision=TP+FPTP​

4 、混淆矩阵

代码

# 混淆矩阵的可视化显示，以下代码可以直接作为模板
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],horizontalalignment="center",color="white" if cm[i, j] > thresh else "black")plt.tight_layout()plt.ylabel('True label')plt.xlabel('Predicted label')

8.2 模型评估——混淆矩阵

1、使用下采样数据训练，使用下采样数据测试

# 下采样最佳参数构造的LR模型
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)
#计算混淆矩阵，confusion_matrix(y_true,y_pred)
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.9387755102040817


\quad \quad在下采样数据集中，目标任务是二分类，所以只有0和1，主对角线上的值就是预测值和真实值一致的情况，深色区域代表模型预测正确（真实值和预测值一致），其余位置代表预测错误。数值9代表有9个样本数据本来是异常的，模型却将它预测为正常，相当于“漏检”。数值21代表有21个样本数据本来是正常的，却把它当成异常的识别出来，相当于“误杀”。

\quad \quad最终得到的召回率为0.93878，看起来是一个还不错的指标，但是还有一些问题。用下采样的数据集进行建模，并且测试集也是下采样的测试集，在这份测试集中，异常样本和正常样本的比例基本均衡，因为已经对数据集进行过处理。但是实际的数据集并不会是这样的，相当于在测试使用理想情况来代替真实情况，这样的检测效果可能会偏高。因此，我们在测试的时候，千万要注意使用原始数据的测试集，才能最具有代表性，只需要改变传入的测试数据即可。下面来操作一下：

2、使用下采样数据训练，使用原始数据测试

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)
#计算混淆矩阵
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.9251700680272109


\quad \quad虽然recall值可达到92.5%，但是其中有11274个数据本来不存在欺诈行为，却检测成了欺诈行为，这还是一个挺头疼的问题。如果误杀掉这么多样本，实际业务也会出现问题，这就要求我们再对模型进行修改。之前我们所提到的解决样本不均衡方案还有一个过采样方案，下面我们来试一下。

9、改进模型——过采样方案

\quad \quad在下采样方案中，虽然得到较高的召回率，但是误杀的样本数量太多了，下面就来看看用过采样方案能否解决这个问题。使用过采样，使得两种样本数据一样多。

9.1 SMOTE数据生成策略

\quad \quad如何才能让异常样本与正常样本一样多呢？这里需要对少数样本进行生成，这可不是复制粘贴，一摸一样的样本是没有用的，需要采用一些策略，最常用的就是SMOTE算法，其基本原理为：
1、对于少数类中的每一个样本x，以欧式距离计算它到少数类样本集中所有样本的距离，经过排序，得到其近邻样本。

2、根据样本不平衡比例设置一个采样比例以确定采样倍率N，对于每一个少数样本x，从其近邻中开始依次选择N个样本xnx_nxn​。

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

\quad \quad对于SMOTE算法，可以使用imblearn工具包完成这个操作，首先需要安装该工具包，可以直接在命令行中使用pip install imblearn 完成安装操作。再把SMOTE算法加载进来，只要将特征数据和便签传进去即可。

9.2 构造过采样数据

import pandas as pd
from imblearn.over_sampling import SMOTE
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split
# 读入文件，将数据分成features-labels两部分
credit_cards=pd.read_csv('creditcard.csv')
columns=credit_cards.columns
# 在特征中去除掉标签
features_columns=columns.delete(len(columns)-1)
features=credit_cards[features_columns]
labels=credit_cards['Class']
# 划分训练集、测试集
features_train, features_test, labels_train, labels_test = train_test_split(features, labels, test_size=0.3, random_state=0)
# 过采样
oversampler=SMOTE(random_state=0)
os_features,os_labels=oversampler.fit_sample(features_train,labels_train)
len(os_labels[os_labels==1])#查看生成样本后异常样本的数量

9.3 构建模型

1、 K折交叉验证得到最好的惩罚参数C

# 转换成能被逻辑回归模型接受的数据类型
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  0 : recall score =  0.9142857142857143
Iteration  1 : recall score =  0.88
Iteration  2 : recall score =  0.9716742539200809
Iteration  3 : recall score =  0.9614732372781288
Iteration  4 : recall score =  0.9618752119788461Mean recall score  0.9378616834925542-------------------------------------------
C parameter:  0.1
-------------------------------------------Iteration  0 : recall score =  0.9142857142857143
Iteration  1 : recall score =  0.88
Iteration  2 : recall score =  0.9728376327769348
Iteration  3 : recall score =  0.9640735111233937
Iteration  4 : recall score =  0.9641111962515859Mean recall score  0.9390616108875257-------------------------------------------
C parameter:  1
-------------------------------------------Iteration  0 : recall score =  0.9142857142857143
Iteration  1 : recall score =  0.88
Iteration  2 : recall score =  0.9730652503793626
Iteration  3 : recall score =  0.9644001155677264
Iteration  4 : recall score =  0.9644001155677264Mean recall score  0.939230239160106-------------------------------------------
C parameter:  10
-------------------------------------------Iteration  0 : recall score =  0.9142857142857143
Iteration  1 : recall score =  0.88
Iteration  2 : recall score =  0.9730905412240769
Iteration  3 : recall score =  0.9642870601831497
Iteration  4 : recall score =  0.9642242516361627Mean recall score  0.9391775134658207-------------------------------------------
C parameter:  100
-------------------------------------------Iteration  0 : recall score =  0.9142857142857143
Iteration  1 : recall score =  0.88
Iteration  2 : recall score =  0.9726858877086495
Iteration  3 : recall score =  0.9643624304395342
Iteration  4 : recall score =  0.9644252389865213Mean recall score  0.9391518542840839*********************************************************************************
Best model to choose from cross validation is with C parameter =  1.0
*********************************************************************************

2、逻辑回归计算混淆矩阵以及召回率

# 代入逻辑回归模型计算混淆矩阵以及召回率lr = LogisticRegression(C = best_c, penalty = 'l1',solver='liblinear')
lr.fit(os_features,os_labels.values.ravel())
y_pred = lr.predict(features_test.values)
# 计算混淆矩阵
cnf_matrix = confusion_matrix(labels_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]))
# 画出非规范化的混淆矩阵
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.8843537414965986

\quad \quad小结：虽然过采样的recall值比下采样稍小，但是它的精度却大大提高了，即减少了误杀的数量，所以在出现数据不均衡的情况下，较经常使用的是生成数据而不是减少数据，但是数据一旦多起来，运行时间也变长了。

10、总结

从此项目中得到了以下技术点：

10.1 样本不均衡解决方案

\quad \quad如何解决数据标签不平衡问题？首先造成数据标签不平衡的最根本原因就是它们的个数相差悬殊，如果能让它们的个数相差不大，或者比例接近，这个问题就解决了。基于此，有以下两种解决方案：

（1）下采样
\quad \quad既然异常数据比较少，那就让正常样本和异常样本一样少。例如正常样本有30w个，异常样本只有500个，若从正常样本中随机选出500个，他们的比列就均衡了。虽然下采样的方法看似很简单，但是也存在瑕疵，即使原始数据很丰富，下采样过后，只利用了其中一小部分数据，这样对结果会不会有影响呢？

（2）过采样
\quad \quad不想放弃任何有价值的数据，只能让异常样本和正常样本一样多，怎么做到呢？异常样本样本若只有500个样本，此时可以对数据进行和转换，假造出来一些异常数据，数据生成也是现阶段常见的一种套路。虽然数据生成解决了异常样本数量的问题，但是异常数据毕竟是造出来的，会不i会存在问题呢？

\quad \quad这两种方案各有优缺点，到底哪种方案比较好呢？需要进行实验比较。

10.2 其他

（1）模型的调参也是很重要的，之前我们通过实验也发现了不同的参数可能会对结果产生较大的影响，这一步也是必须的，后续实战内容我们还会来强调调参的细节，这里就简单概述一下了。对于参数我建立大家在使用工具包的时候先看看其API文档，知道每一个参数的意义，再来实验选择合适的参数值。

（2）得到的结果一定要和实际任务结合在一起，有时候虽然得到的结果指标还不错，但是实际应用却成了问题，所以测试环节也是必不可少的。到此，这个项目就给大家介绍到这里了，在实践中学习才能成长的更快，建议大家一定使用提供的Notebook代码文件来自己完成一遍上述操作。

python之逻辑回归项目实战——信用卡欺诈检测相关推荐

  1. 机器学习项目实战----信用卡欺诈检测(二)

    六.混淆矩阵: 混淆矩阵是由一个坐标系组成的,有x轴以及y轴,在x轴里面有0和1,在y轴里面有0和1.x轴表达的是预测的值,y轴表达的是真实的值.可以对比真实值与预测值之间的差异,可以计算当前模型衡量 ...

  2. 机器学习项目实战----信用卡欺诈检测

    一.任务基础 数据集包含由欧洲人于2013年9月使用信用卡进行交易的数据.此数据集显示两天内发生的交易,其中284807笔交易中有492笔被盗刷.数据集非常不平衡,正例(被盗刷)占所有交易的0.172 ...

  3. 机器学习项目实战----信用卡欺诈检测(一)

    一.任务基础 数据集包含由欧洲人于2013年9月使用信用卡进行交易的数据.此数据集显示两天内发生的交易,其中284807笔交易中有492笔被盗刷.数据集非常不平衡,正例(被盗刷)占所有交易的0.172 ...

  4. 逻辑回归三部曲——逻辑回归项目实战(信贷数据+Python代码实现)

         逻辑回归已经在各大银行和公司都实际运用于业务,已经有很多前辈写过逻辑回归.本文将从我实际应用的角度阐述逻辑回归的由来,致力于让逻辑回归变得清晰.易懂.逻辑回归又叫对数几率回归,是一种广义线性 ...

  5. 大数据分析实战-信用卡欺诈检测（五）-逻辑回归模型

    大数据分析实战-信用卡欺诈检测(一) 大数据分析实战-信用卡欺诈检测(二)-下采样方案和交叉验证 大数据分析实战-信用卡欺诈检测(三)- 模型评估 大数据分析实战-信用卡欺诈检测(四)-正则化惩罚 逻 ...

  6. 大数据分析实战-信用卡欺诈检测（四）-正则化惩罚

    大数据分析实战-信用卡欺诈检测(一) 大数据分析实战-信用卡欺诈检测(二)-下采样方案和交叉验证 大数据分析实战-信用卡欺诈检测(三)- 模型评估 文章目录 正则化惩罚 正则化惩罚 正则化惩罚,这个名 ...

  7. 大数据分析实战-信用卡欺诈检测（三）- 模型评估

    大数据分析实战-信用卡欺诈检测(二)-下采样方案和交叉验证 大数据分析实战-信用卡欺诈检测(一) 文章目录 模型评估方法 模型评估方法 接下来,没错,还没到实际建模任务,还需要考虑模型的评估方法,为什 ...

  8. 大数据分析实战-信用卡欺诈检测（二）-下采样方案和交叉验证

    第一部分已经写到这里了,看完第一部分再看这一部分:大数据分析实战-信用卡欺诈检测 文章目录 下采样方案 交叉验证 下采样方案 下采样方案的实现过程比较简单,只需要对正常样本进行采样,得到与异常样本一样 ...

  9. NO.62——100天机器学习实践第五天：用逻辑回归模型分析信用卡欺诈案例

    import pandas as pd import matplotlib.pyplot as plt import numpy as np%matplotlib inline #分类计数 count ...

最新文章

  1. ubuntu|利用system来新建文件夹
  2. 深度学习NN、CNN、RNN、和DNN你了解吗？
  3. ubuntu set ntpdate
  4. 软工作业3：词频统计
  5. Arduino 控制舵机
  6. android gradle 目录,Android Gradle：将目录列入文件
  7. SpringMVC学习总结（2）——SpringMVC返回json配置
  8. 【LeetCode笔记】53. 最大子序和（Java、动态规划）
  9. 2019新的启程新的规划
  10. 受疫情影响 AMD宣布退出CES线下展会
  11. 编译原理语义分析_编译原理 第一章 绪论
  12. 基于SpringBoot的在线音乐播放系统
  13. win7 64位下 memcached安装
  14. 人事管理系统 C语言,人事管理系统----C语言设计
  15. 拉姆达表达式启动一个线程
  16. 个人项目-20组刘鼎事后诸葛亮会议
  17. BlendMask 论文学习
  18. 有什么能测试安卓硬件的软件吗,手机硬件检测工具有哪些 总有一款适合你
  19. 23.2.7 点亮三个灯
  20. C# 代码 Unicode码和字符串相互转换

热门文章

  1. 腾讯YSDK米大师接入
  2. Linux用ASF没有文件路径,linux环境下使用mono运行asf挂卡
  3. Kubernets 安装dashboard
  4. 物联网无线通信——通往未来的连接
  5. Uniapp小程序登录和登录验证
  6. HTML一级菜单和二级菜单区别,一级菜单和二级菜单对不齐
  7. 19学习提升：gRPC源码中的那些优秀设计（上）
  8. sock5 UDP代理通信及dante-1.4.0 实现篇
  9. 【读取npy文件转换并保存为png】(批量保存且为灰度图)
  10. 【雕爷学编程】MicroPython动手做（10）——零基础学MaixPy之神经网络KPU