K-Nearest Neighbors/k-NN wine-quality (from scratch).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing   import StandardScaler\n",
    "from collections             import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outlierDetect(df,no_of_feature_contains = 3):\n",
    "    '''pass pandas\"s dataframe'''\n",
    "    outlier_indices = []\n",
    "    for col in df:\n",
    "        q1 = np.percentile(df[col],25)\n",
    "        q3 = np.percentile(df[col],75)\n",
    "        # IQR\n",
    "        iqr = q3 - q1\n",
    "        lower = q1 - 1.5 * iqr\n",
    "        upper = q3 + 1.5 * iqr\n",
    "        outlier_index = df[ (df[col] < lower) | (df[col] > upper)].index.tolist()\n",
    "        outlier_indices.extend(outlier_index)\n",
    "\n",
    "    counted_outliers = Counter(outlier_indices)    \n",
    "    indexs = [k for k,v in counted_outliers.items() if v > no_of_feature_contains] \n",
    "    return indexs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def loaddata():\n",
    "    raw_data = pd.read_csv('../DataSets/glass.csv')\n",
    "    X = raw_data.iloc[:,:-1]\n",
    "    y = raw_data.iloc[:,-1]\n",
    "    X_train , X_test , y_train , y_test = train_test_split(X,y,\n",
    "                                                       test_size = 0.3, \n",
    "                                                       random_state=42,\n",
    "                                                       shuffle=True,\n",
    "                                                       stratify=y)\n",
    "    sc = StandardScaler()\n",
    "    X_train = sc.fit_transform(X_train)  \n",
    "    X_test  = sc.transform(X_test)\n",
    "    outlier_index = outlierDetect(pd.DataFrame(X_train))  \n",
    "    X_train = np.delete(X_train , outlier_index , axis=0)\n",
    "    y_train = np.array(y_train)\n",
    "    y_train = np.delete( y_train , outlier_index)\n",
    "    return np.array(X_train) , np.array(X_test) , np.array(y_train) , np.array(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train , X_test , y_train , y_test = loaddata()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(140, 9)\n",
      "(65, 9)\n",
      "(140,)\n",
      "(65,)\n"
     ]
    }
   ],
   "source": [
    "print(X_train.shape)\n",
    "print(X_test.shape)\n",
    "print(y_train.shape)\n",
    "print(y_test.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 5, 6, 7], dtype=int64)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x21c03d7d550>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.countplot(y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x21c040aada0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.countplot(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: 35.0, 1: 35.0, 7: 12.142857142857142, 3: 8.571428571428571, 5: 5.714285714285714, 6: 3.571428571428571}\n"
     ]
    }
   ],
   "source": [
    "x = dict((pd.value_counts(y_train)/pd.value_counts(y_train).sum())*100) # this used as weighted average \n",
    "# because we dont have same number of data for all classes\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(7,7))\n",
    "plt.pie(x.values(),labels=[2,1,7,3,5,6])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PseudoCode for kNN\n",
    "\n",
    "We can implement a KNN model by following the below steps:\n",
    "\n",
    "1. Load the data\n",
    "2. Initialise the value of k\n",
    "3. For getting the predicted class, iterate from 1 to total number of training data points\n",
    "    1. Calculate the distance between test data and each row of training data. Here we will use Euclidean distance as our distance metric since it’s the most popular method. The other metrics that can be used are Chebyshev, cosine, etc.\n",
    "    2. Sort the calculated distances in ascending order based on distance values\n",
    "    3. Get top k rows from the sorted array\n",
    "    4. Get the most frequent class of these rows\n",
    "    5. Return the predicted class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class kNN():\n",
    "    \n",
    "    def __init__(self,n_neighbors):\n",
    "        self.n_neighbors = n_neighbors\n",
    "        self.distance = []\n",
    "        self.index    = []\n",
    " \n",
    "    def euclieanDist(self,train,test):\n",
    "        sort = []\n",
    "        for i in range(train.shape[0]):\n",
    "            sort.append(np.sqrt(np.sum(np.square(train[i]-test))))\n",
    "        return sort\n",
    "\n",
    "    def fit(self,train,test):\n",
    "        for x in range(test.shape[0]):\n",
    "            dist = self.euclieanDist(train, test[x]) # all distance from test data to all training data\n",
    "            idex = list(np.argsort(dist)[:self.n_neighbors]) # sortdata with argument and select top k points\n",
    "            self.index.append(idex) \n",
    "            temp = []\n",
    "            for j in idex:\n",
    "                temp.append(dist[j])\n",
    "            self.distance.append(temp)\n",
    "            \n",
    "    def predict(self,y_train):\n",
    "        y_cap = []\n",
    "        for i in self.index:\n",
    "            y_ = []\n",
    "            for j in i:\n",
    "                y_.append(y_train[j])\n",
    "            y_cap.append(max(y_))\n",
    "        return np.array(y_cap)\n",
    "    \n",
    "    def score(self,y_pred,y_actual):\n",
    "        c=0\n",
    "        for i in range(len(y_pred)):\n",
    "            if y_pred[i] == y_actual[i]:\n",
    "                c+=1\n",
    "        return c/len(y_pred)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 7 7 7 2 6 3 2 2 1 1 5 3 7 2 6 2 2 6 7 1 7 7 3 3 2 7 5 1 2 1 7 2 2 6 2 7\n",
      " 2 5 2 1 2 2 1 3 1 1 2 1 1 1 1 1 2 1 2 2 2 7 5 2 7 2 2 2]\n",
      "0.7076923076923077\n"
     ]
    }
   ],
   "source": [
    "knn = kNN(n_neighbors=2)\n",
    "knn.fit(X_train,X_test)\n",
    "predict = knn.predict(y_train)\n",
    "print(predict)\n",
    "score = knn.score(predict,y_test)\n",
    "print(score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 7 7 1 2 3 1 2 1 1 2 1 7 2 2 1 2 6 7 1 7 7 2 1 1 7 2 1 2 1 7 2 1 6 2 7\n",
      " 2 2 1 1 2 1 1 2 1 1 2 1 1 1 1 1 2 1 1 2 1 7 2 2 2 1 2 2]\n",
      "0.7692307692307693\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "knn = KNeighborsClassifier(n_neighbors=2)\n",
    "knn.fit(X_train , y_train)\n",
    "predict = knn.predict(X_test)\n",
    "print(predict)\n",
    "print(knn.score(X_test,y_test))"
   ]
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}