# importing basic libraries
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
Run to view results
# Reading dataset
df= pd.read_csv('./creditcard.csv')
df.head()
Run to view results
df.shape
Run to view results
df.info()
Run to view results
df.describe()
Run to view results
# checking null values
df.isnull().count()
Run to view results
# Checking the distribution of the class
classes= df['Class'].value_counts()
classes
Run to view results
#Creating fraudulent dataframe
data_fraud = df[df['Class'] == 1]
# Creating non fraudulent dataframe
data_non_fraud = df[df['Class'] == 0]
# Distribution plot
plt.figure(figsize=(8,5))
ax = sns.distplot(data_fraud['Time'],label='fraudulent',hist=False)
ax = sns.distplot(data_non_fraud['Time'],label='non fraudulent',hist=False)
ax.set(xlabel='Seconds elapsed between the transction and the first transction')
plt.show()
Run to view results
#We do not see any specific pattern for the fraudulent and non-fraudulent transctions with
#respect to Time. Hence, we can drop the Time column.
# Dropping the Time column
df.drop('Time', axis=1, inplace=True)
Run to view results
#Distribution plot
plt.figure(figsize=(8,5))
ax = sns.distplot(data_fraud['Amount'],label='fraudulent',hist=False)
ax = sns.distplot(data_non_fraud['Time'],label='non fraudulent',hist=False)
ax.set(xlabel='Transction Amount')
plt.show()
Run to view results
from sklearn.model_selection import train_test_split
X=df.drop(['Class'],axis=1)
Y=df['Class']
X_train,X_test,y_train,y_test= train_test_split(X,Y,train_size=0.8,test_size=0.2,random_state=100)
Run to view results
# we need to scale Amount col
from sklearn.preprocessing import StandardScaler
scaler=StandardScaler()
X_train['Amount']=scaler.fit_transform(X_train[['Amount']])
Run to view results
X_test['Amount']=scaler.transform(X_test[['Amount']])
Run to view results
# Plotting the distribution of the variables (skewness) of all the columns
cols = X_train.columns
k = 0
plt.figure(figsize=(17, 28))
for col in cols:
k = k + 1
plt.subplot(6, 5, k)
sns.distplot(X_train[col])
plt.title(col + ' Skewness: ' + str(X_train[col].skew()))
plt.tight_layout()
plt.show()
Run to view results
#Mitigate skweness with PowerTransformer
# Importing PowerTransformer
from sklearn.preprocessing import PowerTransformer
# Instantiate the powertransformer
pt = PowerTransformer(method='yeo-johnson', standardize=True,copy=False)
# Fit and transform the PT on training data
X_train[cols] = pt.fit_transform(X_train)
# Transform the test set
X_test[cols] = pt.transform(X_test)
# Plotting the distribution of the variables (skewness) of all the columns
k=0
plt.figure(figsize=(17,28))
for col in cols :
k=k+1
plt.subplot(6, 5,k)
sns.distplot(X_train[col])
plt.title(col+' '+str(X_train[col].skew()))
Run to view results
from sklearn.linear_model import LogisticRegression
from sklearn import metrics
from sklearn.metrics import f1_score
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
Run to view results
#Cross validation
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import GridSearchCV
Run to view results
# Creating KFold object with 5 splits
folds=KFold(n_splits=5,shuffle=True, random_state=4 )
# Specify params
params = {"C": [0.01, 0.1, 1, 10, 100, 1000]}
# Specifing score as recall as we are more focused on acheiving the higher sensitivity than the accuracy
model_cv = GridSearchCV(estimator = LogisticRegression(),
param_grid = params,
scoring= 'roc_auc',
cv = folds,
verbose = 1,
return_train_score=True)
# Fit the model
model_cv.fit(X_train, y_train)
Run to view results
# results of grid search CV
cv_results = pd.DataFrame(model_cv.cv_results_)
cv_results
Run to view results
# plot of C versus train and validation scores
plt.figure(figsize=(8, 6))
plt.plot(cv_results['param_C'], cv_results['mean_test_score'])
plt.plot(cv_results['param_C'], cv_results['mean_train_score'])
plt.xlabel('C')
plt.ylabel('roc_auc')
plt.legend(['test result', 'train result'], loc='upper left')
plt.xscale('log')
Run to view results
# Best score with best C
best_score = model_cv.best_score_
best_C = model_cv.best_params_['C']
print(" The highest test roc_auc is {0} at C = {1}".format(best_score,
best_C))
Run to view results
# Instantiate the model with best C
logistic_imb = LogisticRegression(C=0.01)
# Fit the model on the train set
logistic_imb_model = logistic_imb.fit(X_train, y_train)
Run to view results
# Predictions on the train set
y_train_pred = logistic_imb_model.predict(X_train)
Run to view results
# Confusion matrix
confusion = metrics.confusion_matrix(y_train, y_train_pred)
print(confusion)
TP = confusion[1,1] # true positive
TN = confusion[0,0] # true negatives
FP = confusion[0,1] # false positives
FN = confusion[1,0] # false negatives
# Accuracy
print("Accuracy:-",metrics.accuracy_score(y_train, y_train_pred))
# Sensitivity
print("Sensitivity:-",TP / float(TP+FN))
# Specificity
print("Specificity:-", TN / float(TN+FP))
# F1 score
print("F1-Score:-", f1_score(y_train, y_train_pred))
Run to view results
# classification_report
print(classification_report(y_train, y_train_pred))
Run to view results
# ROC Curve function
def draw_roc( actual, probs ):
fpr, tpr, thresholds = metrics.roc_curve( actual, probs,
drop_intermediate =
False )
auc_score = metrics.roc_auc_score( actual, probs )
plt.figure(figsize=(5, 5))
plt.plot( fpr, tpr, label='ROC curve (area = %0.2f)' % auc_score )
plt.plot([0, 1], [0, 1], 'k--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate or [1 - True Negative Rate]')
plt.ylabel('True Positive Rate')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()
return None
# Predicted probability
y_train_pred_proba = logistic_imb_model.predict_proba(X_train)[:,1]
# Plot the ROC curve
draw_roc(y_train, y_train_pred_proba)
Run to view results
# Prediction on the test set
y_test_pred = logistic_imb_model.predict(X_test)
# Confusion matrix
confusion = metrics.confusion_matrix(y_test, y_test_pred)
print(confusion)
TP = confusion[1,1] # true positive
TN = confusion[0,0] # true negatives
FP = confusion[0,1] # false positives
FN = confusion[1,0] # false negatives
# Accuracy
print("Accuracy:-",metrics.accuracy_score(y_test, y_test_pred))
# Sensitivity
print("Sensitivity:-",TP / float(TP+FN))
# Specificity
print("Specificity:-", TN / float(TN+FP))
# F1 score
print("F1-Score:-", f1_score(y_test, y_test_pred))
# classification_report
print(classification_report(y_test, y_test_pred))
Run to view results
# Predicted probability
y_test_pred_proba = logistic_imb_model.predict_proba(X_test)[:,1]
# Plot the ROC curve
draw_roc(y_test, y_test_pred_proba)
Run to view results
Run to view results