Download FDAM.py from Abs6187/Fraud_Detection_API_excecute4: direct link, hf CLI and curl.
- Browser
- Download file 6.35 kB
-
https://huggingface.co/spaces/Abs6187/Fraud_Detection_API_excecute4/resolve/main/FDAM.py
- Command line
-
hf download hf://spaces/Abs6187/Fraud_Detection_API_excecute4/FDAM.py
-
curl -L -o FDAM.py https://huggingface.co/spaces/Abs6187/Fraud_Detection_API_excecute4/resolve/main/FDAM.py
6.35 kB
| #!/usr/bin/env python3 | |
| # -*- coding: utf-8 -*- | |
| """ | |
| Created on Fri Mar 15 14:57:46 2019 | |
| @author: atavci | |
| """ | |
| import pandas as pd | |
| import numpy as np | |
| import seaborn as sns | |
| import matplotlib.pyplot as plt | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.metrics import confusion_matrix, classification_report | |
| from sklearn.metrics import roc_curve, auc | |
| import xgboost as xgb | |
| from sklearn.neighbors import KNeighborsClassifier | |
| from sklearn.ensemble import RandomForestClassifier | |
| from sklearn.ensemble import VotingClassifier | |
| # set seaborn style because it prettier | |
| sns.set() | |
| # %% read and plot | |
| data = pd.read_csv("Data/synthetic-data-from-a-financial-payment-system/bs140513_032310.csv") | |
| data.head(5) | |
| # Create two dataframes with fraud and non-fraud data | |
| df_fraud = data.loc[data.fraud == 1] | |
| df_non_fraud = data.loc[data.fraud == 0] | |
| sns.countplot(x="fraud",data=data) | |
| plt.title("Count of Fraudulent Payments") | |
| plt.legend() | |
| plt.show() | |
| print("Number of normal examples: ",df_non_fraud.fraud.count()) | |
| print("Number of fradulent examples: ",df_fraud.fraud.count()) | |
| #print(data.fraud.value_counts()) # does the same thing above | |
| print("Mean feature values per category",data.groupby('category')['amount','fraud'].mean()) | |
| print("Columns: ", data.columns) | |
| # Plot histograms of the amounts in fraud and non-fraud data | |
| plt.hist(df_fraud.amount, alpha=0.5, label='fraud',bins=100) | |
| plt.hist(df_non_fraud.amount, alpha=0.5, label='nonfraud',bins=100) | |
| plt.title("Histogram for fraud and nonfraud payments") | |
| plt.ylim(0,10000) | |
| plt.xlim(0,1000) | |
| plt.legend() | |
| plt.show() | |
| # %% Preprocessing | |
| print(data.zipcodeOri.nunique()) | |
| print(data.zipMerchant.nunique()) | |
| # dropping zipcodeori and zipMerchant since they have only one unique value | |
| data_reduced = data.drop(['zipcodeOri','zipMerchant'],axis=1) | |
| data_reduced.columns | |
| # turning object columns type to categorical for later purposes | |
| col_categorical = data_reduced.select_dtypes(include= ['object']).columns | |
| for col in col_categorical: | |
| data_reduced[col] = data_reduced[col].astype('category') | |
| # it's usually better to turn the categorical values (customer, merchant, and category variables ) | |
| # into dummies because they have no relation in size(i.e. 5>4) but since they are too many (over 500k) the features will grow too many and | |
| # it will take forever to train but here is the code below for turning categorical features into dummies | |
| #data_reduced.loc[:,['customer','merchant','category']].astype('category') | |
| #data_dum = pd.get_dummies(data_reduced.loc[:,['customer','merchant','category','gender']],drop_first=True) # dummies | |
| #print(data_dum.info()) | |
| # categorical values ==> numeric values | |
| data_reduced[col_categorical] = data_reduced[col_categorical].apply(lambda x: x.cat.codes) | |
| # define X and y | |
| X = data_reduced.drop(['fraud'],axis=1) | |
| y = data['fraud'] | |
| # I won't do cross validation since we have a lot of instances | |
| X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=42,shuffle=True,stratify=y) | |
| # %% Function for plotting ROC_AUC curve | |
| def plot_roc_auc(y_test, preds): | |
| ''' | |
| Takes actual and predicted(probabilities) as input and plots the Receiver | |
| Operating Characteristic (ROC) curve | |
| ''' | |
| fpr, tpr, threshold = roc_curve(y_test, preds) | |
| roc_auc = auc(fpr, tpr) | |
| plt.title('Receiver Operating Characteristic') | |
| plt.plot(fpr, tpr, 'b', label = 'AUC = %0.2f' % roc_auc) | |
| plt.legend(loc = 'lower right') | |
| plt.plot([0, 1], [0, 1],'r--') | |
| plt.xlim([0, 1]) | |
| plt.ylim([0, 1]) | |
| plt.ylabel('True Positive Rate') | |
| plt.xlabel('False Positive Rate') | |
| plt.show() | |
| # The base score should be better than predicting always non-fraduelent | |
| print("Base score we must beat is: ", | |
| df_non_fraud.fraud.count()/ np.add(df_non_fraud.fraud.count(),df_fraud.fraud.count()) * 100) | |
| # %% K-ello Neigbors | |
| knn = KNeighborsClassifier(n_neighbors=5,p=1) | |
| knn.fit(X_train,y_train) | |
| y_pred = knn.predict(X_test) | |
| # High precision on fraudulent examples almost perfect score on non-fraudulent examples | |
| print("Classification Report for K-Nearest Neighbours: \n", classification_report(y_test, y_pred)) | |
| print("Confusion Matrix of K-Nearest Neigbours: \n", confusion_matrix(y_test,y_pred)) | |
| plot_roc_auc(y_test, knn.predict_proba(X_test)[:,1]) | |
| # %% Random Forest Classifier | |
| rf_clf = RandomForestClassifier(n_estimators=100,max_depth=8,random_state=42, | |
| verbose=1,class_weight="balanced") | |
| rf_clf.fit(X_train,y_train) | |
| y_pred = rf_clf.predict(X_test) | |
| # 98 % recall on fraudulent examples but low 24 % precision. | |
| print("Classification Report for Random Forest Classifier: \n", classification_report(y_test, y_pred)) | |
| print("Confusion Matrix of Random Forest Classifier: \n", confusion_matrix(y_test,y_pred)) | |
| plot_roc_auc(y_test, rf_clf.predict_proba(X_test)[:,1]) | |
| # %% XG-Boost | |
| XGBoost_CLF = xgb.XGBClassifier(max_depth=6, learning_rate=0.05, n_estimators=400, | |
| objective="binary:hinge", booster='gbtree', | |
| n_jobs=-1, nthread=None, gamma=0, min_child_weight=1, max_delta_step=0, | |
| subsample=1, colsample_bytree=1, colsample_bylevel=1, reg_alpha=0, reg_lambda=1, | |
| scale_pos_weight=1, base_score=0.5, random_state=42, verbosity=True) | |
| XGBoost_CLF.fit(X_train,y_train) | |
| y_pred = XGBoost_CLF.predict(X_test) | |
| # reatively high precision and recall for fraudulent class | |
| print("Classification Report for XGBoost: \n", classification_report(y_test, y_pred)) # Accuracy for XGBoost: 0.9963059088641371 | |
| print("Confusion Matrix of XGBoost: \n", confusion_matrix(y_test,y_pred)) | |
| plot_roc_auc(y_test, XGBoost_CLF.predict_proba(X_test)[:,1]) | |
| # %% Ensemble | |
| estimators = [("KNN",knn),("rf",rf_clf),("xgb",XGBoost_CLF)] | |
| ens = VotingClassifier(estimators=estimators, voting="soft",weights=[1,4,1]) | |
| ens.fit(X_train,y_train) | |
| y_pred = ens.predict(X_test) | |
| # Combined Random Forest model's recall and other models' precision thus this model | |
| # ensures a higher recall with less false alarms (false positives) | |
| print("Classification Report for Ensembled Models: \n", classification_report(y_test, y_pred)) # Accuracy for XGBoost: 0.9963059088641371 | |
| print("Confusion Matrix of Ensembled Models: \n", confusion_matrix(y_test,y_pred)) | |
| plot_roc_auc(y_test, ens.predict_proba(X_test)[:,1]) | |