Clas-K-Nearest-neighbors-CustCat.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "#### Customer Classification with K-Nearest Neighbors (KNN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "**K-Nearest Neighbors** is an algorithm for supervised learning. Where the data is 'trained' with data points corresponding to their classification. Once a point is to be predicted, it takes into account the 'K' nearest points to it to determine it's classification.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Lets load required libraries\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn import preprocessing\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "### Load Data From CSV File\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "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>region</th>\n",
       "      <th>tenure</th>\n",
       "      <th>age</th>\n",
       "      <th>marital</th>\n",
       "      <th>address</th>\n",
       "      <th>income</th>\n",
       "      <th>ed</th>\n",
       "      <th>employ</th>\n",
       "      <th>retire</th>\n",
       "      <th>gender</th>\n",
       "      <th>reside</th>\n",
       "      <th>custcat</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2</td>\n",
       "      <td>13</td>\n",
       "      <td>44</td>\n",
       "      <td>1</td>\n",
       "      <td>9</td>\n",
       "      <td>64.0</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>11</td>\n",
       "      <td>33</td>\n",
       "      <td>1</td>\n",
       "      <td>7</td>\n",
       "      <td>136.0</td>\n",
       "      <td>5</td>\n",
       "      <td>5</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>6</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "      <td>68</td>\n",
       "      <td>52</td>\n",
       "      <td>1</td>\n",
       "      <td>24</td>\n",
       "      <td>116.0</td>\n",
       "      <td>1</td>\n",
       "      <td>29</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2</td>\n",
       "      <td>33</td>\n",
       "      <td>33</td>\n",
       "      <td>0</td>\n",
       "      <td>12</td>\n",
       "      <td>33.0</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>23</td>\n",
       "      <td>30</td>\n",
       "      <td>1</td>\n",
       "      <td>9</td>\n",
       "      <td>30.0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   region  tenure  age  marital  address  income  ed  employ  retire  gender  \\\n",
       "0       2      13   44        1        9    64.0   4       5     0.0       0   \n",
       "1       3      11   33        1        7   136.0   5       5     0.0       0   \n",
       "2       3      68   52        1       24   116.0   1      29     0.0       1   \n",
       "3       2      33   33        0       12    33.0   2       0     0.0       1   \n",
       "4       2      23   30        1        9    30.0   1       2     0.0       0   \n",
       "\n",
       "   reside  custcat  \n",
       "0       2        1  \n",
       "1       6        4  \n",
       "2       2        3  \n",
       "3       1        1  \n",
       "4       4        3  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('teleCust1000t.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "<div id=\"visualization_analysis\">\n",
    "    <h2>Data Visualization and Analysis</h2> \n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "#### Let’s see how many of each class is in our data set\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    281\n",
       "1    266\n",
       "4    236\n",
       "2    217\n",
       "Name: custcat, dtype: int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['custcat'].value_counts()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "#### 281 Plus Service, 266 Basic-service, 236 Total Service, and 217 E-Service customers\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can easily explore your data using visualization techniques:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[<matplotlib.axes._subplots.AxesSubplot object at 0x0000021F60FC2310>]],\n",
       "      dtype=object)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.hist(column='income', bins=50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "### Feature set\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Lets define feature sets, X:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['region', 'tenure', 'age', 'marital', 'address', 'income', 'ed',\n",
       "       'employ', 'retire', 'gender', 'reside', 'custcat'],\n",
       "      dtype='object')"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To use scikit-learn library, we have to convert the Pandas data frame to a Numpy array:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  2.,  13.,  44.,   1.,   9.,  64.,   4.,   5.,   0.,   0.,   2.],\n",
       "       [  3.,  11.,  33.,   1.,   7., 136.,   5.,   5.,   0.,   0.,   6.],\n",
       "       [  3.,  68.,  52.,   1.,  24., 116.,   1.,  29.,   0.,   1.,   2.],\n",
       "       [  2.,  33.,  33.,   0.,  12.,  33.,   2.,   0.,   0.,   1.,   1.],\n",
       "       [  2.,  23.,  30.,   1.,   9.,  30.,   1.,   2.,   0.,   0.,   4.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = df[['region', 'tenure','age', 'marital', 'address', 'income', 'ed', 'employ','retire', 'gender', 'reside']] .values  #.astype(float)\n",
    "X[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "What are our labels?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 3, 1, 3], dtype=int64)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = df['custcat'].values\n",
    "y[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "## Normalize Data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Data Standardization give data zero mean and unit variance, it is good practice, especially for algorithms such as KNN which is based on distance of cases:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.02696767, -1.055125  ,  0.18450456,  1.0100505 , -0.25303431,\n",
       "        -0.12650641,  1.0877526 , -0.5941226 , -0.22207644, -1.03459817,\n",
       "        -0.23065004],\n",
       "       [ 1.19883553, -1.14880563, -0.69181243,  1.0100505 , -0.4514148 ,\n",
       "         0.54644972,  1.9062271 , -0.5941226 , -0.22207644, -1.03459817,\n",
       "         2.55666158],\n",
       "       [ 1.19883553,  1.52109247,  0.82182601,  1.0100505 ,  1.23481934,\n",
       "         0.35951747, -1.36767088,  1.78752803, -0.22207644,  0.96655883,\n",
       "        -0.23065004],\n",
       "       [-0.02696767, -0.11831864, -0.69181243, -0.9900495 ,  0.04453642,\n",
       "        -0.41625141, -0.54919639, -1.09029981, -0.22207644,  0.96655883,\n",
       "        -0.92747794],\n",
       "       [-0.02696767, -0.58672182, -0.93080797,  1.0100505 , -0.25303431,\n",
       "        -0.44429125, -1.36767088, -0.89182893, -0.22207644, -1.03459817,\n",
       "         1.16300577]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = preprocessing.StandardScaler().fit(X).transform(X.astype(float))\n",
    "X[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "### Train Test Split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set: (800, 11) (800,)\n",
      "Test set: (200, 11) (200,)\n"
     ]
    }
   ],
   "source": [
    "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.2, random_state=4)\n",
    "print ('Train set:', X_train.shape,  y_train.shape)\n",
    "print ('Test set:', X_test.shape,  y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "<div id=\"classification\">\n",
    "    <h2>Classification</h2>\n",
    "</div>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "<h3>K nearest neighbor (KNN)</h3>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "#### Import library\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "Classifier implementing the k-nearest neighbors vote.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "### Training\n",
    "\n",
    "Lets start the algorithm with k=4 for now:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "KNeighborsClassifier(n_neighbors=4)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k = 4\n",
    "#Train Model and Predict  \n",
    "neigh = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)\n",
    "neigh"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "### Predicting\n",
    "\n",
    "we can use the model to predict the test set:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 3, 2, 4], dtype=int64)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yhat = neigh.predict(X_test)\n",
    "yhat[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "### Accuracy evaluation\n",
    "\n",
    "In multilabel classification, **accuracy classification score** is a function that computes subset accuracy. This function is equal to the jaccard_similarity_score function. Essentially, it calculates how closely the actual labels and predicted labels are matched in the test set.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set Accuracy:  0.5475\n",
      "Test set Accuracy:  0.32\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "print(\"Train set Accuracy: \", metrics.accuracy_score(y_train, neigh.predict(X_train)))\n",
    "print(\"Test set Accuracy: \", metrics.accuracy_score(y_test, yhat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets try this time with k=6?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set Accuracy:  0.51625\n",
      "Test set Accuracy:  0.31\n"
     ]
    }
   ],
   "source": [
    "k = 6\n",
    "#Train Model and Predict  \n",
    "neigh6 = KNeighborsClassifier(n_neighbors = k).fit(X_train,y_train)\n",
    "neigh6\n",
    "\n",
    "yhat = neigh6.predict(X_test)\n",
    "yhat[0:5]\n",
    "\n",
    "print(\"Train set Accuracy: \", metrics.accuracy_score(y_train, neigh6.predict(X_train)))\n",
    "print(\"Test set Accuracy: \", metrics.accuracy_score(y_test, yhat))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "#### What about other K?\n",
    "\n",
    "K in KNN, is the number of nearest neighbors to examine. It is supposed to be specified by the User. So, how can we choose right value for K?\n",
    "The general solution is to reserve a part of your data for testing the accuracy of the model. Then chose k =1, use the training part for modeling, and calculate the accuracy of prediction using all samples in your test set. Repeat this process, increasing the k, and see which k is the best for your model.\n",
    "\n",
    "We can calculate the accuracy of KNN for different Ks.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.3  , 0.29 , 0.315, 0.32 , 0.315, 0.31 , 0.335, 0.325, 0.34 ])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Ks = 10\n",
    "mean_acc = np.zeros((Ks-1))\n",
    "std_acc = np.zeros((Ks-1))\n",
    "\n",
    "for n in range(1,Ks):\n",
    "    \n",
    "    #Train Model and Predict  \n",
    "    neigh = KNeighborsClassifier(n_neighbors = n).fit(X_train,y_train)\n",
    "    yhat=neigh.predict(X_test)\n",
    "    mean_acc[n-1] = metrics.accuracy_score(y_test, yhat)\n",
    "\n",
    "    \n",
    "    std_acc[n-1]=np.std(yhat==y_test)/np.sqrt(yhat.shape[0])\n",
    "\n",
    "mean_acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "source": [
    "#### Plot  model accuracy  for Different number of Neighbors\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(1,Ks),mean_acc,'g')\n",
    "plt.fill_between(range(1,Ks),mean_acc - 1 * std_acc,mean_acc + 1 * std_acc, alpha=0.10)\n",
    "plt.fill_between(range(1,Ks),mean_acc - 3 * std_acc,mean_acc + 3 * std_acc, alpha=0.10,color=\"green\")\n",
    "plt.legend(('Accuracy ', '+/- 1xstd','+/- 3xstd'))\n",
    "plt.ylabel('Accuracy ')\n",
    "plt.xlabel('Number of Neighbors (K)')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "button": false,
    "new_sheet": false,
    "run_control": {
     "read_only": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best accuracy was with 0.34 with k= 9\n"
     ]
    }
   ],
   "source": [
    "print( \"The best accuracy was with\", mean_acc.max(), \"with k=\", mean_acc.argmax()+1) "
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}