resilientSupplier_knn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=[]\n",
    "Id=[]\n",
    "for i in range(1,5):\n",
    "    d=pd.read_csv(\"data_new_\"+str(i)+\".csv\")\n",
    "    Id.append(d[\"OrderId\"])\n",
    "    d=d.drop([\"OrderId\"],axis=1)\n",
    "    data.append(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting Dataset into Train and Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "X_train=[None]*4\n",
    "X_test=[None]*4\n",
    "y_train=[None]*4\n",
    "y_test=[None]*4\n",
    "for i in range(4):\n",
    "    X_train[i], X_test[i], y_train[i], y_test[i] = train_test_split(data[i].iloc[:,0:3],data[i].iloc[:,3], test_size=0.20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Implementing KNN Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import mean_squared_error\n",
    "predictionList=[]\n",
    "errList=[]\n",
    "for j in range(4):\n",
    "    knn = KNeighborsClassifier(n_neighbors=2)\n",
    "    knn.fit(X_train[j], y_train[j])\n",
    "    predict=knn.predict(X_test[j])\n",
    "    err=mean_squared_error(y_test[j],predict)\n",
    "    errList.append(err)\n",
    "    predictionList.append(predict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix For Each Supplier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For Supplier1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[115,  61],\n",
       "       [ 56, 768]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "cm1=confusion_matrix(y_test[0], predictionList[0])\n",
    "cm1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f9a1f36dd10>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import seaborn as sn\n",
    "sn.heatmap(cm1, annot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.67      0.65      0.66       176\n",
      "           1       0.93      0.93      0.93       824\n",
      "\n",
      "    accuracy                           0.88      1000\n",
      "   macro avg       0.80      0.79      0.80      1000\n",
      "weighted avg       0.88      0.88      0.88      1000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(y_test[0],predictionList[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7927239629302736"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test[0],predictionList[0])\n",
    "roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "roc_auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "prob=knn.predict_proba(X_test[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1.],\n",
       "       [0., 1.],\n",
       "       [0., 1.],\n",
       "       ...,\n",
       "       [0., 1.],\n",
       "       [0., 1.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0\n",
       "0  1.0\n",
       "1  1.0\n",
       "2  1.0\n",
       "3  1.0\n",
       "4  0.0"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob1_1 = pd.DataFrame(data=prob[:,0])\n",
    "prob1_2 = pd.DataFrame(data=prob[:,1])\n",
    "prob1_2.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For Supplier2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[103,  52],\n",
       "       [ 54, 791]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "cm1=confusion_matrix(y_test[1], predictionList[1])\n",
    "cm1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f9a1c45eed0>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAAD9CAYAAACC7q1lAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAUmUlEQVR4nO3df5hcVXnA8e+bhKQChgBCuiRRQJJB8KlRfojYIsovSa3BVlpsi5SCgadgQUsr8Set5VGRiPIYoVF+BFoTEaqkaBAMgqAlGjGNJDgQIJBNtomCCQiUZHdP/5ibOITd2dlkd8/OzffDc56de+6de8+Q8O7Le889EyklJElDb0TuAUjSzsoALEmZGIAlKRMDsCRlYgCWpEwMwJKUiQG4/64F1gMPDtD5zgAeKdoZRd+uwHeAXwLLgc8O0LU0PKwCfgEsBZYUfZ+n9ue9DPgWMC7LyDSkDMD9dz3wzu14393A/tv07QV8CngzcGTxes9i3+XAwcAbgbcCJ2/HNTV8vR2YChxebN8JvB74A+BhYGamcWkIjerrgIg4GJgOTAASsBZYkFJ6aJDHNlz9kJcH0tcCs4F9gOeBD1DLZvpyErX/8J4utu+kFtznAT8o+jYBDwATd2TQGvbuqHt9P/DeXAPR0GmYAUfER4D5QAA/AX5avJ4XERcP/vBaxhzgg8BhwEXAV5p83wRgdd12e9FXbxzwJ8CiHRyjho9ELeD+DJjRw/6/BRYO6YiURTR6FDkiHgYOTSlt3qZ/NLA8pTS5l/fNoPiLtccr2g7bbcyePR3WsiZO2o+53/gKxx19CrvutivLHrmXx1au2rp/9OhdOPaod/Pnf3kKZ597OgD7H/Bq1rR3sHnzZp58op2zT7+Acz94JmNGj+ZLs/4NgAsvOpcXXniBf5s9F4CRI0dy/fzZ3LPoR3zt6huH/HMOpnXPbcg9hGza2sbT0bGOffbZm9sXzufCCz/OvfctBmDmxX/PYYf9Ae899ezMo8yjc9Oa2NFzbP71Y02vr7DLqw7c4evtiL5KEN3AfsAT2/S3Fft6lFKaQy0rZMKeh5Z6sYkRI4JnNj7Licf82cv23fT1b3PT178NwDf/6zo+9Hcfo3312q37O9au4+g/PGLrdtuE8fz4vp9u3b7si5fw+KNPlC747uw6OtYB8KtfPcWtty7kiCOmcu99izn99FP542nHc8JJf555hBoqfd2EuxBYFBELI2JO0W6n9r/DFwz+8Ia/3z77HKufbOdd00/c2nfI6ytNvfeeRT/imLcfzR57jGWPPcZyzNuP5p5FPwLgnz7297xy7Cv51EwnQJTJrru+gt13323r6xOOfxvLl1c56cRj+ceL/o5T/vRveOGF/8s8yhbX3dV8y6xhBpxSuj0iplC7Qz+BWv23HfhpSin/6DOY/bXP85a3HsFee49jyYOLuPyzszn/Ax/hM7M+yQUXncuoUaO49T8XsuLBap/n2rBhI1/8/NV8565vAHDFZVexYcNG2vYbzwUXncMj1Uf53j03A3DdV7/OvBtvGdTPpsE3fvw+3PzNawAYNWok8+d/m+/dcTe/XHEfY8aM4faF8wFYvPgBzjvf2yzbpasz9wia1rAGPBDKXoLQ9tmZa8Dq3UDUgDetXd50zBm936HDugYsSa2lu9fbU8OOAVhSuSQDsCTlMQxurjXLACypXFooA3YtCEmlkro6m26NREQlIpbWtWci4sKIuCQi1tT1T6t7z8yIWBkR1Yg4qa+xmgFLKpcBugmXUqpSWzCJiBgJrKG2Ut2ZwBUppcvrj4+IQ4DTgEOpPcD2/YiY0mjKrhmwpHJJ3c235h0HPJpS2vap4HrTgfkppRdTSo8DK6k9Q9ErA7CkcunHk3ARMSMiltS1nhZHglpmO69u+/yIWBYR10bElsVumllc6yUMwJLKpR8ZcEppTkrp8Lo2Z9vTFYuPvRv4ZtF1FbUlaKcCHcCsLYf2NJpGQ7UGLKlcBv5R5JOBB1JK6wC2/ASIiK8CtxWb7cCkuvdNpLZ+eq/MgCWVS3d3860576Ou/BARbXX73sPvvp5sAXBaRIyJiAOAydTWUe+VGbCkUhnIdcIiYlfgBOCcuu7LImIqtfLCqi37UkrLI+ImYAXQCZzX16JlBmBJ5TKAD2KklJ4H9t6m7/QGx18KXNrs+Q3AksrFxXgkKZMWehTZACypXLo2933MMGEAllQuliAkKRNLEJKUiRmwJGViAJakPJI34SQpE2vAkpSJJQhJysQMWJIyMQOWpEzMgCUpk84BX5B90BiAJZWLGbAkZWINWJIyMQOWpEzMgCUpEzNgScrEWRCSlElKuUfQNAOwpHKxBixJmRiAJSkTb8JJUiZdXblH0DQDsKRysQQhSZkYgCUpE2vAkpRH6nYesCTlYQlCkjJxFoQkZWIGLEmZGIAlKRMX45GkTFooAx6RewCSNKC6U/OtDxExLiJujohfRsRDEfGWiNgrIu6MiEeKn3sWx0ZEXBkRKyNiWUS8qa/zG4AllUtXV/Otb18Cbk8pHQy8AXgIuBhYlFKaDCwqtgFOBiYXbQZwVV8nNwBLKpXU3d10ayQixgLHANcApJQ2pZQ2ANOBucVhc4FTitfTgRtSzf3AuIhoa3QNA7Ckchm4EsSBwK+A6yLi5xHxtYjYDRifUuoAKH7uWxw/AVhd9/72oq9XBmBJ5ZK6m24RMSMiltS1GXVnGgW8CbgqpfRG4Dl+V27oSfQ0mkZDdRaEpHLpx1oQKaU5wJxedrcD7SmlxcX2zdQC8LqIaEspdRQlhvV1x0+qe/9EYG2j65sBSyqXzq7mWwMppf8FVkdEpeg6DlgBLADOKPrOAG4tXi8A3l/MhjgK2LilVNEbM2BJ5TKwy1F+EPiPiBgNPAacSS1xvSkizgKeBE4tjv0uMA1YCTxfHNuQAVhSuQzgcpQppaXA4T3sOq6HYxNwXn/ObwCWVCp9TS8bTgzAksrFBdklKRMDsCRl4oLskpSH3wknSbkYgCUpE2dBSFImZsCSlIkBWJLySF2WICQpDzNgScrDaWiSlIsBWJIyaZ0SsAFYUrmkztaJwAZgSeXSOvHXACypXLwJJ0m5mAFLUh5mwJKUixmwJOWROnOPoHkGYEmlMrDfSj+4DMCSysUALEl5mAFLUiYGYEnKJHVF7iE0zQAsqVTMgCUpk9RtBixJWZgBS1ImKZkBS1IWZsCSlEm3syAkKQ9vwklSJgZgScoktc5ywAZgSeXSShnwiNwDkKSBlFI03ZoRESMj4ucRcVuxfX1EPB4RS4s2teiPiLgyIlZGxLKIeFNf5zYDllQqXQM/C+IC4CFgbF3fP6aUbt7muJOByUV7M3BV8bNXZsCSSmUgM+CImAj8MfC1Ji49Hbgh1dwPjIuItkZvMABLKpXUHU23iJgREUvq2oxtTvdF4J94+TLvlxZlhisiYkzRNwFYXXdMe9HXKwOwpFJJqT8tzUkpHV7X5mw5T0S8C1ifUvrZNpeYCRwMHAHsBXxky1t6Gk6jsVoDllQqAzgL4q3AuyNiGvB7wNiI+PeU0l8X+1+MiOuAi4rtdmBS3fsnAmsbXcAMWFKpdHWPaLo1klKamVKamFLaHzgNuCul9Ndb6roREcApwIPFWxYA7y9mQxwFbEwpdTS6hhmwpFIZggcx/iMi9qFWclgKnFv0fxeYBqwEngfO7OtEBmBJpdI9CMtRppTuBu4uXr+jl2MScF5/zmsAllQqrgcsSZm4FkSddc9tGOxLqAW9sPbe3ENQSQ1GCWKwmAFLKpW+ZjcMJwZgSaXSQhUIA7CkcrEEIUmZOAtCkjJpoS9FNgBLKpfU45o4w5MBWFKpdFqCkKQ8zIAlKRNrwJKUiRmwJGViBixJmXSZAUtSHgP3jUSDzwAsqVS6zYAlKQ8X45GkTLwJJ0mZdIclCEnKoiv3APrBACypVJwFIUmZOAtCkjJxFoQkZWIJQpIycRqaJGXSZQYsSXmYAUtSJgZgScqkhb4SzgAsqVzMgCUpEx9FlqRMnAcsSZlYgpCkTFopAI/IPQBJGkipH62RiPi9iPhJRPxPRCyPiH8u+g+IiMUR8UhEfCMiRhf9Y4rtlcX+/fsaqwFYUql0R/OtDy8C70gpvQGYCrwzIo4CPgdckVKaDPwGOKs4/izgNymlg4AriuMaMgBLKpWufrRGUs1vi81dipaAdwA3F/1zgVOK19OLbYr9x0U0/noOA7CkUukmNd0iYkZELKlrM+rPFREjI2IpsB64E3gU2JBS6iwOaQcmFK8nAKsBiv0bgb0bjdWbcJJKpT834VJKc4A5DfZ3AVMjYhzwLeB1PR1W/Owp221YajYDllQqA3UT7iXnTGkDcDdwFDAuIrYkrxOBtcXrdmASQLF/D+DpRuc1AEsqle5+tEYiYp8i8yUiXgEcDzwE/AB4b3HYGcCtxesFxTbF/rtSSg3jvCUISaXSGQP2pURtwNyIGEktWb0ppXRbRKwA5kfEvwI/B64pjr8GuDEiVlLLfE/r6wIGYEmlMlDhN6W0DHhjD/2PAUf20P9/wKn9uYYBWFKptNKTcAZgSaXS3ULfi2wAllQqrRN+DcCSSsYShCRl0tVCObABWFKpmAFLUibJDFiS8jADlqRMnIYmSZm0Tvg1AEsqmc4WCsEGYEml4k04ScrEm3CSlIkZsCRlYgYsSZl0Nf4SimHFACypVJwHLEmZWAOWpEysAUtSJpYgJCkTSxCSlImzICQpE0sQkpSJN+EkKRNrwJKUiSUIScokeRNOkvLwa+klKRNLEJKUiSUIScrEDFiSMnEamiRl4qPIkpSJJQhJyqSVAvCI3AOQpIGUUmq69SUiro2I9RHxYF3fJRGxJiKWFm1a3b6ZEbEyIqoRcVJf5zcDllQqA5wBXw98Gbhhm/4rUkqX13dExCHAacChwH7A9yNiSkqpq7eTmwFLKpXUj3/6PFdKPwSebvLS04H5KaUXU0qPAyuBIxu9wQAsqVS6UnfTLSJmRMSSujajycucHxHLihLFnkXfBGB13THtRV+vDMCSSqU/NeCU0pyU0uF1bU4Tl7gKeC0wFegAZhX90dNwGp3IGrCkUhnsWRAppXVbXkfEV4Hbis12YFLdoROBtY3OZQYsqVQGsgbck4hoq9t8D7BlhsQC4LSIGBMRBwCTgZ80OpcZsKRS6R7AJ+EiYh5wLPCqiGgHPgUcGxFTqZUXVgHnAKSUlkfETcAKoBM4r9EMCIAY7JWDRo2e0DqzojVkXlh7b+4haBja5VUH9lRH7ZdDx7+56ZizfN3iHb7ejjADllQqXal1vpbTACypVAayBDHYDMCSSsXlKCUpEzNgScrEDFiSMulqPPNrWDEASyoVv5RTkjJppQXZDcCSSsUMWJIycRaEJGXiLAhJysRHkSUpE2vAkpSJNWBJysQMWJIycR6wJGViBixJmTgLQpIy8SacAFj58P08+9vf0tXVTWdnJ0e9ZdrWfR/+0Dlc9rlPMr7t9Tz11G8yjlL98fgT7Vz0yc9s3W5f28H5Z5/O6X/xnq19G595lk985gpWr+lgzOjRfPqjH2Lygfvv0HU3bdrEzE/PYkX1EcbtMZbL/2UmE9rG8+OfPMAXr76OzZs72WWXUfzDeWfx5sOm7tC1Wp0lCG11/AmnvizATpy4H8cfdwxPPNGeaVTaXge8ZiK3zJ0NQFdXF+845XSOe9vRLznmqzd8g4Mnv5YrP/NJHntiNZfOms01V362qfOv6VjHxy6dxfVfvuwl/f952x2MfeXuLLzpWr77/bv5wleuZdanZ7LnuLF8+XOXsO8+e/PIY6s450Mf565b/31gPmyLaqUn4UbkHsDOaNbll3DxRy9tqd/Uern7lyxl0oQ29vv98S/pf3TVkxx12BsAOPA1k1jTsY5fP137Jfxf37uL086+gD874zz++bIr6epqbu3au+79b6ZPOx6AE4/9Ixb/bCkpJV435SD23WdvAA464DW8uGkTmzZtGqiP2JJSSk233LY7AEfEmQM5kDJKKbHwu/NYfP9Czj7rrwB417tOYM2aDpYtW5F5dNpRCxfdw7Tj3/ay/spBB/L9e34MwC9WVOlYt55163/No6ue5PZF93Dj1bO4Ze5sRowYwW13/KCpa63/1VP8/r6vAmDUqJHsvtuubNj4zEuOufPu+3jdlNcyevToHfxkra07paZbbrG9vwUi4smU0qt72TcDmFFszkkpzdnO8bW6/YC1wL7AnR/+8Ifv+MIXvnAMcCKwEVgFHA78OtsItV0qlcpoan+2h1ar1XXb7BsLfAl4I/AL4GDgbOCPgI8C64tDXwHMe/jhh9dOmTLlZOAAYDTwamBlccyXqtXqdZVKZTlwUrVabS+u8ShwZLVafarYPhRYAJxYrVYfHaSPrQHWsAYcEct62wWM72UfRcDdWYNuvbXFz/XAt9ra2j4A7AL8T9E/EXgAOBL436EfnnbAycAD2wZfgGq1+gxwJkClUgng8aIdA8ytVqsz64+PiCXVavXw4vj9geur1eqx25y2HZgEtFcqlVHAHsDTxXsmAt8C3m/wbS193YQbD5wEbHubPoAfD8qIymM3aiWeZ4vXJy5evPg5YErdMaswA25V7wPm9bSjUqmMA56vVqubqGW+P6xWq89UKpVFwK2VSuWKarW6vlKp7AW8ssnrLQDOAP4beC9wV7VaTcW1vgPMrFarP9rBz6Qh1lcAvg3YPaW0dNsdEXH3oIyoPMZTy0qg9u/567fccst7GhyvFlGpVHYFTgDOqes7F6BarV4NvA64oVKpdAErgLOKfSsqlcrHgTsqlcoIYDNwXpOXvQa4sVKprKSW+Z5W9J8PHAR8olKpfKLoO7Fara7v4RwaZra7Bqz+i4gZO3E9XL3w78XOywAsSZk4D1iSMjEAS1ImBuAhEhHvjIhqRKyMiItzj0f5RcS1EbE+Ih7MPRblYQAeAhExEphNbe7oIcD7IuKQvKPSMHA98M7cg1A+BuChcSSwMqX0WEppEzAfmJ55TMospfRDiocptHMyAA+NCcDquu32ok/STswAPDSihz7n/0k7OQPw0NjyHP8WE/ndOhGSdlIG4KHxU2ByRBwQEaOpPUa6IPOYJGVmAB4CKaVOas/sfw94CLgppbQ876iUW0TMo7a4TiUi2iPirNxj0tDyUWRJysQMWJIyMQBLUiYGYEnKxAAsSZkYgCUpEwOwJGViAJakTP4fxyvoC6xZqZcAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sn\n",
    "sn.heatmap(cm1, annot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.66      0.66      0.66       155\n",
      "           1       0.94      0.94      0.94       845\n",
      "\n",
      "    accuracy                           0.89      1000\n",
      "   macro avg       0.80      0.80      0.80      1000\n",
      "weighted avg       0.89      0.89      0.89      1000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(y_test[1],predictionList[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8003054017942355"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test[1],predictionList[1])\n",
    "roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "roc_auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1.],\n",
       "       [0., 1.],\n",
       "       [0., 1.],\n",
       "       ...,\n",
       "       [0., 1.],\n",
       "       [0., 1.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob=knn.predict_proba(X_test[1])\n",
    "prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0\n",
       "0  1.0\n",
       "1  1.0\n",
       "2  1.0\n",
       "3  1.0\n",
       "4  1.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob2_1 = pd.DataFrame(data=prob[:,0])\n",
    "prob2_2 = pd.DataFrame(data=prob[:,1])\n",
    "prob2_2.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For Supplier3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[101,  55],\n",
       "       [ 38, 806]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "cm1=confusion_matrix(y_test[2], predictionList[2])\n",
    "cm1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f9a1c397910>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sn\n",
    "sn.heatmap(cm1, annot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.73      0.65      0.68       156\n",
      "           1       0.94      0.95      0.95       844\n",
      "\n",
      "    accuracy                           0.91      1000\n",
      "   macro avg       0.83      0.80      0.82      1000\n",
      "weighted avg       0.90      0.91      0.90      1000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(y_test[2],predictionList[2]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8012061003767165"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test[2],predictionList[2])\n",
    "roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "roc_auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 1. ],\n",
       "       [0. , 1. ],\n",
       "       [0.5, 0.5],\n",
       "       ...,\n",
       "       [0. , 1. ],\n",
       "       [0. , 1. ],\n",
       "       [0. , 1. ]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob=knn.predict_proba(X_test[2])\n",
    "prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0\n",
       "0  1.0\n",
       "1  1.0\n",
       "2  0.5\n",
       "3  1.0\n",
       "4  1.0"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob3_1 = pd.DataFrame(data=prob[:,0])\n",
    "prob3_2 = pd.DataFrame(data=prob[:,1])\n",
    "prob3_2.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For Supplier4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[125,  61],\n",
       "       [ 61, 753]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "cm1=confusion_matrix(y_test[3], predictionList[3])\n",
    "cm1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f9a1c3157d0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sn\n",
    "sn.heatmap(cm1, annot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.67      0.67      0.67       186\n",
      "           1       0.93      0.93      0.93       814\n",
      "\n",
      "    accuracy                           0.88      1000\n",
      "   macro avg       0.80      0.80      0.80      1000\n",
      "weighted avg       0.88      0.88      0.88      1000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import classification_report\n",
    "print(classification_report(y_test[3],predictionList[3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7985522179070567"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.metrics import roc_curve, auc\n",
    "false_positive_rate, true_positive_rate, thresholds = roc_curve(y_test[3],predictionList[3])\n",
    "roc_auc = auc(false_positive_rate, true_positive_rate)\n",
    "roc_auc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0. , 1. ],\n",
       "       [0. , 1. ],\n",
       "       [0.5, 0.5],\n",
       "       ...,\n",
       "       [0. , 1. ],\n",
       "       [0. , 1. ],\n",
       "       [0. , 1. ]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob=knn.predict_proba(X_test[2])\n",
    "prob"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>0.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "     0\n",
       "0  1.0\n",
       "1  1.0\n",
       "2  0.5\n",
       "3  1.0\n",
       "4  1.0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "prob4_1 = pd.DataFrame(data=prob[:,0])\n",
    "prob4_2 = pd.DataFrame(data=prob[:,1])\n",
    "prob4_2.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_col_merged =pd.concat([prob1_2,prob2_2], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>0</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>1</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>3</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>4</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>995</td>\n",
       "      <td>0.5</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>996</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>997</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>998</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>999</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1000 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       0    0\n",
       "0    1.0  1.0\n",
       "1    1.0  1.0\n",
       "2    1.0  1.0\n",
       "3    1.0  1.0\n",
       "4    0.0  1.0\n",
       "..   ...  ...\n",
       "995  0.5  1.0\n",
       "996  1.0  1.0\n",
       "997  1.0  1.0\n",
       "998  1.0  1.0\n",
       "999  1.0  1.0\n",
       "\n",
       "[1000 rows x 2 columns]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_col_merged"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}