逻辑回归-二分类问题(信用卡欺诈分析)

最新推荐文章于 2022-06-03 19:40:04 发布
最新推荐文章于 2022-06-03 19:40:04 发布
阅读量897 收藏 6
点赞数
分类专栏： 机器学习 逻辑回归 文章标签： 逻辑回归 分类算法 数据分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41314786/article/details/104334563
版权

概述：
       本篇博文，使用逻辑回归进行银行卡欺诈分析，对于不均衡样本的数据预处理处理展示了两种方法：

  • 向下采样策略
  • 向上采样策略（文中使用SMOTE算法）

       然后对比了数据进行上述处理前后的效果对比。此外还对不同阈值对分类模型的影响进行了探讨。文中有完整的代码和图示。并有详细的中英文代码注释。
       涉及到的技术有：

  1. pandas库
  2. numpy库
  3. sklearn库
  4. imblearn库
  5. matplot库

下面是正文：

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

%matplotlib inline

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

#count_classes = pd.value_counts(data['Class'], sort = True).sort_index()  #

#把某列数据传入，自动计算各类型数据的数量
count_classes = pd.value_counts(data['Class'], sort = True)
count_classes.plot(kind = 'bar')
plt.title("Fraud class histogram")
plt.xlabel("Class")
plt.ylabel("Frequency")

Text(0, 0.5, 'Frequency')

png

#sklearn(库)中有数据预处理模块（processing） and 函数(StandardScaler)
from sklearn.preprocessing import StandardScaler 

# 将给定数据进行标准化，并作为新的一列存入data(新的列名“normAmount”)
# data['normAmount'] = StandardScaler().fit_transform(data['Amount'].reshape(-1, 1)) #已弃用,原因，data[]的类型是series，而data[].values类型是numpy.ndarray which support reshape operation
data['normAmount'] = StandardScaler().fit_transform(data['Amount'].values.reshape(-1,1))

# 丢弃指定的列
data = data.drop(['Time','Amount'],axis=1)
data.head()
V1V2V3V4V5V6V7V8V9V10...V21V22V23V24V25V26V27V28ClassnormAmount
0-1.359807-0.0727812.5363471.378155-0.3383210.4623880.2395990.0986980.3637870.090794...-0.0183070.277838-0.1104740.0669280.128539-0.1891150.133558-0.02105300.244964
11.1918570.2661510.1664800.4481540.060018-0.082361-0.0788030.085102-0.255425-0.166974...-0.225775-0.6386720.101288-0.3398460.1671700.125895-0.0089830.0147240-0.342475
2-1.358354-1.3401631.7732090.379780-0.5031981.8004990.7914610.247676-1.5146540.207643...0.2479980.7716790.909412-0.689281-0.327642-0.139097-0.055353-0.05975201.160686
3-0.966272-0.1852261.792993-0.863291-0.0103091.2472030.2376090.377436-1.387024-0.054952...-0.1083000.005274-0.190321-1.1755750.647376-0.2219290.0627230.06145800.140534
4-1.1582330.8777371.5487180.403034-0.4071930.0959210.592941-0.2705330.8177390.753074...-0.0094310.798278-0.1374580.141267-0.2060100.5022920.2194220.2151530-0.073403

5 rows × 30 columns

type(data[data.Class == 1].values) #Values 获取数据底层存储的是numpy数组

numpy.ndarray

#构造特征X 和 目标值 y
    #data.iloc[] can :
    # *Indexing both axes**

    # You can mix the indexer types for the index and columns. Use ``:`` to
    # select the entire axis.
X = data.iloc[:, data.columns != 'Class'] # 与x = data[data.columns!="Class"]不等价：We are left with two options: a single key, and a collection of keys,
y = data.iloc[:, data.columns == 'Class']


# Number of data points in the minority class
# 计算欺诈样本个数和对应的索引 indices(index的复数形式) 。注意：Values 获取数据底层存储的是numpy数组 Index 获取索引
number_records_fraud = len(data[data.Class == 1])
fraud_indices = np.array(data[data.Class == 1].index)

# Picking the indicates of the normal classes
#获取未被欺诈的样本的索引
normal_indices = data[data.Class == 0].index

# Out of the indicates we picked, randomly select "x" number (number_records_fraud)
random_normal_indices = np.random.choice(normal_indices, number_records_fraud, replace = False)
#下面一行代码操作其实多余，因为上一行的结果就是numpy.ndarray
random_normal_indices = np.array(random_normal_indices)

# Appending the 2 indicates: 
#将两个索引结合 concatenate:将一系列事情结合（联系）起来
under_sample_indices = np.concatenate([fraud_indices,random_normal_indices])

# Under sample dataset
#根据索引获取对应的数据，生成新的数据样本：under_sample_data
under_sample_data = data.iloc[under_sample_indices,:]

#从新样本中构造X 和 Y ，用于后面训练
X_undersample = under_sample_data.iloc[:, under_sample_data.columns != 'Class']
y_undersample = under_sample_data.iloc[:, under_sample_data.columns == 'Class']

# Showing ratio
#显示新样本中比率信息
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

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_undersample是根据向下根据采样策略从原始数据的一个子集
    #下采样策略：本案例，欺诈用户远远小于正常用户，所以从正常用户抽取和欺诈用户数量相同的数据，与欺诈用户共同构成子集
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

#Recall = TP/(TP+FN)
    #What is Recall(召回率):
    #是数据挖掘、机器学习和推荐系统中的评测指标之一，召回率是覆盖面的度量，度量有多个正例被分为正例，详情：https://www.cnblogs.com/Zhi-Z/p/8728168.html
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import KFold, cross_val_score  #KFold用于交叉验证  cross_val_score用于交叉验证评估结果 
from sklearn.metrics import confusion_matrix,recall_score,classification_report  #混淆矩阵  召回率评估 分类结果报告


def printing_Kfold_scores(x_train_data,y_train_data):
    fold = KFold(n_splits=5,shuffle=False) #切分成指定份数

    # Different C parameters
    #正则化惩罚项，图例：https://img-blog.csdnimg.cn/20200215102344486.png
        #下面的c_param_range就是惩罚力度，i.e.（c*惩罚项）
    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

    # the k-fold will give 2 lists: train_indices = indices[0], test_indices = indices[1]
    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(x_train_data.values),start=1):      #enumerate返回一个序号（可以指定start参数从几开始）和 可迭代参数

            # Call the logistic regression model with a certain C parameter
            # 创建一个逻辑回归模型，指定惩罚力度和惩罚项生成方法（l1 表示使用权重绝对值之和）
            lr = LogisticRegression(C = c_param, penalty = 'l1',solver= 'liblinear')

            # Use the training data to fit the model. In this case, we use the portion of the fold to train the model
            # with indices[0]. We then predict on the portion assigned as the 'test cross validation' with indices[1]
            # 使用x和y训练模型。注意X的行数和y的行数应该相同
            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
            # 传入x进行预测，生成预测值predicted y
            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_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.
        #设置第j个惩罚力度对应的平均召回率，更二维数组某个元素赋值一个道理，只不过列名是字符串而已。更c++中a[i][j]一个意思
        results_table.loc[j,'Mean recall score'] = np.mean(recall_accs,out=None)
        j += 1
        print('')
        print('Mean recall score ', np.mean(recall_accs))
        print('')

    print(results_table)
    print("")
    
    #idxmax函数返回Series的最大值的索引，注意，series内部一定要是数字类型。不能是object。因为object无法比较大小
    best_c = results_table.loc[results_table['Mean recall score'].astype('float64').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)
#best_c i.e 最佳的惩罚力度值


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

Iteration  1 : recall score =  0.9452054794520548
Iteration  2 : recall score =  0.9315068493150684
Iteration  3 : recall score =  1.0
Iteration  4 : recall score =  0.9594594594594594
Iteration  5 : recall score =  0.9848484848484849

Mean recall score  0.9642040546150135

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

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

Mean recall score  0.9009604576820737

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

Iteration  1 : recall score =  0.8493150684931506
Iteration  2 : recall score =  0.8904109589041096
Iteration  3 : recall score =  0.9830508474576272
Iteration  4 : recall score =  0.9459459459459459
Iteration  5 : recall score =  0.9090909090909091

Mean recall score  0.9155627459783485

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

Iteration  1 : recall score =  0.8493150684931506
Iteration  2 : recall score =  0.8904109589041096
Iteration  3 : recall score =  0.9830508474576272
Iteration  4 : recall score =  0.9594594594594594
Iteration  5 : recall score =  0.9090909090909091

Mean recall score  0.9182654486810511

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

Iteration  1 : recall score =  0.8493150684931506
Iteration  2 : recall score =  0.8904109589041096
Iteration  3 : recall score =  0.9830508474576272
Iteration  4 : recall score =  0.9594594594594594
Iteration  5 : recall score =  0.9090909090909091

Mean recall score  0.9182654486810511

   C_parameter Mean recall score
0         0.01          0.964204
1         0.10           0.90096
2         1.00          0.915563
3        10.00          0.918265
4       100.00          0.918265

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

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  #itertools 是python的迭代器模块，itertools提供的工具相当高效且节省内存。

# 创建&训练Logistic Regression模型并预测
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)
print("混淆矩阵:\n",cnf_matrix,"\n",type(cnf_matrix),"\n")
np.set_printoptions(precision=2)   #输出的精度，即小数点后位数，默认8

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()

混淆矩阵:
 [[138  11]
 [ 12 135]] 
 <class 'numpy.ndarray'> 

Recall metric in the testing dataset:  0.9183673469387755

png

# 以下用向下采样处理后的数据集训练模型，并使用原始数据中分割出来的测试集进行测试

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.9115646258503401

png

#下面不对原始数据作向下采样处理，并直接训练模型。分析模型和混淆矩阵
best_c = printing_Kfold_scores(X_train,y_train)

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

Iteration  1 : recall score =  0.4925373134328358
Iteration  2 : recall score =  0.6027397260273972
Iteration  3 : recall score =  0.6833333333333333
Iteration  4 : recall score =  0.5692307692307692
Iteration  5 : recall score =  0.45

Mean recall score  0.5595682284048672

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

Iteration  1 : recall score =  0.5671641791044776
Iteration  2 : recall score =  0.6164383561643836
Iteration  3 : recall score =  0.6833333333333333
Iteration  4 : recall score =  0.5846153846153846
Iteration  5 : recall score =  0.525

Mean recall score  0.5953102506435158

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

Iteration  1 : recall score =  0.5522388059701493
Iteration  2 : recall score =  0.6164383561643836
Iteration  3 : recall score =  0.7166666666666667
Iteration  4 : recall score =  0.6153846153846154
Iteration  5 : recall score =  0.5625

Mean recall score  0.612645688837163

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

Iteration  1 : recall score =  0.5522388059701493
Iteration  2 : recall score =  0.6164383561643836
Iteration  3 : recall score =  0.7333333333333333
Iteration  4 : recall score =  0.6153846153846154
Iteration  5 : recall score =  0.575

Mean recall score  0.6184790221704963

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

Iteration  1 : recall score =  0.5522388059701493
Iteration  2 : recall score =  0.6164383561643836
Iteration  3 : recall score =  0.7333333333333333
Iteration  4 : recall score =  0.6153846153846154
Iteration  5 : recall score =  0.575

Mean recall score  0.6184790221704963

   C_parameter Mean recall score
0         0.01          0.559568
1         0.10           0.59531
2         1.00          0.612646
3        10.00          0.618479
4       100.00          0.618479

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

lr = LogisticRegression(C = best_c, penalty = 'l1',solver='liblinear')
lr.fit(X_train,y_train.values.ravel())
y_pred_undersample = lr.predict(X_test.values)

# Compute confusion matrix
cnf_matrix = confusion_matrix(y_test,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.6190476190476191

png

# 下面尝试用向下采样处理后的数据集进行训练、并对比不同阈值对分类效果的影响

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)
print("每一个样本对应的预测值:\n",y_pred_undersample_proba[0:5,:])

# 定义一个阈值
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
    
    # Compute confusion matrix
    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]))

    # Plot non-normalized confusion matrix
    class_names = [0,1]
    plot_confusion_matrix(cnf_matrix
                          , classes=class_names
                          , title='Threshold >= %s'%i) 

每一个样本对应的预测值:
 [[0.57 0.43]
 [0.57 0.43]
 [0.   1.  ]
 [0.59 0.41]
 [0.54 0.46]]
Recall metric in the testing dataset:  1.0
Recall metric in the testing dataset:  1.0
Recall metric in the testing dataset:  1.0
Recall metric in the testing dataset:  0.9727891156462585
Recall metric in the testing dataset:  0.9183673469387755
Recall metric in the testing dataset:  0.8571428571428571
Recall metric in the testing dataset:  0.8299319727891157
Recall metric in the testing dataset:  0.7414965986394558
Recall metric in the testing dataset:  0.5850340136054422

png


#####################################向上采样策略：SMOTE方法 训练模型效果比较############################################


import pandas as pd

from imblearn.over_sampling import SMOTE   #SMOTE数据生成算法、即向上采样策略
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import train_test_split

credit_cards=pd.read_csv('creditcard.csv')

columns=credit_cards.columns
# The labels are in the last column ('Class'). Simply remove it to obtain features columns
# 删除最后一列，最后一列索引( len(columns)-1 )
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.2, 
                                                                            random_state=0)

len(labels_train)

227845

oversampler=SMOTE(random_state=0)
# 将训练数据传入，算法将会根据label值自动平衡并生成新的数据
os_features,os_labels=oversampler.fit_sample(features_train,labels_train)


len(os_labels[os_labels==1])

227454

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.8903225806451613
Iteration  2 : recall score =  0.8947368421052632
Iteration  3 : recall score =  0.9688170853159235
Iteration  4 : recall score =  0.9578263593497544
Iteration  5 : recall score =  0.9584198898671151

Mean recall score  0.9340245514566435

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

Iteration  1 : recall score =  0.8903225806451613
Iteration  2 : recall score =  0.8947368421052632
Iteration  3 : recall score =  0.9704105344694036
Iteration  4 : recall score =  0.9599366900781482
Iteration  5 : recall score =  0.9605631945131401

Mean recall score  0.9351939683622232

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

Iteration  1 : recall score =  0.8903225806451613
Iteration  2 : recall score =  0.8947368421052632
Iteration  3 : recall score =  0.9705211906606175
Iteration  4 : recall score =  0.9596069509018367
Iteration  5 : recall score =  0.9607830206306811

Mean recall score  0.9351941169887119

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

Iteration  1 : recall score =  0.8903225806451613
Iteration  2 : recall score =  0.8947368421052632
Iteration  3 : recall score =  0.9705211906606175
Iteration  4 : recall score =  0.9601894901133203
Iteration  5 : recall score =  0.9601455248898122

Mean recall score  0.9351831256828349

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

Iteration  1 : recall score =  0.8903225806451613
Iteration  2 : recall score =  0.8947368421052632
Iteration  3 : recall score =  0.970366271992918
Iteration  4 : recall score =  0.9594091073960497
Iteration  5 : recall score =  0.960530220595509

Mean recall score  0.9350730045469803

   C_parameter Mean recall score
0         0.01          0.934025
1         0.10          0.935194
2         1.00          0.935194
3        10.00          0.935183
4       100.00          0.935073

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

lr = LogisticRegression(C = best_c, penalty = 'l1')
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)

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.90099009901

png

#Summary
# 对于样本不均匀的情况：
#  1、 利用下采样策略
#  2、利用SMOTE数据生成算法
#建议：数据利用越多越好。优先使用SMOTE数据生成算法
TransPlus
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习中的数学原理——二分类问题
weixin_63866037的博客
12-31 5688
​ 今天是2022年的最后一天，提前祝大家新年快乐！这个专栏主要是用来分享一下我在机器学习中的学习笔记及一些感悟，也希望对你的学习有帮助哦！感兴趣的小伙伴欢迎私信或者评论区留言！这一篇就更新一下《白话机器学习中的数学——二分类问题》！ ​
使用逻辑回归对信用卡诈骗分析
weixin_46278697的博客
02-29 551
此次的数据集包括了 2013 年 9 月份两天时间内的信用卡交易数据，284807 笔交易中，一共有 492 笔 是欺诈行为。输入数据一共包括了 28 个特征 V1，V2，……V28 对应的取值，以及交易时间 Time 和交易金额 Amount。为了保护数据隐私，我们不知道 V1 到 V28 这些特征代表的具体含 义，只知道这 28 个特征值是通过 PCA 变换得到的结果。另外字段 Class 代...
逻辑回归-信用卡欺诈检测代码调试问题（二分类）
kind_begin的博客
11-21 736
# conda list # conda install nump # anaconda search -t conda sklearn # anaconda show # pip install sklearn # pip install imblearn 不平衡模块 以上是安装一些库的搜索或安装命令 %matplotlib作用 是在使用jupyter notebook 或...
机器学习，信用卡项目（二分类问题）完整代码 + 详细注释
zy的博客
06-03 527
机器学习，二分类问题
6.逻辑回归项目实战-信用卡欺诈检测代码调试
weixin_47038938的博客
04-22 770
信用卡欺诈检测 《跟着迪哥学Python数据分析与机器学习实战》 报错一 data['normAmount']=StandardScaler().fit_transform(data['Amount'].reshape(-1,1)) AttributeError: ‘Series’ object has no attribute ‘reshape’ 修改 data是dataFrame数据结构，data[‘Amount’]取dataframe的一个column，输出格式为series，series不具有r
人工智能-机器学习-逻辑回归-利用Logistic回归实现信用卡欺诈检测
06-29
使用Logstic Regression对信用卡欺诈检测进行分类 步骤以及一些需要注意的点 特征工程 样本不均衡问题的解决(降采样以及过采样两种方式) 下采样策略 交叉验证(充分利用数据，使模型更具说服力) 模型评估方法(分类...
基于逻辑回归的信用卡欺诈检测.pdf
07-18
详细介绍了基于逻辑回归的信用卡欺诈检测 包括代码共30页
逻辑回归信用卡欺诈检测
04-27
信用卡欺诈检测代码，包含数据
逻辑回归+信用卡欺诈检测.rar
12-11
共有两个压缩包，包括逻辑回归以及信用卡欺诈，首先是利用梯度下降法求解逻辑回归，另外一个压缩包是逻辑回归在信用卡欺诈中的实际应用
�信用卡�欺诈检测--逻辑回归 - Kesci.com1
最新发布
08-04
1.数据探索 2. 数据预处 3. 建模与模型评估 1. 数据探索 2. 数据预处
Sales_TransactionsDatasetWeekly数据挖掘
02-28
Sales_TransactionsDatasetWeekly数据挖掘，包括数据文件和python源代码，具备Anaconda即可运行
Python数据分析与机器学习实战笔记(10) - 项目实战（交易数据异常检测）
grinningGrace的博客
03-02 1063
文章目录项目实战（交易数据异常检测）1. 信用卡欺诈检测1.1 任务流程：1.2 主要解决问题：2. 项目总结 项目实战（交易数据异常检测） 1. 信用卡欺诈检测 基于信用卡交易记录数据建立分类模型来预测哪些交易记录是异常的哪些是正常的。 1.1 任务流程： a. 加载数据，观察问题 b. 针对问题给出解决方案 c. 数据集切分 d. 评估方法对比 e. 逻辑回归模型 f. 建模结果分析 g. ...
交叉验证
weixin_45271076的博客
08-04 171
def printing_Kfold_scores(x_train_data, y_train_data): fold = KFold(5, shuffle=False) c_param_range = [0.01,0.1,1,10,100] recall_accs=list() results_table=pd.DataFrame(index=range(len(...
python 机器学习实战：信用卡欺诈异常值检测
热门推荐
dengheCSDN的博客
01-16 1万+
今晚又实战了一个小案例，把它总结出来：有些人利用信用卡进行诈骗等活动，如何根据用户的行为，来判断该用户的信用卡账单涉嫌欺诈呢？数据集见及链接：  在这个数据集中，由于原始数据有一定的隐私，因此，每一列（即特征）的名称并没有给出。     一开始，还是导入库： import numpy as np import pandas as pd import matplotlib.pyplot as p
信用卡欺诈检测正确代码
utacxl的博客
02-20 820
平台：win10，anaconda，python3.7.3版本，scikit-learn0.20.3版本。 《跟着迪哥学Python数据分析与机器学习实战》一书中的信用卡欺诈检测案例，书中的源代码需要做如下改动才能正确执行（标红的代码是需要额外添加和修改的）： from sklearn.model_selection import KFoldfrom sklearn.linear_model ...
信用卡欺诈行为逻辑回归数据分析-大数据ML样本集案例实战
weixin_33873846的博客
12-08 495
版权声明：本套技术专栏是作者（秦凯新）平时工作的总结和升华，通过从真实商业环境抽取案例进行总结和分享，并给出商业应用的调优建议和集群环境容量规划等内容，请持续关注本套博客。QQ邮箱地址：1120746959@qq.com，如有任何学术交流，可随时联系。 1 信用卡欺诈行为案例集预处理 import pandas as pd import matplotlib.pyplot as plt impor...
信用卡欺诈检测--Logistic回归算法应用
Arthur_Holmes的博客
08-10 2321
主要内容1 数据分析和数据处理2 数据均衡处理2.1 方案一：Undersample2.2 方案二：Oversample3 问题记录4 知识技能归纳Part 1 数据分析和数据处理此项目中数据量比较大，约有20多万条数据，需要利用python中的pandas库将数据导入，导入后数据格式为DataFrame，代码如下：import pandas as pd import matplotlib.pyp...
人工智能学习笔记——案例实战信用卡欺诈检测（逻辑回归）
唯恋殊雨的博客
06-13 1912
点击下载数据集import pandas as pd import matplotlib.pyplot as plt import numpy as np %matplotlib inlinedata = pd.read_csv("creditcard.csv") data.head()#查看样本是否平衡count_classes = pd.value_counts(data['Class'],...
scikit-learn 逻辑回归实现信用卡欺诈检测
szfhy的博客
09-14 1534
读书笔记 import numpy as np import pandas as pd import matplotlib.pyplot as plt data = pd.read_csv('creditcard.csv') #data.head(10) print (data.shape) count_class = pd.value_counts(data['Class'],s...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值