KNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parameters:\t\n",
    "\n",
    "k = int, optional (default = 3)\n",
    "Number of neighbours per neighbourhood\n",
    "\n",
    "metric = string, default 'euclidean'\n",
    "Distance metric used to compare relative distances. Default = 'euclidean' where p=2 using minkowski distance.\n",
    "\n",
    "Methods:\n",
    "\n",
    "classify(x,class_x,y) where x = training datapoints (NxD),\n",
    "                            class_x = classes of the datapoints used for training(x) (NxD),\n",
    "                            y = datapoints to be classifed (test set) (PxS)\n",
    "                      Returns:\n",
    "                            predictions = array of class predictions (PxS)\n",
    "                \n",
    "error(class_y) where class_y = true classes corresponding to test set (PxS)\n",
    "               Returns:\n",
    "                     score - percentage accuracy of the model\n",
    "                         \n",
    "                            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class KNN:\n",
    "    def __init__(self,k=3,metric='euclidean'):\n",
    "        self.k = k\n",
    "        self.metric = metric\n",
    "        if metric == 'euclidean':\n",
    "            self.p=2\n",
    "        elif metric == 'minkowski':\n",
    "            self.p=1\n",
    "    \n",
    "    # calculates distance between points, default = 'euclidean'\n",
    "    def distance_metric(self,x,y):\n",
    "        return scipy.spatial.distance.minkowski(x,y,self.p)\n",
    "\n",
    "    # model is trained on x and predicts classes for y\n",
    "    def classify(self,x,class_x,y):\n",
    "        if self.k>len(x):\n",
    "            raise Exception('K cant be greater than the number of training examples')\n",
    "        \n",
    "        # Calculate distance matrix between training and test points\n",
    "        distance = np.array([])\n",
    "        for i in range(len(x)):\n",
    "            for j in range(len(y)):\n",
    "                distance = np.append(distance,self.distance_metric(x[i],y[j]))\n",
    "        distance = np.reshape(distance,(len(x),len(y))).T\n",
    "        \n",
    "        # Locate minimum distances and compute corresponding classes\n",
    "        self.prediction = np.array([])\n",
    "        for loc in range(distance.shape[0]):\n",
    "            arranged = np.argsort(distance[loc])[:self.k]\n",
    "            count = np.argmax(np.bincount(np.reshape(class_x[arranged],(len(arranged),))))\n",
    "            self.prediction = np.append(self.prediction,count)\n",
    "            \n",
    "        return self.prediction.astype(int)\n",
    "    \n",
    "    # Calculates percentage accuracy of the classifier\n",
    "    def error(self,class_y):\n",
    "        count = len(np.where(self.prediction==class_y)[0])\n",
    "        return (count/len(class_y))*100\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class predictions:  [2 1 0 2 1 0 1 0 1 1 0 1 0 1 0 2 0 0 0 1 1 1 2 0 0 1 2 1 0 2 0 1 0 1 0 0 0\n",
      " 2 1 1 0 2 1 2 2 1 2 2 0 2 0 2 1 2 0 0 2 0 0 1 2 2 1 0 0 0 0 2 0 0 0 0 1 2\n",
      " 0 2 0 2 1 1 2 0 2 0 1 1 2 1 2 0 0 0 2 1 1 2 0 2 1 1 2 2 1 1 1 2 2 1 1 0 0\n",
      " 1 0]\n",
      "Classifier score: 96.46017699115043\n"
     ]
    }
   ],
   "source": [
    "from sklearn import datasets\n",
    "iris = datasets.load_iris()\n",
    "\n",
    "X = iris.data\n",
    "Y = iris.target\n",
    "\n",
    "from sklearn.cross_validation import train_test_split\n",
    "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = .75)\n",
    "\n",
    "k = KNN(k=3,metric='euclidean')\n",
    "predictions = k.classify(X_train,Y_train,X_test)\n",
    "score = k.error(Y_test)\n",
    "print(\"Class predictions: \",predictions)\n",
    "print(\"Classifier score:\",score)"
   ]
  },
  {
   "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": []
  },
  {
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}