模型可视化>> credit-card>> 返回
项目作者： Sudev18

项目描述 ：
Credit Card Fraud Detection algorithm using smote , confusion matrix, correlation matrix, density plots and ROC-AUC curve . Model - Logistic Regression, Knn, Isolation Forest
高级语言：
项目地址: git://github.com/Sudev18/credit-card.git
创建时间： 2020-12-11T00:16:31Z
项目社区：https://github.com/Sudev18/credit-card
开源协议：
下载


credit-card

Credit Card Fraud Detection algorithm using smote , confusion matrix, correlation matrix, density plots and ROC-AUC curve

!/usr/bin/env python3

-- coding: utf-8 --

!/usr/bin/env python3

-- coding: utf-8 --

!/usr/bin/env python3

-- coding: utf-8 --

“””
Created on Thu Dec 10 17:02:55 2020

@author: sudevpradhan
CREDIT CARD FRAUD DETECTION
Data sets from https://www.kaggle.com/mlg-ulb/creditcardfraud
“””

import numpy as np # linear algebra
import pandas as pd # data processing, CSV file I/O
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
from sklearn.model_selection import GridSearchCV
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, auc, roc_curve
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from imblearn.over_sampling import SMOTE
from sklearn.metrics import plot_confusion_matrix
from mpl_toolkits.mplot3d import Axes3D
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score, roc_curve, accuracy_score, precision_recall_curve, classification_report, confusion_matrix

from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import IsolationForest

from xgboost import XGBClassifier

Other Libraries

from imblearn.pipeline import make_pipeline as imbalanced_make_pipeline
from imblearn.under_sampling import TomekLinks
from imblearn.under_sampling import NearMiss
from imblearn.metrics import classification_report_imbalanced
from sklearn.pipeline import make_pipeline
from sklearn.neighbors import LocalOutlierFactor
from sklearn.svm import OneClassSVM
from sklearn.utils import resample
from sklearn.preprocessing import StandardScaler, RobustScaler, LabelEncoder
from sklearn.model_selection import cross_val_score, cross_val_predict, GridSearchCV, KFold, StratifiedKFold, train_test_split
from sklearn.manifold import TSNE
from sklearn.decomposition import PCA, TruncatedSVD
from sklearn.model_selection import StratifiedShuffleSplit as sss
import warnings
warnings.filterwarnings(“ignore”)

Load the Dataset

data = pd.read_csv(‘creditcard.csv’)

df = pd.read_csv(‘creditcard.csv’)
print(df.shape)
df.head()

df.info()

df.describe()

class_names = {0:’Not Fraud’, 1:’Fraud’}
print(df.Class.value_counts().rename(index = class_names))

fig = plt.figure(figsize = (15, 12))

def imbalance():

  1. #Print the value counts of frauds and non-frauds in the data
  2. print(data['Class'].value_counts())
  4. #Calculate the percentage of Fraud and Non-fraud transactions.
  5. print('Valid Transactions: ', round(data['Class'].value_counts()[0]/len(data) * 100,2)
  6.       , '% of the dataset')
  8. print('Fraudulent Transactions: ', round(data['Class'].value_counts()[1]/len(data) * 100,2)
  9.       , '% of the dataset')
  11. #Visualizing the class Imbalance
  12. colors = ['blue','red']
  13. sns.countplot('Class', data=data, palette=colors)

def data_visualisation():

  1. #Distribution of the amount and time in the data sets
  2. fig, ax = plt.subplots(1, 2, figsize=(16,4))
  3. fig.suptitle('Distribution', fontsize=16)
  4. amount_val = df['Amount'].values
  5. time_val = df['Time'].values
  6. colors = ["#0101DF", "#DF0101"]
  7. sns.distplot(amount_val, ax=ax[0], color=colors[0])
  8. ax[0].set_title('Distribution of Transaction Amount')
  9. ax[0].set_xlim([min(amount_val), max(amount_val)])
  11. sns.distplot(time_val, ax=ax[1], color=colors[1])
  12. ax[1].set_title('Distribution of Transaction Time')
  13. ax[1].set_xlim([min(time_val), max(time_val)])
  14. plt.show()
  16. #fraud amount and non fraud amount
  17. fig, ax = plt.subplots(1, 2, figsize=(16,4), sharex=True)
  18. fig.suptitle('Amount/transaction', fontsize=16)
  19. colors = ["#0101DF", "#DF0101"]
  21. sns.distplot(df[df['Class']==1].Amount, ax=ax[0], color=colors[0])
  22. plt.xlabel('Amount')
  23. plt.ylabel('Number of Transactions')
  24. ax[0].set_title('Distribution of Transaction Amount (Fraud)')    
  25. sns.distplot(df[df['Class']==0].Amount, ax=ax[1], color=colors[1])
  26. ax[1].set_title('Distribution of Transaction Amount (Valid)')
  27. plt.xlabel('Amount')
  28. plt.ylabel('Number of Transactions')
  29. plt.xlim((0, 20000))
  30. plt.yscale('log')
  31. plt.show()
  34. # scatter plot of the fraudulent and non fraudulent data against time   
  35. fig, ax = plt.subplots(1, 2, figsize=(16,4), sharex=True)
  36. fig.suptitle('Time of transaction vs Amount', fontsize=16)
  37. colors = ["#0101DF", "#DF0101"]
  38. ax[0].scatter(df[df['Class']==1].Time, df[df['Class']==1].Amount)
  39. ax[0].set_title('Fraud')
  40. plt.xlabel('Time')
  41. plt.ylabel('Amount')
  42. ax[1].scatter(df[df['Class']==0].Time, df[df['Class']==0].Amount)
  43. ax[1].set_title('Valid')
  44. plt.xlabel('Time')
  45. plt.ylabel('Amount')
  46. plt.show()

def plotCorrelationMatrix():
features = df.columns.values

  1. correlation_matrix = df.corr()
  2. fig = plt.figure(figsize=(12,8))
  3. fig.suptitle('Correlation Plot', fontsize=16)
  4. sns.heatmap(correlation_matrix,vmax=0.8,square = True)
  5. plt.show()
  6. correlations = df[features].corr().abs().unstack().sort_values(kind="quicksort").reset_index()
  7. correlations = correlations[correlations['level_0'] != correlations['level_1']]
  8. print("Top 6 correlated features")
  9. print(correlations.head(5)) #
  10. print("\n Least 6 correlated features")
  11. print(correlations.tail(5))

def preprocessing(X,y):

  1. #Splitting the Data
  4. X_train, X_test, y_train, y_test =  train_test_split(X, y, test_size=0.3, random_state=0)
  6. print("Transactions in X_train dataset: ", X_train.shape)
  7. print("Transaction classes in y_train dataset: ", y_train.shape)
  9. print("Transactions in X_test dataset: ", X_test.shape)
  10. print("Transaction classes in y_test dataset: ", y_test.shape)
  12. #Feature Scaling
  14. scaler_amount = StandardScaler()
  15. scaler_time = StandardScaler()
  17. #   normalising
  18. X_train['normAmount'] = scaler_amount.fit_transform(X_train['Amount'].values.reshape(-1, 1))
  20. X_test['normAmount'] = scaler_amount .transform(X_test['Amount'].values.reshape(-1, 1))
  22. X_train['normTime'] = scaler_time .fit_transform(X_train['Time'].values.reshape(-1, 1))
  24. X_test['normTime'] = scaler_time .transform(X_test['Time'].values.reshape(-1, 1))
  27. X_train = X_train.drop(['Time', 'Amount'], axis=1)
  28. X_test = X_test.drop(['Time', 'Amount'], axis=1)
  30. X_train.head()
  31. return X_train, X_test, y_train, y_test

def distribution(): 

  1. raw_df= data
  2. cleaned_df = raw_df.copy()
  4. # You don't want the `Time` column.
  5. cleaned_df.pop('Time')
  7. # The `Amount` column covers a huge range. Convert to log-space.
  8. eps=0.001 # 0 => 0.1¢
  9. cleaned_df['Log Ammount'] = np.log(cleaned_df.pop('Amount')+eps)
  11. # Use a utility from sklearn to split and shuffle our dataset.
  12. train_df, test_df = train_test_split(cleaned_df, test_size=0.2)
  13. train_df, val_df = train_test_split(train_df, test_size=0.2)
  15. # Form np arrays of labels and features.
  16. train_labels = np.array(train_df.pop('Class'))
  17. bool_train_labels = train_labels != 0
  18. val_labels = np.array(val_df.pop('Class'))
  19. test_labels = np.array(test_df.pop('Class'))
  21. train_features = np.array(train_df)
  22. val_features = np.array(val_df)
  23. test_features = np.array(test_df)
  25. scaler = StandardScaler()
  26. train_features = scaler.fit_transform(train_features)
  28. val_features = scaler.transform(val_features)
  29. test_features = scaler.transform(test_features)
  31. train_features = np.clip(train_features, -5, 5)
  32. val_features = np.clip(val_features, -5, 5)
  33. test_features = np.clip(test_features, -5, 5)
  36. print('Training labels shape:', train_labels.shape)
  37. print('Validation labels shape:', val_labels.shape)
  38. print('Test labels shape:', test_labels.shape)
  40. print('Training features shape:', train_features.shape)
  41. print('Validation features shape:', val_features.shape)
  42. print('Test features shape:', test_features.shape)
  43. pos_df = pd.DataFrame(train_features[ bool_train_labels], columns = train_df.columns)
  44. neg_df = pd.DataFrame(train_features[~bool_train_labels], columns = train_df.columns)
  46. sns.jointplot(pos_df['V5'], pos_df['V6'],
  47.               kind='hex', xlim = (-5,5), ylim = (-5,5))
  48. plt.suptitle("Positive distribution")
  50. sns.jointplot(neg_df['V5'], neg_df['V6'],
  51.               kind='hex', xlim = (-5,5), ylim = (-5,5))
  52. _ = plt.suptitle("Negative distribution")

def using_smote(X_train, X_test, y_train, y_test): 

  1. print("Before over-sampling:\n", y_train['Class'].value_counts())
  3. sm = SMOTE()
  5. X_train_res, y_train_res = sm.fit_sample(X_train, y_train['Class'])
  7. print("After over-sampling:\n", y_train_res.value_counts())
  9. #Build the Model
  12. parameters = {"penalty": ['l1', 'l2'], 'C': [0.001, 0.01, 0.1, 1, 10, 100, 1000]}
  13. lr = LogisticRegression()
  14. clf = GridSearchCV(lr, parameters, cv=5, verbose=5, n_jobs=3)
  15. k = clf.fit(X_train_res, y_train_res)
  17. print(k.best_params_)
  19. #Evaluate the Model
  20. lr_gridcv_best = clf.best_estimator_
  22. y_test_pre = lr_gridcv_best.predict(X_test)
  24. cnf_matrix_test = confusion_matrix(y_test, y_test_pre)
  26. print("Recall metric in the test dataset:", (cnf_matrix_test[1,1]/(cnf_matrix_test[1,0]+cnf_matrix_test[1,1] )))
  28. y_train_pre = lr_gridcv_best.predict(X_train_res)
  30. cnf_matrix_train = confusion_matrix(y_train_res, y_train_pre)
  32. print("Recall metric in the train dataset:", (cnf_matrix_train[1,1]/(cnf_matrix_train[1,0]+cnf_matrix_train[1,1] )))
  34. print(classification_report(y_test,y_test_pre))
  37. return k,X_test, y_test, X_train_res, y_train_res

def confusion(k,X_test, y_test, X_train_res, y_train_res): 

  1. #Visualize the Confusion Matrix
  3. plt.style.use('seaborn')
  4. class_names = ['Not Fraud', 'Fraud']
  5. plot_confusion_matrix(k, X_test, y_test,  values_format = '.5g', display_labels=class_names)
  6. plt.title("Test data Confusion Matrix")
  7. plt.show()
  8. plot_confusion_matrix(k, X_train_res, y_train_res,  values_format = '.5g', display_labels=class_names) 
  9. plt.title("Oversampled Train data Confusion Matrix")
  10. plt.show()

def ROC(X_test,y_test):
y_k = k.decision_function(X_test)

  1. fpr, tpr, thresholds = roc_curve(y_test, y_k)
  3. roc_auc = auc(fpr, tpr)
  4. print("ROC-AUC:", roc_auc)
  5. # Now visualize the roc_auc curve.
  6. plt.style.use('seaborn')
  7. plt.title('Receiver Operating Characteristic')
  8. plt.plot(fpr, tpr, 'b',label='AUC = %0.3f'% roc_auc)
  9. plt.legend(loc='lower right')
  10. plt.plot([0,1],[0,1],'r--')
  11. plt.xlim([-0.1,1.0])
  12. plt.ylim([-0.1,1.01])
  13. plt.ylabel('True Positive Rate')
  14. plt.xlabel('False Positive Rate')
  15. plt.show()

def plotScatterMatrix(df, plotSize, textSize):
df = df.select_dtypes(include =[np.number]) # keep only numerical columns

  1. # Remove rows and columns that would lead to df being singular
  2. df = df.dropna('columns')
  3. df = df[[col for col in df if df[col].nunique() > 1]] # keep columns where there are more than 1 unique values
  4. columnNames = list(df)
  5. if len(columnNames) > 10: # reduce the number of columns for matrix inversion of kernel density plots
  6.     columnNames = columnNames[:10]
  7. df = df[columnNames]
  8. ax = pd.plotting.scatter_matrix(df, alpha=0.75, figsize=[plotSize, plotSize], diagonal='kde')
  9. corrs = df.corr().values
  10. for i, j in zip(*plt.np.triu_indices_from(ax, k = 1)):
  11.     ax[i, j].annotate('Corr. coef = %.3f' % corrs[i, j], (0.8, 0.2), xycoords='axes fraction', ha='center', va='center', size=textSize)
  12. plt.suptitle('Scatter and Density Plot')
  13. plt.show()

def regression():

  1. log_reg_params = {"penalty": ['l1', 'l2'], 'C': [0.01, 0.1, 1]}
  2. grid_log_reg = GridSearchCV(LogisticRegression(), log_reg_params)
  3. grid_log_reg.fit(X_train, y_train)
  4. log_reg = grid_log_reg.best_estimator_
  5. log_reg_score = cross_val_score(log_reg, X_train, y_train, cv=5)
  6. print('Logistic Regression Cross Validation Score: ', round(log_reg_score.mean() * 100, 2).astype(str) + '%')
  8. from sklearn.model_selection import ShuffleSplit
  9. from sklearn.model_selection import learning_curve
  11. '''def plot_learning_curve(estimator1, X, y, ylim=None, cv=None,
  12.                         n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5)):
  13.     f, ((ax1)) = plt.subplots(1,1, figsize=(16,8), sharey=True)
  14.     if ylim is not None:
  15.         plt.ylim(*ylim)
  16.         train_sizes, train_scores, test_scores = learning_curve(
  17.             estimator1, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes)
  18.         train_scores_mean = np.mean(train_scores, axis=1)
  19.         train_scores_std = np.std(train_scores, axis=1)
  20.         test_scores_mean = np.mean(test_scores, axis=1)
  21.         test_scores_std = np.std(test_scores, axis=1)
  22.         ax1.fill_between(train_sizes, train_scores_mean - train_scores_std,
  23.                          train_scores_mean + train_scores_std, alpha=0.1,
  24.                          color="#ff9124")
  25.         ax1.fill_between(train_sizes, test_scores_mean - test_scores_std,
  26.                          test_scores_mean + test_scores_std, alpha=0.1, color="#2492ff")
  27.         ax1.plot(train_sizes, train_scores_mean, 'o-', color="#ff9124",
  28.                  label="Training score")
  29.         ax1.plot(train_sizes, test_scores_mean, 'o-', color="#2492ff",
  30.                  label="Cross-validation score")
  31.         ax1.set_title("Logistic Regression Learning Curve", fontsize=14)
  32.         ax1.set_xlabel('Training size (m)')
  33.         ax1.set_ylabel('Score')
  34.         ax1.grid(True)
  35.         ax1.legend(loc="best")
  36.         return plt'''
  38. cv = ShuffleSplit(n_splits=100, test_size=0.2, random_state=21)
  39. #plot_learning_curve(log_reg, X_train, y_train, (0.87, 1.01), cv=cv, n_jobs=4)
  40. log_reg_pred = cross_val_predict(log_reg, X_train, y_train, cv=5,
  41.                          method="decision_function")
  43. print('Logistic Regression: ', roc_auc_score(y_train, log_reg_pred))

def Isolation_forest_algorithm():

  1. classifiers = {
  2.     "Isolation Forest":IsolationForest(n_estimators=100, max_samples=len(X), verbose=0)}
  4. for i, (clf_name,clf) in enumerate(classifiers.items()):
  5.     clf.fit(X_train)
  6.     scores_prediction = clf.decision_function(X_train)
  7.     y_pred = clf.predict(X_train)
  8.     y_pred[y_pred == 1] = 0
  9.     y_pred[y_pred == -1] = 1
  10.     n_errors = (y_pred != y_train).sum()
  12.     print("{}: {}".format(clf_name,n_errors))
  13.     print("Accuracy Score :")
  14.     print(accuracy_score(y_train,y_pred))
  15.     print("Classification Report :")
  16.     print(classification_report(y_train,y_pred))
  17.     print('\n')

def knn():
knn = KNeighborsClassifier(n_neighbors = 5,n_jobs=16)
knn.fit(X_train,y_train)
k1=knn.fit(X_train,y_train)
print(“”)
print(“knn classifier created”)
score = knn.score(X_test,y_test)
print(“knn model score-“)
print(score)
pred = knn.predict(X_test)
print(classification_report(y_test,pred))
matrix=confusion_matrix(y_test,pred)
print(matrix)
plt.figure(figsize = (10,7))
sns.heatmap(matrix,annot=True)
prob=knn.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, prob[:,1])
plt.figure(figsize=(10,6))
plt.plot([0, 1], [0, 1], linestyle=’—‘)
plt.plot(fpr, tpr, marker=’.’)
plt.annotate(‘Minimum ROC Score of 50% \n (This is the minimum score to get)’, xy=(0.5, 0.5), xytext=(0.6, 0.3),
arrowprops=dict(facecolor=’#6E726D’, shrink=0.05),
)
plt.title(“ROC curve”)
plt.xlabel(‘false positive rate’)
plt.ylabel(‘true positive rate’)
plt.show()

MAIN FUNCTION

Exploring the Class Column

X = data.loc[:, data.columns != ‘Class’]
y = data.loc[:, data.columns == ‘Class’]

nRowsRead = 1000
df1 = pd.read_csv(‘creditcard.csv’, delimiter=’,’, nrows = nRowsRead)
df1.dataframeName = ‘creditcard.csv’
nRow, nCol = df1.shape
print(f’There are {nRow} rows and {nCol} columns’)

FUNCTION CALL

imbalance()
X_train, X_test, y_train, y_test=preprocessing(X,y)
k,X_test, y_test, X_train_res, y_train_res=using_smote(X_train, X_test, y_train, y_test)
data_visualisation()
distribution()
plotCorrelationMatrix()
plotScatterMatrix(df1, 20, 10)

confusion(k,X_test, y_test, X_train_res, y_train_res)
ROC(X_test, y_test)
knn()
X_train, X_test, y_train, y_test=preprocessing(X,y)
X_train = X_train.replace([np.inf, -np.inf], np.nan).fillna(0)
X_train = X_train.values
X_test = X_test.replace([np.inf, -np.inf], np.nan).fillna(0)
X_test = X_test.values
y_train = y_train.replace([np.inf, -np.inf], np.nan).fillna(0)
y_train = y_train.values
y_test = y_test.replace([np.inf, -np.inf], np.nan).fillna(0)
y_test = y_test.values
Isolation_forest_algorithm()

activate this code separetly, for the regression plot

‘’’regression()’’’