Module_5_AP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 5 : Performance measurements of  K-Nearest Neighbor and Decision Tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import library packages\n",
    "import pandas as p\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as s\n",
    "import numpy as n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df=p.read_excel(\"AirQuality.xlsx\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "var_mod = ['Country','State','city','place','lastupdate','Avg','Max','Min','Pollutants']\n",
    "le = LabelEncoder()\n",
    "for i in var_mod:\n",
    "    df[i] = le.fit_transform(df[i]).astype(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['AQI'] = df.Avg.map({ '68':'satisfactor', '74':'satisfactor', '71':'satisfactor', '4':'good', '39':'good', '42':'good', '27':'good', '263':'poor', '250':'poor', '249':'poor','258':'poor', '284':'poor', '28':'good', '106':'satisfactor', '44':'good', '62':'satisfactor', '59':'satisfactor', '1':'good', '9':'good', '15':'good', '34':'good','63':'satisfactor', '14':'good', '13':'good', '69':'satisfactor', '37':'good', '2':'good', '5':'good', '66':'satisfactor', '202':'poor', '11':'good', '10':'good','52':'satisfactor', '54':'satisfactor', '246':'poor', '248':'poor', '32':'good', '93':'satisfactor', '226':'poor', '189':'moderate', '124':'moderate', '272':'poor','277':'poor', '278':'poor', '279':'poor', '280':'poor', '87':'satisfactor', '19':'good', '240':'poor', '197':'moderate', '38':'good', '84':'satisfactor','61':'satisfactor', '196':'moderate', '171':'moderate', '23' :'good', '111':'moderate', '43' :'good', '188':'moderate', '203' :'poor' , '16' :'good', '20' :'good','225' :'poor' , '190':'moderate', '26' :'good', '104':'moderate', '25' :'good', '224' :'poor' , '210' :'poor' , '83':'satisfactor', '82':'satisfactor', '233' :'poor' ,'205' :'poor' , '78':'satisfactor', '70':'satisfactor', '211' :'poor' , '179':'moderate', '91':'satisfactor', '49':'good', '134':'moderate', '161':'moderate', '223' :'poor' ,'57':'satisfactor', '73':'satisfactor', '207' :'poor' , '184':'moderate', '48' :'good', '6' :'good', '7' :'good', '194':'moderate', '21' :'good', '50' :'good', '231' :'poor' ,'175':'moderate', '45' :'good', '86':'satisfactor', '243' :'poor' , '232' :'poor' , '18' :'good', '31' :'good', '95':'satisfactor', '237' :'poor' , '217' :'poor' ,'99':'satisfactor', '33' :'good', '176':'moderate', '22' :'good', '29' :'good', '107':'moderate', '17' :'good', '75':'satisfactor', '220' :'poor' , '165':'moderate','149':'moderate', '3' :'good', '245' :'poor' , '239' :'poor' , '72':'satisfactor', '77':'satisfactor', '208' :'poor' , '24' :'good', '198':'moderate', '153':'moderate','53':'satisfactor', '228' :'poor' , '186':'moderate', '51':'satisfactor', '247' :'poor' , '219' :'poor' , '100':'satisfactor', '36' :'good', '204' :'poor' , '30' :'good','221' :'poor' , '229' :'poor' , '187':'moderate', '56':'satisfactor', '230' :'poor' , '192':'moderate', '114':'moderate', '274' :'poor' , '236' :'poor' ,'222' :'poor' , '206' :'poor' , '174':'moderate', '58':'satisfactor', '235' :'poor' , '212' :'poor' , '120':'moderate', '148':'moderate', '242' :'poor' ,'215' :'poor' , '80':'satisfactor', '79':'satisfactor', '67':'satisfactor', '40' :'good', '35' :'good', '185':'moderate', '101':'moderate', '46' :'good', '209' :'poor' ,'169':'moderate', '12' :'good', '47' :'good', '227' :'poor' , '200' :'moderate' , '244' :'poor' , '238' :'poor' , '160':'moderate', '282' :'poor' , '218' :'poor' ,'261' :'poor' , '262' :'poor' , '260' :'poor' , '256' :'poor' , '252' :'poor' , '162':'moderate', '172':'moderate', '156':'moderate', '133':'moderate','116':'moderate', '193':'moderate', '123':'moderate', '65':'satisfactor', '96':'satisfactor', '173':'moderate', '103':'moderate', '8' :'good', '273' :'poor' , '275' :'poor' ,'283' :'poor' , '276' :'poor' , '254' :'poor' , '152':'moderate', '105':'moderate', '64':'satisfactor', '0' :'good', '76':'satisfactor', '127':'moderate', '97':'satisfactor','115':'moderate', '150':'moderate', '142':'moderate', '41' :'good', '102':'moderate', '90':'satisfactor', '132':'moderate', '98':'satisfactor', '199':'moderate', '191':'moderate','157':'moderate', '139':'moderate', '94':'satisfactor', '110':'moderate', '270' :'poor' , '268' :'poor' , '281' :'poor' , '265' :'poor' , '267' :'poor' ,'269' :'poor' , '81':'satisfactor', '128':'moderate', '146':'moderate', '145':'moderate', '129':'moderate', '85':'satisfactor', '117':'moderate', '108':'moderate', '154':'moderate','131':'moderate', '255' :'poor' , '257' :'poor' , '88':'satisfactor', '113':'moderate', '118':'moderate', '167':'moderate', '164':'moderate', '137':'moderate','135':'moderate', '138':'moderate', '109':'moderate', '60':'satisfactor', '177':'moderate', '271' :'poor' , '170':'moderate', '144':'moderate', '166':'moderate','155':'moderate', '136':'moderate', '151':'moderate', '89':'satisfactor', '119':'moderate', '266' :'poor' , '264' :'poor' , '251' :'poor' , '253' :'poor' ,'259' :'poor' , '163':'moderate', '159':'moderate', '241' :'poor' , '214' :'poor' , '122':'moderate', '234' :'poor' , '195':'moderate', '130':'moderate','216' :'poor' , '213' :'poor' , '121':'moderate', '112':'moderate', '168':'moderate', '201' :'poor' , '141':'moderate', '181':'moderate', '143':'moderate','126':'moderate', '182':'moderate', '178':'moderate', '158':'moderate', '140':'moderate', '183':'moderate', '92':'satisfactor', '180':'moderate', '147':'moderate', '55':'satisfactor','125':'moderate'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['class'] = df.AQI.map({'good':1,'moderate':0, 'servere':0, 'verypoor':0, 'satisfactor':1,'poor':0})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "del df['AQI']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#According to the cross-validated MCC scores, the random forest is the best-performing model, so now let's evaluate its performance on the test set.\n",
    "from sklearn.metrics import confusion_matrix, classification_report, matthews_corrcoef, cohen_kappa_score, accuracy_score, average_precision_score, roc_auc_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.drop(labels='class', axis=1)\n",
    "#Response variable\n",
    "y = df.loc[:,'class']    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "#We'll use a test size of 30%. We also stratify the split on the response variable, which is very important to do because there are so few fraudulent transactions.\n",
    "from sklearn.model_selection import train_test_split\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1, stratify=y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "K-Nearest Neighbor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification report of K-Nearest Neighbor Results:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.96      0.97      0.97        73\n",
      "           1       0.99      0.98      0.99       175\n",
      "\n",
      "    accuracy                           0.98       248\n",
      "   macro avg       0.97      0.98      0.98       248\n",
      "weighted avg       0.98      0.98      0.98       248\n",
      "\n",
      "Cross validation test results of accuracy:\n",
      "[1.         1.         1.         0.94117647 0.94117647 0.94117647\n",
      " 1.         0.94117647 1.         0.94117647 1.         1.\n",
      " 0.94117647 1.         1.         1.         1.         1.\n",
      " 1.         1.         1.         1.         0.82352941 1.\n",
      " 0.94117647 1.         0.94117647 0.94117647 0.94117647 0.94117647\n",
      " 0.94117647 0.94117647 1.         0.9375     1.         1.\n",
      " 0.875      1.         1.         1.         0.9375     1.\n",
      " 1.         1.         1.         1.         1.         1.\n",
      " 1.         1.        ]\n",
      "\n",
      "\n",
      "Accuracy result of K-Nearest Neighbor is: 97.61764705882354\n",
      "\n",
      "Confusion Matrix result of K-Nearest Neighbor is:\n",
      " [[ 71   2]\n",
      " [  3 172]]\n",
      "\n",
      "Sensitivity :  0.9726027397260274\n",
      "\n",
      "Specificity :  0.9828571428571429\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import cross_val_score\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "knnc = KNeighborsClassifier()\n",
    "\n",
    "knnc.fit(X_train,y_train)\n",
    "\n",
    "predictR = knnc.predict(X_test)\n",
    "\n",
    "print(\"\")\n",
    "print('Classification report of K-Nearest Neighbor Results:')\n",
    "print(\"\")\n",
    "\n",
    "\n",
    "\n",
    "print(classification_report(y_test,predictR))\n",
    "accuracy = cross_val_score(knnc, X, y, cv=50)\n",
    "print('Cross validation test results of accuracy:')\n",
    "print(accuracy)\n",
    "print(\"\")\n",
    "\n",
    "#get the mean of each fold \n",
    "print(\"\")\n",
    "print(\"Accuracy result of K-Nearest Neighbor is:\",accuracy.mean() * 100)\n",
    "print(\"\")\n",
    "\n",
    "cm1=confusion_matrix(y_test,predictR)\n",
    "print('Confusion Matrix result of K-Nearest Neighbor is:\\n',cm1)\n",
    "print(\"\")\n",
    "sensitivity1 = cm1[0,0]/(cm1[0,0]+cm1[0,1])\n",
    "print('Sensitivity : ', sensitivity1 )\n",
    "print(\"\")\n",
    "specificity1 = cm1[1,1]/(cm1[1,0]+cm1[1,1])\n",
    "print('Specificity : ', specificity1)\n",
    "print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True Positive : 172\n",
      "True Negative : 71\n",
      "False Positive : 2\n",
      "False Negative : 3\n",
      "\n",
      "True Positive Rate : 0.9828571428571429\n",
      "True Negative Rate : 0.9726027397260274\n",
      "False Positive Rate : 0.0273972602739726\n",
      "False Negative Rate : 0.017142857142857144\n",
      "\n",
      "Positive Predictive Value : 0.9885057471264368\n",
      "Negative predictive value : 0.9594594594594594\n"
     ]
    }
   ],
   "source": [
    "TN = cm1[0][0]\n",
    "FN = cm1[1][0]\n",
    "TP = cm1[1][1]\n",
    "FP = cm1[0][1]\n",
    "print(\"True Positive :\",TP)\n",
    "print(\"True Negative :\",TN)\n",
    "print(\"False Positive :\",FP)\n",
    "print(\"False Negative :\",FN)\n",
    "print(\"\")\n",
    "TPR = TP/(TP+FN)\n",
    "TNR = TN/(TN+FP)\n",
    "FPR = FP/(FP+TN)\n",
    "FNR = FN/(TP+FN)\n",
    "print(\"True Positive Rate :\",TPR)\n",
    "print(\"True Negative Rate :\",TNR)\n",
    "print(\"False Positive Rate :\",FPR)\n",
    "print(\"False Negative Rate :\",FNR)\n",
    "print(\"\")\n",
    "PPV = TP/(TP+FP)\n",
    "NPV = TN/(TN+FN)\n",
    "print(\"Positive Predictive Value :\",PPV)\n",
    "print(\"Negative predictive value :\",NPV)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decision Tree Classifier :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Classification report of Decision Tree Classifier Results:\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        73\n",
      "           1       1.00      1.00      1.00       175\n",
      "\n",
      "    accuracy                           1.00       248\n",
      "   macro avg       1.00      1.00      1.00       248\n",
      "weighted avg       1.00      1.00      1.00       248\n",
      "\n",
      "Cross validation test results of accuracy:\n",
      "[1.         1.         1.         1.         1.         1.\n",
      " 1.         1.         1.         1.         1.         1.\n",
      " 1.         1.         1.         1.         1.         0.94117647\n",
      " 1.         1.         1.         1.         1.         1.\n",
      " 1.         1.         1.         1.         1.         1.\n",
      " 1.         1.         1.         1.         1.         1.\n",
      " 1.         1.         1.         1.         1.         1.\n",
      " 1.         1.         1.         1.         1.         1.\n",
      " 1.         1.        ]\n",
      "\n",
      "\n",
      "Accuracy result of Decision Tree Classifier is: 99.88235294117646\n",
      "\n",
      "Confusion Matrix result of Decision Tree Classifier is:\n",
      " [[ 73   0]\n",
      " [  0 175]]\n",
      "\n",
      "Sensitivity :  1.0\n",
      "\n",
      "Specificity :  1.0\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "dtree = DecisionTreeClassifier()\n",
    "\n",
    "dtree.fit(X_train, y_train)\n",
    "\n",
    "predictDT = dtree.predict(X_test)\n",
    "\n",
    "print(\"\")\n",
    "print('Classification report of Decision Tree Classifier Results:')\n",
    "print(\"\")\n",
    "\n",
    "print(classification_report(y_test,predictDT))\n",
    "accuracy = cross_val_score(dtree, X, y, cv=50)\n",
    "\n",
    "print('Cross validation test results of accuracy:')\n",
    "print(accuracy)\n",
    "print(\"\")\n",
    "\n",
    "\n",
    "#get the mean of each fold \n",
    "print(\"\")\n",
    "print(\"Accuracy result of Decision Tree Classifier is:\",accuracy.mean() * 100)\n",
    "print(\"\")\n",
    "\n",
    "cm1=confusion_matrix(y_test,predictDT)\n",
    "print('Confusion Matrix result of Decision Tree Classifier is:\\n',cm1)\n",
    "print(\"\")\n",
    "sensitivity1 = cm1[0,0]/(cm1[0,0]+cm1[0,1])\n",
    "print('Sensitivity : ', sensitivity1 )\n",
    "print(\"\")\n",
    "specificity1 = cm1[1,1]/(cm1[1,0]+cm1[1,1])\n",
    "print('Specificity : ', specificity1)\n",
    "print(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True Positive : 175\n",
      "True Negative : 73\n",
      "False Positive : 0\n",
      "False Negative : 0\n",
      "\n",
      "True Positive Rate : 1.0\n",
      "True Negative Rate : 1.0\n",
      "False Positive Rate : 0.0\n",
      "False Negative Rate : 0.0\n",
      "\n",
      "Positive Predictive Value : 1.0\n",
      "Negative predictive value : 1.0\n"
     ]
    }
   ],
   "source": [
    "TN = cm1[0][0]\n",
    "FN = cm1[1][0]\n",
    "TP = cm1[1][1]\n",
    "FP = cm1[0][1]\n",
    "print(\"True Positive :\",TP)\n",
    "print(\"True Negative :\",TN)\n",
    "print(\"False Positive :\",FP)\n",
    "print(\"False Negative :\",FN)\n",
    "print(\"\")\n",
    "TPR = TP/(TP+FN)\n",
    "TNR = TN/(TN+FP)\n",
    "FPR = FP/(FP+TN)\n",
    "FNR = FN/(TP+FN)\n",
    "print(\"True Positive Rate :\",TPR)\n",
    "print(\"True Negative Rate :\",TNR)\n",
    "print(\"False Positive Rate :\",FPR)\n",
    "print(\"False Negative Rate :\",FNR)\n",
    "print(\"\")\n",
    "PPV = TP/(TP+FP)\n",
    "NPV = TN/(TN+FN)\n",
    "print(\"Positive Predictive Value :\",PPV)\n",
    "print(\"Negative predictive value :\",NPV)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# decision tree    \n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import learning_curve\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_sizes, train_scores, test_scores = learning_curve(DecisionTreeClassifier(), \n",
    "                                               X, y, cv=70, scoring='accuracy', n_jobs=-1, \n",
    "                                               # 50 different sizes of the training set\n",
    "                                               train_sizes=n.linspace(0.01, 1.0, 50))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_mean = n.mean(train_scores, axis=1)\n",
    "train_std = n.std(train_scores, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_mean = n.mean(test_scores, axis=1)\n",
    "test_std = n.std(test_scores, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplots(1, figsize=(5,5))\n",
    "plt.plot(train_sizes, train_mean, '--', color=\"#111111\",  label=\"Training score\")\n",
    "plt.plot(train_sizes, test_mean, color=\"#111111\", label=\"Cross-validation score\")\n",
    "    \n",
    "    # Draw bands\n",
    "plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color=\"#DDDDDD\")\n",
    "plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color=\"#DDDDDD\")\n",
    "    \n",
    "    # Create plot\n",
    "plt.title(\"Learning Curve\")\n",
    "plt.xlabel(\"Training Set Size\"), plt.ylabel(\"Accuracy Score\"), plt.legend(loc=\"best\")\n",
    "plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 360x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# KNN\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import learning_curve\n",
    "\n",
    "train_sizes, train_scores, test_scores = learning_curve(KNeighborsClassifier(), \n",
    "                                               X, y, cv=70, scoring='accuracy', n_jobs=-1, \n",
    "                                               # 50 different sizes of the training set\n",
    "                                               train_sizes=n.linspace(0.01, 1.0, 50))\n",
    "\n",
    "train_mean = n.mean(train_scores, axis=1)\n",
    "train_std = n.std(train_scores, axis=1)\n",
    "\n",
    "\n",
    "test_mean = n.mean(test_scores, axis=1)\n",
    "test_std = n.std(test_scores, axis=1)\n",
    "\n",
    "\n",
    "plt.subplots(1, figsize=(5,5))\n",
    "plt.plot(train_sizes, train_mean, '--', color=\"#111111\",  label=\"Training score\")\n",
    "plt.plot(train_sizes, test_mean, color=\"#111111\", label=\"Cross-validation score\")\n",
    "    \n",
    "    # Draw bands\n",
    "plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color=\"#DDDDDD\")\n",
    "plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color=\"#DDDDDD\")\n",
    "    \n",
    "    # Create plot\n",
    "plt.title(\"Learning Curve\")\n",
    "plt.xlabel(\"Training Set Size\"), plt.ylabel(\"Accuracy Score\"), plt.legend(loc=\"best\")\n",
    "plt.tight_layout(); plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}