Handwritten_Digit_Recognition.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(42000, 785)\n",
      "(42000, 785)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "%matplotlib inline \n",
    "\n",
    "import pandas as pd\n",
    "ds = pd.read_csv('./train.csv')\n",
    "# train.csv is mnist dataset of handwritten digits such that it contains each digit stored as 28x28\n",
    "# matrix which are compressed to 784(28*28) columns.\n",
    "# Also the dataset consists of 42000 rows with each row consisting of 785 columns where 0th column \n",
    "# represents the label(i.e what number that row actually represents) and rest 784 columns store the \n",
    "# 28x28 matrix data of handwritten digits \n",
    "print (ds.shape)\n",
    "\n",
    "data = ds.values\n",
    "print (data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(42000,) (42000, 784)\n",
      "8\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1f72b9f2518>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_train = data[:,0]   # this is the label part which tell which digit in the pics is\n",
    "x_train = data[:,1:]  # this is the feature vector which stores information about each digit's shape \n",
    "print (y_train.shape,x_train.shape) \n",
    "\n",
    "plt.figure(0)\n",
    "idx = 1204  # 1204th index in train.csv file\n",
    "print (y_train[idx])    # label stored at 1204th location\n",
    "plt.imshow(x_train[idx].reshape((28,28)),cmap = 'gray') # reshaping the label stored at 1204th location \n",
    "# to a 28*28 matrix to get its actual shape\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "((array([ 6.]), array([7], dtype=int64)), 6.0)\n",
      "6\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAADadJREFUeJzt3X2oVHUex/HPd0uxrkIPoiuaaw+ybISr20U2UmnZFDcM6w+j/rI29hYkrGS0dbOMlkCkh12IAkPxStnzk8myJhHqxmbZA2W5pZlb5uW6YZD1R6L3u3/cc3dvduc348w5c8b7fb9AZuZ855zzZfBzz5n5zZmfubsAxPOTshsAUA7CDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBEX4gqJObuTMz4+uEQMHc3Wp5XkNHfjOba2Yfm9luM7utkW0BaC6r97v9ZnaSpE8kzZa0T9Jbkq5x948S63DkBwrWjCP/dEm73X2Pux+W9KSk+Q1sD0ATNRL+8ZK+GPB4X7bsB8ysw8y2m9n2BvYFIGeNfOA32KnFj07r3X2lpJUSp/1AK2nkyL9P0lkDHk+QtL+xdgA0SyPhf0vSZDM728yGS7pa0vp82gJQtLpP+939iJktkrRR0kmSVrv7h7l1BqBQdQ/11bUz3vMDhWvKl3wAnLgIPxAU4QeCIvxAUIQfCIrwA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQhB8Iqqk/3Y14ZsyYUbG2cePG5LrDhg1L1mfNmpWsv/HGG8l6dBz5gaAIPxAU4QeCIvxAUIQfCIrwA0ERfiAoxvnRkAkTJiTra9asqVg75ZRTGtr3hRdemKwzzp/GkR8IivADQRF+ICjCDwRF+IGgCD8QFOEHgmponN/M9ko6JOmopCPu3p5HU2gdo0aNStY3bNiQrJ9zzjl177u3tzdZ7+npqXvbyOdLPr9x969y2A6AJuK0Hwiq0fC7pFfM7G0z68ijIQDN0ehp/8Xuvt/MxkjaZGb/cvctA5+Q/VHgDwPQYho68rv7/uz2gKQXJE0f5Dkr3b2dDwOB1lJ3+M2szcxG9d+XNEfSjrwaA1CsRk77x0p6wcz6t7PO3f+eS1cACld3+N19j6Rf5tgLSjBy5MhkfdWqVcn6lClT8mznB+68885k/dlnny1s3xEw1AcERfiBoAg/EBThB4Ii/EBQhB8Iyty9eTsza97OUJPzzz8/Wd+xo7jvbd1xxx3J+vLly5P1Zv7fPZG4u9XyPI78QFCEHwiK8ANBEX4gKMIPBEX4gaAIPxAUU3QPcTNmzEjWly1bVuj+U5fdrlixIrku4/jF4sgPBEX4gaAIPxAU4QeCIvxAUIQfCIrwA0FxPf8QMHz48Iq11157LbnuRRdd1NC+16xZk6wvXbq0Ym3//v0N7RuD43p+AEmEHwiK8ANBEX4gKMIPBEX4gaAIPxBU1XF+M1staZ6kA+5+QbbsDElPSZokaa+kq9z966o7Y5y/EKnft7/11lsb2vZnn32WrM+cOTNZZyy/+fIc518jae4xy26T9Kq7T5b0avYYwAmkavjdfYukg8csni+pK7vfJemKnPsCULB63/OPdfduScpux+TXEoBmKPw3/MysQ1JH0fsBcHzqPfL3mNk4ScpuD1R6oruvdPd2d2+vc18AClBv+NdLWpjdXyjppXzaAdAsVcNvZk9I+qekn5vZPjO7XtJySbPNbJek2dljACcQrucfAg4dOlSx1tbWllz38OHDyfott9ySrD/00EPJOpqP6/kBJBF+ICjCDwRF+IGgCD8QFOEHgmKK7hPAjTfemKyPGDGi7m1v3rw5WW90KG/s2LEVa5MnT25o259++mmy3t3d3dD2hzqO/EBQhB8IivADQRF+ICjCDwRF+IGgCD8QFJf0toDZs2cn6y+//HKynpqi+/vvv0+ue9lllyXr1ab4vvbaa5P1zs7OirXzzjsvuW417733XrJ++eWXV6x9+eWXDe27lXFJL4Akwg8ERfiBoAg/EBThB4Ii/EBQhB8Iiuv5W8Do0aOT9dQ4fjVbt25N1t99991kfenSpcn67bffnqyfeuqpFWuNfsdk6tSpyXpXV1fF2qWXXtrQvocCjvxAUIQfCIrwA0ERfiAowg8ERfiBoAg/EFTVcX4zWy1pnqQD7n5BtuxuSX+Q9J/saZ3u/reimhzqFi1a1ND6vb29FWsPPvhgct0XX3wxWZ81a1ZdPfVr5u9FHOvMM88sbd8nglqO/GskzR1k+YPuPjX7R/CBE0zV8Lv7FkkHm9ALgCZq5D3/IjN738xWm9npuXUEoCnqDf8jks6VNFVSt6T7Kz3RzDrMbLuZba9zXwAKUFf43b3H3Y+6e6+kRyVNTzx3pbu3u3t7vU0CyF9d4TezcQMeXilpRz7tAGiWWob6npB0iaTRZrZP0jJJl5jZVEkuaa+kGwrsEUABqobf3a8ZZPGqAnoJq62traH1X3/99Yq1uXMHG6X9v0bH8at58803K9Y2bNiQXHfVqvR/s6H82/vNwDf8gKAIPxAU4QeCIvxAUIQfCIrwA0Hx091DwMyZM+uqSdKRI0eS9e+++y5Zf/jhh5P1++67r2Lt6NGjyXU3bdqUrJvVNBM1KuDIDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBMc4f3K5du5L1BQsWJOuHDx9O1ufNm1extnjx4uS606ZNa2jfa9euTdaj48gPBEX4gaAIPxAU4QeCIvxAUIQfCIrwA0Exzt8CnnnmmWR9ypQphe174sSJyfoDDzyQrE+fXnGyJknSaaeddtw91Wrbtm3JerXpyaPjyA8ERfiBoAg/EBThB4Ii/EBQhB8IivADQVUd5zezsyStlfRTSb2SVrr7X83sDElPSZokaa+kq9z96+JaHbr27NlT2r6rTQ8+Z86cJnXyYzfffHOyvm7duiZ1MjTVcuQ/ImmJu/9C0q8l3WRm50u6TdKr7j5Z0qvZYwAniKrhd/dud38nu39I0k5J4yXNl9SVPa1L0hVFNQkgf8f1nt/MJkmaJmmbpLHu3i31/YGQNCbv5gAUp+bv9pvZSEnPSVrs7t/UOk+amXVI6qivPQBFqenIb2bD1Bf8x939+Wxxj5mNy+rjJB0YbF13X+nu7e7enkfDAPJRNfzWd4hfJWmnuw+8xGu9pIXZ/YWSXsq/PQBFMXdPP8FshqStkj5Q31CfJHWq733/05ImSvpc0gJ3P1hlW+mdBTVq1KhkfcmSJcn6XXfdlWc7TfPYY48l69ddd12yXm2K76jcvab35FXf87v7PyRV2thvj6cpAK2Db/gBQRF+ICjCDwRF+IGgCD8QFOEHgqo6zp/rzhjnr8uIESOS9c7Ozoq1YcOGJdcdPXp0sn799dcn67t3707W77nnnoq1apfk9vb2JusYXK3j/Bz5gaAIPxAU4QeCIvxAUIQfCIrwA0ERfiAoxvmBIYZxfgBJhB8IivADQRF+ICjCDwRF+IGgCD8QFOEHgiL8QFCEHwiK8ANBEX4gKMIPBEX4gaAIPxBU1fCb2Vlm9pqZ7TSzD83sj9nyu83sSzN7L/t3WfHtAshL1R/zMLNxksa5+ztmNkrS25KukHSVpG/d/b6ad8aPeQCFq/XHPE6uYUPdkrqz+4fMbKek8Y21B6Bsx/We38wmSZomaVu2aJGZvW9mq83s9ArrdJjZdjPb3lCnAHJV82/4mdlISZsl3evuz5vZWElfSXJJf1bfW4PfV9kGp/1AwWo97a8p/GY2TNIGSRvd/YFB6pMkbXD3C6psh/ADBcvtBzzNzCStkrRzYPCzDwL7XSlpx/E2CaA8tXzaP0PSVkkfSOqfM7lT0jWSpqrvtH+vpBuyDwdT2+LIDxQs19P+vBB+oHj8bj+AJMIPBEX4gaAIPxAU4QeCIvxAUIQfCIrwA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQVX/AM2dfSfr3gMejs2WtqFV7a9W+JHqrV569/azWJzb1ev4f7dxsu7u3l9ZAQqv21qp9SfRWr7J647QfCIrwA0GVHf6VJe8/pVV7a9W+JHqrVym9lfqeH0B5yj7yAyhJKeE3s7lm9rGZ7Taz28rooRIz22tmH2QzD5c6xVg2DdoBM9sxYNkZZrbJzHZlt4NOk1ZSby0xc3NiZulSX7tWm/G66af9ZnaSpE8kzZa0T9Jbkq5x94+a2kgFZrZXUru7lz4mbGazJH0raW3/bEhmtkLSQXdfnv3hPN3d/9Qivd2t45y5uaDeKs0sfa1KfO3ynPE6D2Uc+adL2u3ue9z9sKQnJc0voY+W5+5bJB08ZvF8SV3Z/S71/edpugq9tQR373b3d7L7hyT1zyxd6muX6KsUZYR/vKQvBjzep9aa8tslvWJmb5tZR9nNDGJs/8xI2e2Ykvs5VtWZm5vpmJmlW+a1q2fG67yVEf7BZhNppSGHi939V5J+J+mm7PQWtXlE0rnqm8atW9L9ZTaTzSz9nKTF7v5Nmb0MNEhfpbxuZYR/n6SzBjyeIGl/CX0Myt33Z7cHJL2gvrcpraSnf5LU7PZAyf38j7v3uPtRd++V9KhKfO2ymaWfk/S4uz+fLS79tRusr7JetzLC/5akyWZ2tpkNl3S1pPUl9PEjZtaWfRAjM2uTNEetN/vwekkLs/sLJb1UYi8/0CozN1eaWVolv3atNuN1KV/yyYYy/iLpJEmr3f3epjcxCDM7R31He6nvisd1ZfZmZk9IukR9V331SFom6UVJT0uaKOlzSQvcvekfvFXo7RId58zNBfVWaWbpbSrxtctzxutc+uEbfkBMfMMPCIrwA0ERfiAowg8ERfiBoAg/EBThB4Ii/EBQ/wVi2Bah5nkuzAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1f72b9df160>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# dist(x1,x2) calculate the euclidean distance b/w two variables\n",
    "def dist(x1,x2):\n",
    "    return np.sqrt(((x1-x2)**2).sum())\n",
    "\n",
    "def KNN(x_train_data,query_point,label_y_train,k=7):\n",
    "    vals = []\n",
    "    \n",
    "    for ix in range(x_train_data.shape[0]):\n",
    "        v = [dist(query_point,x_train_data[ix, :]),label_y_train[ix]]\n",
    "        vals.append(v)\n",
    "        \n",
    "        \n",
    "    updated_vals = sorted(vals,key=lambda x : x[0]) # lambda x[0] means sorting on the basis of euclidean \n",
    "    # distance\n",
    "    pred_ar = np.array(updated_vals[:k]) # selecting first k entries from sorted array\n",
    "    \n",
    "    # selecting only unique entries along with their counts\n",
    "    # NOTE: Here [;,1] means using the label column for calculating the count\n",
    "    pred_ar = np.unique(pred_ar[:,1],return_counts=True)\n",
    "    \n",
    "    # storing the index of the entry with maximum count\n",
    "    pred_idx = pred_ar[1].argmax()\n",
    "    \n",
    "    # returning the pred_ar array which represents the label and its count, and returning the label of \n",
    "    # index with maximum count i.e. pred_ar[0][pred_idx]\n",
    "    return pred_ar,pred_ar[0][pred_idx]\n",
    "\n",
    "\n",
    "iq = int(np.random.random()*x_train.shape[0])  # randomly picks up an index from the training dataset\n",
    "query_point = x_train[iq] # query point containing 784 columns of information about the digit stored \n",
    "# at iq location \n",
    "\n",
    "# we are testing the query_point against the first 10000 entries of the training dataset\n",
    "res = KNN(x_train[:1000],query_point,y_train[:1000])\n",
    "\n",
    "print (res)\n",
    "\n",
    "print (y_train[iq])\n",
    "\n",
    "plt.figure(0)\n",
    "plt.imshow(query_point.reshape((28,28)),cmap='gray')\n",
    "plt.show()"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}