-
Notifications
You must be signed in to change notification settings - Fork 0
/
copy_of_updated_ccfd.py
273 lines (190 loc) · 31.1 KB
/
copy_of_updated_ccfd.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
# -*- coding: utf-8 -*-
"""Copy of Updated_ccfd.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1BsTodi2r1OTSgEmKP_zhz70JZzrw3-gm
# **Credit Card Fraud Detection**
**Importing Libraries**
"""
from google.colab import drive
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, recall_score,precision_score
from sklearn.metrics import confusion_matrix,classification_report
from sklearn.metrics import plot_confusion_matrix
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn import model_selection
from sklearn import tree
from sklearn.neighbors import KNeighborsClassifier
"""**Adding Files and loading dataset into dataframe**"""
drive.mount('/content/drive')
df = pd.read_csv('/content/drive/My Drive/creditcard.csv')
"""**First five data of dataset**"""
df.head()
"""**last five data of dataset**"""
df.tail()
"""**Information of dataset**"""
df.info()
"""**Check for the missing values in each column**"""
df.isnull().sum()
"""**Distribution of normal and fraud transactions**"""
df['Class'].value_counts()
"""dataset highly unblanced..
0 normal transanction, 1 fraudulant transanction
**Separating the data**
"""
non_fraud=df[df.Class == 0]
fraud=df[df.Class == 1]
print(non_fraud.shape)
print(fraud.shape)
"""**Comparing the values of both normal and fraud transactions**"""
df.groupby('Class').mean()
"""# **Under sampling**
Building a sample dataset which will be containing similar distribution of normal transactions and Fraudulent Transactions
Number of Fraudulent Transactions : 492
"""
non_fraud_sample = non_fraud.sample(n=492)
new_dataset = pd.concat([non_fraud_sample,fraud],axis=0)
new_dataset.head()
new_dataset.info()
new_dataset.tail()
new_dataset['Class'].value_counts()
X=new_dataset.drop(columns='Class',axis=1)
Y=new_dataset['Class']
print(X)
print(Y)
"""**Splitting data to test and train**"""
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.25, stratify=Y, random_state=1)
print(X.shape, X_train.shape, X_test.shape)
"""# **KNeighbors Classifier**
K- NN is a Supervised Learning Technique which assumes the similarity b/w new and avaialble data and put the new data into the category that is most similar to the available categories.
"""
classifier = KNeighborsClassifier()
classifier.fit(X_train, Y_train)
X_test_prediction = classifier.predict(X_test)
X_train_prediction = classifier.predict(X_train)
"""Train Data
"""
print(confusion_matrix(Y_train, X_train_prediction))
plot_confusion_matrix(classifier,X_train,Y_train)
plt.show()
print(classification_report(Y_train, X_train_prediction))
print('Accuracy Using KNeighbors classifier on Train Data is ',accuracy_score(X_train_prediction,Y_train)*100)
print(confusion_matrix( Y_test,X_test_prediction))
plot_confusion_matrix(classifier,X_test,Y_test)
plt.show()
print(classification_report(Y_test, X_test_prediction))
print('KNeighbors classifier Accuracy -> ',accuracy_score(X_test_prediction,Y_test)*100)
print("KNeighbors classifier Precision Score -> ",precision_score(X_test_prediction, Y_test,average = 'weighted')*100)
print("KNeighbors classifier Recall Score -> ",recall_score(X_test_prediction, Y_test,average = 'weighted')*100)
"""# **Logistic Regression**
Logistic Regression is a Supervised Learning Technique and is used for solving the Classification problems, predict the categorical dependent variable with the help of independent variables.
"""
classifier = LogisticRegression()
classifier.fit(X_train, Y_train)
X_train_prediction = classifier.predict(X_train)
print(confusion_matrix( Y_train,X_train_prediction))
plot_confusion_matrix(classifier,X_train,Y_train)
plt.show()
print(classification_report( X_train_prediction,Y_train))
training_data_accuracy = accuracy_score(X_train_prediction, Y_train)
print('Accuracy Using Logistic Regression on Training data : ', (training_data_accuracy*100))
X_test_prediction = classifier.predict(X_test)
print(confusion_matrix( Y_test,X_test_prediction))
plot_confusion_matrix(classifier,X_test,Y_test)
plt.show()
print(classification_report(Y_test, X_test_prediction))
test_data_accuracy = accuracy_score(X_test_prediction, Y_test)
print('Logistic Regression Accuracy Score -> : ', test_data_accuracy*100)
print("Logistic Regression Precision Score -> ",precision_score(X_test_prediction, Y_test,average = 'weighted')*100)
print("Logistic Regression Recall Score -> ",recall_score(X_test_prediction, Y_test,average = 'weighted')*100)
"""# **Decision Tree**
Decision Tree is a Supervised learning technique based on a a tree-structured classifier, where internal nodes represent the features of a dataset, branches represent the decision rules and each leaf node represents the outcome.There are two nodes, which are the Decision Node and Leaf Node. Decision nodes are used to make any decision and have multiple branches, whereas Leaf nodes are the output of those decisions and do not contain any further branches.
The decisions or the test are performed on the basis of features of the given dataset.
"""
accuracy=[]
recall_scores=[]
max_depths=[2,4,6,8,10,12,14]
for n in max_depths:
clf_u=DecisionTreeClassifier(max_depth=n)
clf_u.fit(X_train,Y_train)
predict=clf_u.predict(X_test)
recall_scores.append(recall_score(Y_test,predict))
accuracy.append(clf_u.score(X_test,Y_test))
fig,(ax1,ax2)=plt.subplots(1,2,figsize=(12,5))
figs=[ax1,ax2]
def plot_graphs(fig_index,y,y_label,X=max_depths):
global figs
figs[fig_index].plot(X,y)
figs[fig_index].set_ylabel(y_label)
print(accuracy)
plot_graphs(1,accuracy,'accuracy')
plot_graphs(0,recall_scores,'recall')
#training the decison tree classifier with the max depth that has the maximum recall
max_depth=max_depths[recall_scores.index(max(recall_scores))]
clf_u=DecisionTreeClassifier(max_depth=max_depth)
clf_u.fit(X_train,Y_train)
predict=clf_u.predict(X_test)
recall_score(Y_test,predict)
print(confusion_matrix( Y_test,predict))
plot_confusion_matrix(clf_u,X_test,Y_test)
plt.show()
print(classification_report(Y_test, predict))
test_data_accuracy = accuracy_score(predict, Y_test)
print('Accuracy Using Decision Tree on Test Data : ', test_data_accuracy*100)
print('Max_depth with maximum recall {}'.format(max_depth))
# Use accuracy_score function to get the accuracy
print('Decision Tree Accuracy Score : ', test_data_accuracy*100)
print("Decision Tree Precision Score -> ",precision_score(predict, Y_test,average = 'weighted')*100)
print("Decision Tree Recall Score -> ",recall_score(predict, Y_test,average = 'weighted')*100)
import sklearn
plt.figure(figsize=(20,8))
sklearn.tree.plot_tree(clf_u,max_depth=3);
"""# **Bagging Classifier (base as Logistic Regression)**
A Bagging classifier is an ensemble meta-estimator that fits base classifiers each on random subsets of the original dataset and then aggregate their individual predictions (either by voting or by averaging) to form a final prediction
"""
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import make_pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import BaggingClassifier
pipeline = make_pipeline(StandardScaler(),LogisticRegression())
bgclassifier = BaggingClassifier(base_estimator=pipeline)
predictions=bgclassifier.fit(X_train, Y_train)
predictions = bgclassifier.predict(X_test)
print(confusion_matrix(predictions,Y_test))
plot_confusion_matrix(bgclassifier,X_test,Y_test)
plt.show()
print('Model test Score: %.3f, ' %bgclassifier.score(X_test, Y_test),
'Model training Score: %.3f' %bgclassifier.score(X_train, Y_train))
print('Accuracy Using Bagging Classifier with Logistic Regression on Training data : ', (bgclassifier.score(X_train, Y_train)*100))
print('Accuracy Using Bagging Classifier with Logistic Regression on Test Data : ', bgclassifier.score(X_test, Y_test)*100)
print("Bagging Classifier with Logistic Regression Accuracy : ", accuracy_score(predictions,Y_test)*100)
print("Bagging Classifier with Logistic Regression Precision : ", precision_score(predictions,Y_test,average = 'weighted')*100)
print("Bagging Classifier with Logistic Regression Recall : ", recall_score(predictions,Y_test,average = 'weighted')*100)
"""# **Random Forest Classifier**
The Random forest classifier creates a set of decision trees from a randomly selected subset of the training set. It is basically a set of decision trees (DT) from a randomly selected subset of the training set and then It collects the votes from different decision trees to decide the final prediction.
"""
from sklearn import metrics
classifier = RandomForestClassifier(n_estimators = 100)
classifier.fit(X_train, Y_train)
y_pred = classifier.predict(X_test)
recall_score(Y_test,y_pred)
print(confusion_matrix(y_pred,Y_test))
plot_confusion_matrix(classifier,X_test,Y_test)
plt.show()
print(classification_report(Y_test, y_pred))
print('Accuracy Using Random Forest Classifier', metrics.accuracy_score(Y_test, y_pred)*100)
print("Random forest classifier Accuracy : ", accuracy_score(y_pred,Y_test)*100)
print("Random forest classifier Precision : ", precision_score(y_pred,Y_test,average = 'weighted')*100)
print("Random forest classifier Recall : ", recall_score(y_pred,Y_test,average = 'weighted')*100)
"""# **Summary**
---
Comparison Of Algorithms
So in order to Conclude, It is identified that bagging classifier and Random forest performs well as it was able to tell that how many times the ML model was correct overall, how good the model is at predicting a specific category and how many times the model was able to detect a specific category where as in Logistic regression the model wasnot performed very well at predicting and detecting number of times the specific category.
---
**Random Forest Classifier/Bagging Classifier** **>** **Decision Tree** **>** **Logistic Regression** **>** **K Nearest Neighbor**
"""