机器学习 — 信用卡欺诈预测

# 读取CSV文件的内容
import pandas as pd
data = pd.read_csv("creditcard.csv")
data.head()

Time	V1	V2	V3	V4	V5	V6	V7	V8	V9	...	V21	V22	V23	V24	V25	V26	V27	V28	Amount	Class
0	0.0	-1.359807	-0.072781	2.536347	1.378155	-0.338321	0.462388	0.239599	0.098698	0.363787	...	-0.018307	0.277838	-0.110474	0.066928	0.128539	-0.189115	0.133558	-0.021053	149.62	0
1	0.0	1.191857	0.266151	0.166480	0.448154	0.060018	-0.082361	-0.078803	0.085102	-0.255425	...	-0.225775	-0.638672	0.101288	-0.339846	0.167170	0.125895	-0.008983	0.014724	2.69	0
2	1.0	-1.358354	-1.340163	1.773209	0.379780	-0.503198	1.800499	0.791461	0.247676	-1.514654	...	0.247998	0.771679	0.909412	-0.689281	-0.327642	-0.139097	-0.055353	-0.059752	378.66	0
3	1.0	-0.966272	-0.185226	1.792993	-0.863291	-0.010309	1.247203	0.237609	0.377436	-1.387024	...	-0.108300	0.005274	-0.190321	-1.175575	0.647376	-0.221929	0.062723	0.061458	123.50	0
4	2.0	-1.158233	0.877737	1.548718	0.403034	-0.407193	0.095921	0.592941	-0.270533	0.817739	...	-0.009431	0.798278	-0.137458	0.141267	-0.206010	0.502292	0.219422	0.215153	69.99	0

5 rows × 31 columns

# 对‘Class’这一列绘制直方图
from matplotlib import pyplot as plt
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()

# 数据归一化
from sklearn.preprocessing import StandardScaler
data['normAmount'] = StandardScaler().fit_transform(data['Amount'].reshape(-1, 1))
data = data.drop(['Time','Amount'], axis = 1)
data.head()

	V1	V2	V3	V4	V5	V6	V7	V8	V9	V10	...	V21	V22	V23	V24	V25	V26	V27	V28	Class	normAmount
0	-1.359807	-0.072781	2.536347	1.378155	-0.338321	0.462388	0.239599	0.098698	0.363787	0.090794	...	-0.018307	0.277838	-0.110474	0.066928	0.128539	-0.189115	0.133558	-0.021053	0	0.244964
1	1.191857	0.266151	0.166480	0.448154	0.060018	-0.082361	-0.078803	0.085102	-0.255425	-0.166974	...	-0.225775	-0.638672	0.101288	-0.339846	0.167170	0.125895	-0.008983	0.014724	0	-0.342475
2	-1.358354	-1.340163	1.773209	0.379780	-0.503198	1.800499	0.791461	0.247676	-1.514654	0.207643	...	0.247998	0.771679	0.909412	-0.689281	-0.327642	-0.139097	-0.055353	-0.059752	0	1.160686
3	-0.966272	-0.185226	1.792993	-0.863291	-0.010309	1.247203	0.237609	0.377436	-1.387024	-0.054952	...	-0.108300	0.005274	-0.190321	-1.175575	0.647376	-0.221929	0.062723	0.061458	0	0.140534
4	-1.158233	0.877737	1.548718	0.403034	-0.407193	0.095921	0.592941	-0.270533	0.817739	0.753074	...	-0.009431	0.798278	-0.137458	0.141267	-0.206010	0.502292	0.219422	0.215153	0	-0.073403

5 rows × 30 columns

import numpy as np
X = data.ix[:, data.columns != 'Class']
y = data.ix[:, data.columns == 'Class']

# 在'Class’中少数数据点的数量
number_records_fraud = len(data[data.Class == 1])
fraud_indices = np.array(data[data.Class == 1].index)

# 获得正常‘Class’的索引
normal_indices = data[data.Class == 0].index

# 从我们选择的指数中，任意选择x个数
random_normal_indices = np.random.choice(normal_indices, number_records_fraud, replace = False)
random_normal_indices = np.array(random_normal_indices)

# 追加两个指标
under_sample_indices = np.concatenate([fraud_indices, random_normal_indices]) # 数组拼接

# 下采样数据集
under_sample_data = data.iloc[under_sample_indices,:] 
X_undersample = under_sample_data.ix[:,under_sample_data.columns != 'Class']
y_undersample = under_sample_data.ix[:,under_sample_data.columns == 'Class']

# 显示比率
normal_ratio = len(under_sample_data[under_sample_data.Class == 0])/len(under_sample_data)
fraud_ratio = len(under_sample_data[under_sample_data.Class == 1])/len(under_sample_data)
total_number = len(under_sample_data)
print("Percentage of normal transaction:", normal_ratio)
print("Percentage of fraud transaction:", fraud_ratio)
print("Total number of transaction in resample data:", total_number)

Percentage of normal transaction: 0.5
Percentage of fraud transaction: 0.5
Total number of transaction in resample data: 984
 

# 交叉验证
from sklearn.cross_validation 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("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))

# 下采样数据集
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) 召回率
from sklearn.linear_model import LogisticRegression
from sklearn.cross_validation 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):
    fold = KFold(len(y_train_data), 5, shuffle=False)
    
    # 不同的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 two 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, start=1):
            # 用一个确定的C参数调用逻辑回归模型
            lr = LogisticRegression(C = c_param, penalty='l1')
            
            # 使用训练数据拟合模型，在这个例子中，我们使用这交叉部分训练模型
            lr.fit(x_train_data.iloc[indices[0],:], y_train_data.iloc[indices[0],:].values.ravel())
            
            # 在训练集数据中，使用测试指标来预测值
            y_pred_undersample = lr.predict(x_train_data.iloc[indices[1],:].values)
            
            # 评估 the 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)
            
        # 这些 recall scores 的平均值，就是我们想要得到的指标
        results_table.ix[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'].idxmax()]['C_parameter']
    # 最后，我们可以验证那个C参数是最好的选择
    print("Best model to choose from cross validation is with C parameter = ", best_c)
            
    return best_c  
best_c = printing_Kfold_scores(X_train_undersample,y_train_undersample)

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

Iteration 1 :recall score =  0.931506849315
Iteration 2 :recall score =  0.917808219178
Iteration 3 :recall score =  1.0
Iteration 4 :recall score =  0.972972972973
Iteration 5 :recall score =  0.954545454545

Mean recall score  0.955366699202

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

Iteration 1 :recall score =  0.849315068493
Iteration 2 :recall score =  0.86301369863
Iteration 3 :recall score =  0.949152542373
Iteration 4 :recall score =  0.945945945946
Iteration 5 :recall score =  0.893939393939

Mean recall score  0.900273329876

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

Iteration 1 :recall score =  0.86301369863
Iteration 2 :recall score =  0.904109589041
Iteration 3 :recall score =  0.983050847458
Iteration 4 :recall score =  0.945945945946
Iteration 5 :recall score =  0.909090909091

Mean recall score  0.921042198033

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

Iteration 1 :recall score =  0.86301369863
Iteration 2 :recall score =  0.904109589041
Iteration 3 :recall score =  0.983050847458
Iteration 4 :recall score =  0.945945945946
Iteration 5 :recall score =  0.909090909091

Mean recall score  0.921042198033

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

Iteration 1 :recall score =  0.86301369863
Iteration 2 :recall score =  0.904109589041
Iteration 3 :recall score =  0.983050847458
Iteration 4 :recall score =  0.945945945946
Iteration 5 :recall score =  0.909090909091

Mean recall score  0.921042198033

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):
    # 此函数打印并绘制混淆矩阵
    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')
lr.fit(X_train_undersample, y_train_undersample.values.ravel())
y_pred_undersample = lr.predict(X_test_undersample.values)

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

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

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

best_c = printing_Kfold_scores(X_train, y_train)

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

Iteration 1 :recall score =  0.492537313433
Iteration 2 :recall score =  0.602739726027
Iteration 3 :recall score =  0.683333333333
Iteration 4 :recall score =  0.569230769231
Iteration 5 :recall score =  0.45

Mean recall score  0.559568228405

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

Iteration 1 :recall score =  0.567164179104
Iteration 2 :recall score =  0.616438356164
Iteration 3 :recall score =  0.683333333333
Iteration 4 :recall score =  0.584615384615
Iteration 5 :recall score =  0.525

Mean recall score  0.595310250644

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

Iteration 1 :recall score =  0.55223880597
Iteration 2 :recall score =  0.616438356164
Iteration 3 :recall score =  0.716666666667
Iteration 4 :recall score =  0.615384615385
Iteration 5 :recall score =  0.5625

Mean recall score  0.612645688837

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

Iteration 1 :recall score =  0.55223880597
Iteration 2 :recall score =  0.616438356164
Iteration 3 :recall score =  0.733333333333
Iteration 4 :recall score =  0.615384615385
Iteration 5 :recall score =  0.575

Mean recall score  0.61847902217

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

Iteration 1 :recall score =  0.55223880597
Iteration 2 :recall score =  0.616438356164
Iteration 3 :recall score =  0.733333333333
Iteration 4 :recall score =  0.615384615385
Iteration 5 :recall score =  0.575

Mean recall score  0.61847902217

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

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

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

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

lr = LogisticRegression(C=0.01, penalty='l1')
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]
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('Recall metric in the testing dataset:', 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)

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.972789115646
Recall metric in the testing dataset: 0.931972789116
Recall metric in the testing dataset: 0.87074829932
Recall metric in the testing dataset: 0.823129251701
Recall metric in the testing dataset: 0.748299319728
Recall metric in the testing dataset: 0.585034013605

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

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.2, 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])

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.890322580645
Iteration 2 :recall score =  0.894736842105
Iteration 3 :recall score =  0.968861347792
Iteration 4 :recall score =  0.957793385432
Iteration 5 :recall score =  0.958397907255

Mean recall score  0.934022412646

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

Iteration 1 :recall score =  0.890322580645
Iteration 2 :recall score =  0.894736842105
Iteration 3 :recall score =  0.970255615802
Iteration 4 :recall score =  0.959749837878
Iteration 5 :recall score =  0.960299403172

Mean recall score  0.93507285592

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

Iteration 1 :recall score =  0.890322580645
Iteration 2 :recall score =  0.894736842105
Iteration 3 :recall score =  0.969945778466
Iteration 4 :recall score =  0.960387333619
Iteration 5 :recall score =  0.95995867269

Mean recall score  0.935070241505

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

Iteration 1 :recall score =  0.890322580645
Iteration 2 :recall score =  0.894736842105
Iteration 3 :recall score =  0.970543321899
Iteration 4 :recall score =  0.959859750937
Iteration 5 :recall score =  0.960662116266

Mean recall score  0.93522492237

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

Iteration 1 :recall score =  0.890322580645
Iteration 2 :recall score =  0.894736842105
Iteration 3 :recall score =  0.970543321899
Iteration 4 :recall score =  0.958606742067
Iteration 5 :recall score =  0.959365142173

Mean recall score  0.934714925778

Best model to choose from cross validation is with C parameter =  10.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()