Permutation importance and model explaining.ipynb

{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Introduction\nThis is an interesting problem in flagging credit risk when all variables are dimensionally reduced (likely PCA as hinted in the problem). It becomes a pure data science exercise to see what can be done with the data and how to handle highly imbalanced classes. \n\nIn this kernel we'll explore how to \n* look at imbalanced classes\n* test performance of the permutation importance in selecting important features\n* and finally look at model explanation using shap and eli5.\n\n# Data Load\nWe'll use simple logistic regression model and compare it's performance against a tree based classifier like random forest."},{"metadata":{"_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","trusted":true},"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.feature_selection import SelectFromModel\nimport eli5\nfrom eli5.sklearn import PermutationImportance\nfrom sklearn.metrics import classification_report, confusion_matrix, accuracy_score, f1_score, precision_score, recall_score, roc_curve, auc\nfrom imblearn.over_sampling import SMOTE\nfrom imblearn.under_sampling import RandomUnderSampler\nfrom sklearn.preprocessing import RobustScaler\nimport shap\nfrom pdpbox import pdp, get_dataset, info_plots","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true},"cell_type":"code","source":"raw_data = pd.read_csv('data/creditcard.csv')\nraw_data.head()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Features\n**Amount** and **Time** were not scaled in the dataset. Since time is increasing, it may be possible that there are certain times when we may get fraudulent cases to spike up. So we'll find the interval between each consecutive transactions and use that as the proxy for time. In cases of 0, we'll use the mean of the difference. We'll use the **RobustScalar** from **_sklearn_** to scale the Amount column."},{"metadata":{"trusted":true},"cell_type":"code","source":"rob_scaler = RobustScaler()\nraw_data['Time_Int'] = raw_data['Time'].diff() + raw_data['Time'].diff().mean()\nraw_data['Time_Int'][0] =  raw_data['Time'].diff().mean()\nraw_data['Scl_Amount'] = rob_scaler.fit_transform(raw_data['Amount'].values.reshape(-1,1))\nraw_data.drop(['Time', 'Amount'], axis=1, inplace=True)\nraw_data.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"raw_data.describe().transpose()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# EDA\nThere is a very high class imbalance between fraudulent and non-fraudulent cases. We'll explore a few cases of balancing cases before building a classification model.\n\n## Class distribution"},{"metadata":{"trusted":true},"cell_type":"code","source":"print(raw_data.groupby(['Class']).Class.count())\nsns.set_style('dark')\nplt.figure(figsize = (10,5))\nsns.countplot(raw_data['Class'], \n              alpha =.60, \n              palette= ['lightgreen','red'])\nplt.title('Fraud vs Non Fraud')\nplt.ylabel('# Cases')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Let's look at the predictor variables and see how the variables are distributed."},{"metadata":{"trusted":true},"cell_type":"code","source":"X = raw_data.drop('Class', axis = 1)\ny = raw_data['Class']\ncols = X.columns.tolist()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Boxplots by class\nThere are certain outliers in the data that ideally we'd like to eliminate. Removing too much of them would result in over/under fitting the model. Since quite a bit of business context is missing, we'll skip removing that for now.\n\n1. Higher values - more likely to be fraud\n  * V2, V4, V11, V19   \n2. Lower values - more likely to be fraud\n  * V3, V9, V10, V12, V14, V17, V18\n  \nThe above can be seen from the below box plots that might have a correlating impact on the fraudulent cases. We'll deep dive into features driving fraudulent classes in a bit."},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.set_style('dark')\nfig = plt.figure(figsize= (20,40))\nfig.subplots_adjust(hspace = 0.30, wspace = 0.30)\nk=0\nfor i in range(1,len(raw_data.columns)+1):\n    ax = fig.add_subplot(11,3,i)\n    sns.boxplot(x = 'Class', \n                y = X.columns[k], \n                data = raw_data, \n                palette = 'Blues')\n    k = k + 1\n    if k == len(X.columns): break\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Distributions of predictor variables\nMost of the variables seem to be normal/tending to be normal. Some of them have huge tails, and we can consider those to be extreme outliers. We'll look at removing those post some modeling phase to see if removing the outliers improve our model accuracy."},{"metadata":{"trusted":true},"cell_type":"code","source":"sns.set_style('dark')\nfig = plt.figure(figsize = (20,40))\nfig.subplots_adjust(hspace = 0.30, \n                    wspace = 0.30)\nk=0\nfor i in range(1, len(X.columns) + 1):\n    ax = fig.add_subplot(11, 3, i)\n    sns.distplot(X[X.columns[k]], \n                 color = 'teal')\n    k = k + 1\n    if k == len(X.columns): break\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Correlation\nThe below plot looks fishy. We're trying to understand the correlation of variables of a heavily imbalanced dataset. Ideally we should have an under sample of the dataset and look at the correlation then. Let's use the over sample method to have equal data points and then look at the correlation between the variables."},{"metadata":{"trusted":true},"cell_type":"code","source":"fig, ax = plt.subplots(figsize=(10, 8))\ncorr = X.corr()\nsns.heatmap(corr, \n            mask = np.zeros_like(corr, \n                                 dtype=np.bool), \n            cmap = sns.diverging_palette(275, \n                                         150, \n                                         as_cmap=True), \n            square = True, \n            ax = ax)\nplt.title('Correlation matrix of the imbalanced data')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Balanced using SMOTE\nWe'll use SMOTE method to generate some data points in the minority class and see if the correlation matrix improves to give some insights."},{"metadata":{"trusted":true},"cell_type":"code","source":"sm = SMOTE(random_state=101)\nX_sm, y_sm = sm.fit_sample(X, y.ravel())\nbal_data = pd.DataFrame(X_sm)\nbal_data.columns = cols\nbal_data['Class'] = y_sm\nprint(bal_data.groupby(['Class']).Class.count())\nsns.set_style('dark')\nplt.figure(figsize = (10,5))\nsns.countplot(bal_data['Class'], \n              alpha =.60, \n              palette= ['lightgreen','red'])\nplt.title('Fraud vs Non Fraud')\nplt.ylabel('# Cases')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"bal_data = bal_data.drop('Class', axis = 1)\nfig, ax = plt.subplots(figsize=(10, 8))\ncorr = bal_data.corr()\nsns.heatmap(corr, \n            mask = np.zeros_like(corr, \n                                 dtype=np.bool), \n            cmap = sns.diverging_palette(275, \n                                         150, \n                                         as_cmap=True), \n            square = True, \n            ax = ax)\nplt.title('Correlation matrix of the balanced data (SMOTE)')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Balanced using under sampling\nWe'll under sample data points from the majority class and see if the correlation matrix improves to give some insights."},{"metadata":{"trusted":true},"cell_type":"code","source":"un_sam = RandomUnderSampler(random_state=101)\nX_un_sam, y_un_sam = un_sam.fit_sample(X, y.ravel())\nbal_data = pd.DataFrame(X_un_sam)\nbal_data.columns = cols\nbal_data['Class'] = y_un_sam\nprint(bal_data.groupby(['Class']).Class.count())\nsns.set_style('dark')\nplt.figure(figsize = (10,5))\nsns.countplot(bal_data['Class'], \n              alpha =.60, \n              palette= ['lightgreen','red'])\nplt.title('Fraud vs Non Fraud')\nplt.ylabel('# Cases')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"bal_data = bal_data.drop('Class', axis = 1)\nfig, ax = plt.subplots(figsize=(10, 8))\ncorr = bal_data.corr()\nsns.heatmap(corr, \n            mask = np.zeros_like(corr, \n                                 dtype=np.bool), \n            cmap = sns.diverging_palette(275, \n                                         150, \n                                         as_cmap=True), \n            square = True, \n            ax = ax)\nplt.title('Correlation matrix of the balanced data (under sampling)')","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"We see there is no difference between under sampling and SMOTE visually from a correlation perspective, but might have impact on model accuracy. \n\n# Feature selection\nWe see a few highly correlated features from the above correlation matrix. We'll revisit removing some features at a later stage.\n\n## Feature importance using random forest\nWe'll use a random forest model to estimate the important features. Based on the importance, we'll use a cut of to choose the top features for training our model. Here while estimating the importance of a variable, each time a feature is dropped and the loss of accuracy is used to estimate the importance of that particular feature."},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train, X_test, y_train, y_test = train_test_split(X, \n                                                    y, \n                                                    test_size = .30, \n                                                    random_state = 101)\nX_train_res, y_train_res = sm.fit_sample(X_train, y_train.ravel())\nrf = RandomForestClassifier(n_jobs = -1, \n                            random_state = 101)\nrf.fit(X_train_res, y_train_res)\nfeat_imp = rf.feature_importances_\nsns.set(style=\"dark\")\nfig, ax = plt.subplots(figsize=(10, 8))\nvar_imp = pd.DataFrame({'feature':cols, \n                        'importance':feat_imp})\nvar_imp = var_imp.sort_values(ascending=False, \n                              by='importance')\nax = sns.barplot(x='importance', \n                 y='feature', \n                 data=var_imp)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"var_imp['feature_imp_cumsum'] = var_imp['importance'].cumsum()\nvar_imp","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"top_features = SelectFromModel(rf, threshold=0.01)\ntop_features.fit(X_train_res, y_train_res)\nrf_features= X_train.columns[(top_features.get_support())]\nrf_features = rf_features.tolist()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Permutation importance\nLet's look at the permutation importance method of variable importance that changes the order of a column and measures the loss of accuracy of the model to estimate the importance of the feature set. Instead of dripping a feature like in a random forest method, the feature column in randomized. Intuitively, we should see same/similar set of features from both the techniques, ordered differently, and the performance shouldn't differ drastically. We'll use [eli5](https://eli5.readthedocs.io/en/latest/overview.html) to compute importance."},{"metadata":{"trusted":true},"cell_type":"code","source":"perm = PermutationImportance(rf.fit(X_train_res, \n                                    y_train_res), \n                             random_state=1).fit(X_train_res,\n                                                 y_train_res)\neli5.show_weights(perm, \n                  feature_names = X_train.columns.tolist(), \n                  top=(30))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"pi_features = eli5.explain_weights_df(perm, feature_names = X_train.columns.tolist())\npi_features = pi_features.loc[pi_features['weight'] >= 0.01]['feature'].tolist()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(\"\\nFeatures from random forest\", rf_features)\nprint(\"\\nFeatures from permutation importance\", pi_features)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# SMOTE and classification\n## Logistic regression - baseline (all features)"},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train, X_test, y_train, y_test = train_test_split(X, \n                                                    y, \n                                                    test_size=0.3, \n                                                    random_state=101)\nX_train_res, y_train_res = sm.fit_sample(X_train, y_train.ravel())\nlreg = LogisticRegression()\nlreg_model_all = lreg.fit(X_train_res, y_train_res)\ny_pred_lreg_all = lreg_model_all.predict(X_test)\n\nprint('Confusion Matrix')\nprint('__'*10)\nprint(confusion_matrix(y_test, \n                       y_pred_lreg_all))\nprint('__'*30)\nprint('\\nClassification Metrics')\nprint('__'*30)\nprint(classification_report(y_test, \n                            y_pred_lreg_all))\nprint('__'*30)\nlogreg_accuracy = round(accuracy_score(y_test, \n                                       y_pred_lreg_all) * 100,2)\nprint('Accuracy', logreg_accuracy,'%')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fpr_lreg_all, tpr_lreg_all, thresholds = roc_curve(y_test, \n                                                   y_pred_lreg_all)\nroc_auc_lreg_all = auc(fpr_lreg_all,\n                       tpr_lreg_all)\nplt.title('Receiver Operating Characteristic - LReg (All features)')\nplt.plot(fpr_lreg_all, \n         tpr_lreg_all, \n         'b',\n         label='AUC = %0.3f'% roc_auc_lreg_all)\nplt.legend(loc='lower right')\nplt.plot([0,1],[0,1],'r--')\nplt.xlim([-0.1,1.0])\nplt.ylim([-0.1,1.01])\nplt.ylabel('True Positive Rate')\nplt.xlabel('False Positive Rate')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Logistic regression - RF feature selection"},{"metadata":{"trusted":true},"cell_type":"code","source":"X_rf = X[rf_features]\nX_train, X_test, y_train, y_test = train_test_split(X_rf,\n                                                    y, \n                                                    test_size=0.3, \n                                                    random_state=101)\nX_train_res, y_train_res = sm.fit_sample(X_train, y_train.ravel())\nlreg = LogisticRegression()\nlreg_model_rf = lreg.fit(X_train_res, y_train_res)\ny_pred_lreg_rf = lreg_model_rf.predict(X_test)\n\nprint('Confusion Matrix')\nprint('__'*10)\nprint(confusion_matrix(y_test, \n                       y_pred_lreg_rf))\nprint('__'*30)\nprint('\\nClassification Metrics')\nprint('__'*30)\nprint(classification_report(y_test, \n                            y_pred_lreg_rf))\nprint('__'*30)\nlogreg_accuracy = round(accuracy_score(y_test, \n                                       y_pred_lreg_rf) * 100,2)\nprint('Accuracy', logreg_accuracy,'%')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fpr_lreg_rf, tpr_lreg_rf, thresholds_rf = roc_curve(y_test, \n                                                   y_pred_lreg_rf)\nroc_auc_lreg_rf = auc(fpr_lreg_rf,\n                       tpr_lreg_rf)\nplt.title('Receiver Operating Characteristic - LReg (All features + RF Features)')\nplt.plot(fpr_lreg_rf, \n         tpr_lreg_rf, \n         'g',\n         label='AUC = %0.3f'% roc_auc_lreg_rf)\nplt.plot(fpr_lreg_all, \n         tpr_lreg_all, \n         'b',\n         label='AUC = %0.3f'% roc_auc_lreg_all)\nplt.legend(loc='lower right')\nplt.plot([0,1],[0,1],'r--')\nplt.xlim([-0.1,1.0])\nplt.ylim([-0.1,1.01])\nplt.ylabel('True Positive Rate')\nplt.xlabel('False Positive Rate')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Logistic regression - PI feature selection"},{"metadata":{"trusted":true},"cell_type":"code","source":"X_pf = X[pi_features]\nX_train, X_test, y_train, y_test = train_test_split(X_pf, \n                                                    y, \n                                                    test_size=0.3, \n                                                    random_state=101)\nX_train_res, y_train_res = sm.fit_sample(X_train, y_train.ravel())\nlreg_model_pi = lreg.fit(X_train_res, y_train_res)\ny_pred_lreg_pi = lreg_model_pi.predict(X_test)\n\nprint('Confusion Matrix')\nprint('__'*10)\nprint(confusion_matrix(y_test, \n                       y_pred_lreg_pi))\nprint('__'*30)\nprint('\\nClassification Metrics')\nprint('__'*30)\nprint(classification_report(y_test, \n                            y_pred_lreg_pi))\nprint('__'*30)\nlogreg_accuracy = round(accuracy_score(y_test, \n                                       y_pred_lreg_pi) * 100,2)\nprint('Accuracy', logreg_accuracy,'%')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fpr_lreg_pi, tpr_lreg_pi, thresholds_pi = roc_curve(y_test, \n                                                   y_pred_lreg_pi)\nroc_auc_lreg_pi = auc(fpr_lreg_pi,\n                       tpr_lreg_pi)\nplt.title('Receiver Operating Characteristic - LReg (All features + RF Features + PI features)')\nplt.plot(fpr_lreg_rf, \n         tpr_lreg_rf, \n         'g',\n         label='AUC = %0.3f'% roc_auc_lreg_rf)\nplt.plot(fpr_lreg_all, \n         tpr_lreg_all, \n         'b',\n         label='AUC = %0.3f'% roc_auc_lreg_all)\nplt.plot(fpr_lreg_pi, \n         tpr_lreg_pi, \n         'y',\n         label='AUC = %0.3f'% roc_auc_lreg_pi)\nplt.legend(loc='lower right')\nplt.plot([0,1],[0,1],'r--')\nplt.xlim([-0.1,1.0])\nplt.ylim([-0.1,1.01])\nplt.ylabel('True Positive Rate')\nplt.xlabel('False Positive Rate')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"The permutation importance features seem to have marginally improved the accuracy and the AUC. Let's see how it does on a tree based classifier.\n\n## Random forest - all features"},{"metadata":{"trusted":true},"cell_type":"code","source":"rf_model_all = rf.fit(X_train_res, y_train_res)\ny_pred_rf_all = rf_model_all.predict(X_test.as_matrix())\n\nprint('Confusion Matrix')\nprint('__'*10)\nprint(confusion_matrix(y_test, \n                       y_pred_rf_all))\nprint('__'*30)\nprint('\\nClassification Metrics')\nprint('__'*30)\nprint(classification_report(y_test, \n                            y_pred_rf_all))\nprint('__'*30)\nlogreg_accuracy = round(accuracy_score(y_test, \n                                       y_pred_rf_all) * 100,2)\nprint('Accuracy', logreg_accuracy,'%')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fpr_rf_all, tpr_rf_all, thresholds = roc_curve(y_test, \n                                                   y_pred_rf_all)\nroc_auc_rf_all = auc(fpr_rf_all,\n                       tpr_rf_all)\nplt.title('Receiver Operating Characteristic - RF (All features)')\nplt.plot(fpr_rf_all, \n         tpr_rf_all, \n         'b',\n         label='AUC = %0.3f'% roc_auc_rf_all)\nplt.legend(loc='lower right')\nplt.plot([0,1],[0,1],'r--')\nplt.xlim([-0.1,1.0])\nplt.ylim([-0.1,1.01])\nplt.ylabel('True Positive Rate')\nplt.xlabel('False Positive Rate')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Random forest - RF feature selection"},{"metadata":{"trusted":true},"cell_type":"code","source":"X_rf = X[rf_features]\nX_train, X_test, y_train, y_test = train_test_split(X_rf, \n                                                    y, \n                                                    test_size=0.3, \n                                                    random_state=101)\nX_train_res, y_train_res = sm.fit_sample(X_train, y_train.ravel())\nrf_model_rf = rf.fit(X_train_res, y_train_res)\ny_pred_rf_rf = rf_model_rf.predict(X_test.as_matrix())\n\nprint('Confusion Matrix')\nprint('__'*10)\nprint(confusion_matrix(y_test, \n                       y_pred_rf_rf))\nprint('__'*30)\nprint('\\nClassification Metrics')\nprint('__'*30)\nprint(classification_report(y_test, \n                            y_pred_rf_rf))\nprint('__'*30)\nlogreg_accuracy = round(accuracy_score(y_test, \n                                       y_pred_rf_rf) * 100,2)\nprint('Accuracy', logreg_accuracy,'%')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fpr_rf_rf, tpr_rf_rf, thresholds_rf = roc_curve(y_test, \n                                                   y_pred_rf_rf)\nroc_auc_rf_rf = auc(fpr_rf_rf,\n                       tpr_rf_rf)\nplt.title('Receiver Operating Characteristic - RF (All features + RF features)')\nplt.plot(fpr_rf_rf, \n         tpr_rf_rf, \n         'g',\n         label='AUC = %0.3f'% roc_auc_rf_rf)\nplt.plot(fpr_rf_all, \n         tpr_rf_all, \n         'b',\n         label='AUC = %0.3f'% roc_auc_rf_all)\nplt.legend(loc='lower right')\nplt.plot([0,1],[0,1],'r--')\nplt.xlim([-0.1,1.0])\nplt.ylim([-0.1,1.01])\nplt.ylabel('True Positive Rate')\nplt.xlabel('False Positive Rate')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Random forest - PI feature selection"},{"metadata":{"trusted":true},"cell_type":"code","source":"X_pf = X[pi_features]\nX_train, X_test, y_train, y_test = train_test_split(X_pf, \n                                                    y, \n                                                    test_size=0.3, \n                                                    random_state=101)\nX_train_res, y_train_res = sm.fit_sample(X_train, y_train.ravel())\nrf_model_pi = rf.fit(X_train_res, y_train_res)\ny_pred_rf_pi = rf_model_pi.predict(X_test.as_matrix())\n\nprint('Confusion Matrix')\nprint('__'*10)\nprint(confusion_matrix(y_test, \n                       y_pred_rf_pi))\nprint('__'*30)\nprint('\\nClassification Metrics')\nprint('__'*30)\nprint(classification_report(y_test, \n                            y_pred_rf_pi))\nprint('__'*30)\nlogreg_accuracy = round(accuracy_score(y_test, \n                                       y_pred_rf_pi) * 100,2)\nprint('Accuracy', logreg_accuracy,'%')","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"fpr_rf_pi, tpr_rf_pi, thresholds_pi = roc_curve(y_test, \n                                                   y_pred_rf_pi)\nroc_auc_rf_pi = auc(fpr_rf_pi,\n                       tpr_rf_pi)\nplt.title('Receiver Operating Characteristic - RF (All features + RF features + PI features)')\nplt.plot(fpr_rf_rf, \n         tpr_rf_rf, \n         'g',\n         label='AUC = %0.3f'% roc_auc_rf_rf)\nplt.plot(fpr_rf_all, \n         tpr_rf_all, \n         'b',\n         label='AUC = %0.3f'% roc_auc_rf_all)\nplt.plot(fpr_rf_pi, \n         tpr_rf_pi, \n         'y',\n         label='AUC = %0.3f'% roc_auc_rf_pi)\nplt.legend(loc='lower right')\nplt.plot([0,1],[0,1],'r--')\nplt.xlim([-0.1,1.0])\nplt.ylim([-0.1,1.01])\nplt.ylabel('True Positive Rate')\nplt.xlabel('False Positive Rate')\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Looking at the performance of random forest feature importance and permutation importance, in both cases permutation importance had a marginal improvement in model accuracy (not so much in the random forest model). \n\nUsing a random forest method the number of false positives decreased significantly. We'll have to evaluate the cost of model performance vs the cost of missing out on wrong predictions - the trade-off between FPR and TPR as you can see in ROC plots. In a banking use case like this where I'm interested to flag fraudulent cases, it's actually better to have more false positives."},{"metadata":{},"cell_type":"markdown","source":"# Model explaining\n## Partial dependency of features\nWe've seen how randomizing the values of a column and estimating the loss to calculate the importance of features. We can also look at seeing how changing the values of a feature impacts the predictions.\n\n### V4 feature\nIf the feature V4 has higher values, it has a higher change of being a case of fraud. You can see an increase in the y-axis as compared to a flat baseline in red."},{"metadata":{"trusted":true},"cell_type":"code","source":"pdp_V4 = pdp.pdp_isolate(model = rf_model_pi,\n                         dataset = X_test, \n                         model_features = pi_features, \n                         feature='V4', \n                         num_grid_points = 20)\n\npdp.pdp_plot(pdp_V4, \n             'V4', \n             plot_pts_dist=True)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### V14 feature\nIf you look back at the correlation matrix, V14 was negatively correlated to V4 feature. So, if we did the above analysis for the V14 feature, we should see a reverse of the above plot. This also says that having more negative values of this feature V14, has a higher change of predicting fraudulent cases. A really high number shows a tendency to bring the value close to the baseline."},{"metadata":{"trusted":true},"cell_type":"code","source":"pdp_V14 = pdp.pdp_isolate(model = rf_model_pi,\n                         dataset = X_test, \n                         model_features = pi_features, \n                         feature='V14', \n                         num_grid_points = 20)\n\npdp.pdp_plot(pdp_V14, \n             'V14', \n             plot_pts_dist=True)\nplt.show()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## SHAP\n### Explaining predictions\nLet's take a look at rows 443 (fraudulent) and 442 (non-fraudulent) from our test data and see what is the predicted probability for each of the case. The SHAP plot shows how away is the predicted probability from the base value. The pink arrows indicate features that show increased predictions for the fraudulent class and the blue ones from the non-fraudulent class.\n\nYou can also see the baseline value is the difference between the pink and blue bands - variables driving the prediction in their respective direction."},{"metadata":{"trusted":true},"cell_type":"code","source":"explainer = shap.TreeExplainer(rf_model_pi)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"data_row = 443\ndata_row = X_test.iloc[data_row]\nprint(\"Predicted probability\\nNon-fraud - Fraud\\n\", rf_model_pi.predict_proba(data_row.values.reshape(1, -1)))\nshap_values = explainer.shap_values(data_row)\nshap.initjs()\nshap.force_plot(explainer.expected_value[1], shap_values[1], data_row)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"One can interpret the features values of V14, V10, and V12 had a higher impact in classifying this record as fraudulent. This becomes very important when financial institutes want to know the reason behind fraudulent instances and explain the decisions to stakeholders.\n\nIn the below, the same three variables have the same impact in classifying the record as non-fraudulent (not in the same order and magnitude). Comparing the values of the features from the case above, all of them have a higher value when non-fraudulent. This reinforces the assumptions we saw in the box plots by class."},{"metadata":{"trusted":true},"cell_type":"code","source":"data_row = 442\ndata_row = X_test.iloc[data_row]\nprint(\"Predicted probability\\nNon-fraud - Fraud\\n\", rf_model_pi.predict_proba(data_row.values.reshape(1, -1)))\nshap_values = explainer.shap_values(data_row)\nshap.initjs()\nshap.force_plot(explainer.expected_value[1], shap_values[1], data_row)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### SHAP summary plot\nThe summary plot tells us the importance of features but with additional information like the spread of each feature, the impact of a variable, and the value of the respective feature.\n\nLook at the plot below and notice the points on the extremes - pink dots from V14, V16 have an impact of shifting the prediction direction for those records by 40% and having higher values in magnitude."},{"metadata":{"trusted":true},"cell_type":"code","source":"shap_values = explainer.shap_values(X_test)\nshap.summary_plot(shap_values[1], X_test)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### SHAP dependence plot\nThe SHAP dependence plot shows the interaction of a feature against another, and how it's impact on model prediction varies with another. It's different from the above plot and showcases a few more extra details - \n* We observe the obvious that a higher value of the feature V16 it could be fraudulent\n* The downward slope indicates the same\n* The plot below also sheds some light that there are interactions among the features that drive the prediction. Since the spread is pretty broad, the same value of the feature V16 can have different impact on predicting fraud\n* If you observe the outlier on the right, you can see a higher value of V4 feature and a higher value of V16 existed together for a record\n* The correlation between the two features also can be seen by the abundance of the pink records"},{"metadata":{"trusted":true},"cell_type":"code","source":"shap.dependence_plot('V16', shap_values[1], X_test, interaction_index = 'V4')","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.5.2"},"toc":{"base_numbering":1,"nav_menu":{},"number_sections":true,"sideBar":true,"skip_h1_title":false,"title_cell":"Table of Contents","title_sidebar":"Contents","toc_cell":false,"toc_position":{"height":"calc(100% - 180px)","left":"10px","top":"150px","width":"214.1875px"},"toc_section_display":true,"toc_window_display":true}},"nbformat":4,"nbformat_minor":1}