knn_classifier_pokemons.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Import useful libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "from keras.preprocessing import image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Loading and Cleaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\rajni\\Anaconda3\\envs\\tensorflow\\lib\\site-packages\\PIL\\Image.py:965: UserWarning: Palette images with Transparency   expressed in bytes should be converted to RGBA images\n",
      "  ' expressed in bytes should be converted ' +\n"
     ]
    }
   ],
   "source": [
    "labels_converter = {'Pikachu':0, 'Bulbasaur':1, 'Charmander':2}\n",
    "rev_labels = {0:'Pikachu', 1:'Bulbasaur', 2:'Charmander'}\n",
    "\n",
    "image_data = {}\n",
    "\n",
    "p = Path('Images')\n",
    "\n",
    "for d in p.glob('*.jpg'):\n",
    "    data = image.load_img(d,target_size=(100,100))\n",
    "    image_data.setdefault(str(d).split('\\\\')[1], np.array(data))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "pokemon = pd.read_csv('train.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 269,
   "metadata": {},
   "outputs": [],
   "source": [
    "pdata = np.array(pokemon)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_ = [] #input data\n",
    "Y_ = [] #input labels\n",
    "for i in pdata[:,0]:\n",
    "    \n",
    "    #store image pixel data in X\n",
    "    temp = np.array(image_data.get(i))\n",
    "    X_.append(temp.flatten())\n",
    "    \n",
    "for j in pdata[:,1]:\n",
    "    \n",
    "    #store labels in Y\n",
    "    Y_.append(labels_converter.get(j))\n",
    "    \n",
    "X = np.array(X_)\n",
    "Y = np.array(Y_)   \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # KNN Classifier model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [],
   "source": [
    "def distance(a, b):\n",
    "    '''Helper function for getting distance b/w 2 pts.\n",
    "    '''\n",
    "    return np.sum((a-b)**2)**.5\n",
    "\n",
    "def KNN(X, Y, test_input, k=5):\n",
    "    '''K-Nearest-Neighbours algorithm implementation\n",
    "    '''\n",
    "    \n",
    "    flattened_input = test_input.flatten()\n",
    "    iter_range = X.shape[0]\n",
    "    dist_list = []\n",
    "    \n",
    "    for i in range(iter_range):\n",
    "        \n",
    "        dist = distance(flattened_input, X[i])\n",
    "        dist_list.append((dist, Y[i]))\n",
    "    \n",
    "    sorted_dist_list = np.array(sorted(dist_list), dtype = 'int')\n",
    "    n_neigh = np.unique(sorted_dist_list[:k,1], return_counts = 'True')\n",
    "    index = np.argmax(n_neigh[1])\n",
    "    \n",
    "    #however, most weight is given to that element, who's distance from\n",
    "    #test_input is zero\n",
    "    for i in range(sorted_dist_list.shape[0]):\n",
    "        if sorted_dist_list[i][0] == 0:\n",
    "            index = i\n",
    "            \n",
    "    return rev_labels.get(sorted_dist_list[index][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Test Phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_csv = pd.read_csv('test.csv')\n",
    "test_array = np.array(test_csv)\n",
    "\n",
    "#Create submission file as submissionn.csv\n",
    "f = open('submission.csv', 'a')\n",
    "f.write('ImageId,NameOfPokemon\\n')\n",
    "\n",
    "\n",
    "#load data from image_data to test_imaage_data\n",
    "test_image_data = []\n",
    "test_image_name = []\n",
    "\n",
    "for i in test_array[:,0]:\n",
    "    test_image_data.append(image_data.get(i))\n",
    "    test_image_name.append(i)\n",
    "\n",
    "#finally, write everything in the submission file, and then close the file    \n",
    "for i in range(len(test_image_data)):\n",
    "    f.write(test_image_name[i] + ',' + KNN(X, Y, test_image_data[i], 2) + '\\n')\n",
    "    \n",
    "f.close()    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bulbasaur\n"
     ]
    }
   ],
   "source": [
    "test_image = np.array(image.load_img('Images\\\\2031.jpg', target_size = (100,100)))\n",
    "\n",
    "a = KNN(X, Y, test_image)\n",
    "print(a)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.6 (tensorflow)",
   "language": "python",
   "name": "tensorflow"
  },
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}