K_Nearest_Neighbors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Part 3 - K Nearest Neighbors (KNN)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### By Aziz Presswala"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Aziz\\Anaconda3\\lib\\site-packages\\sklearn\\cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.\n",
      "  \"This module will be removed in 0.20.\", DeprecationWarning)\n",
      "C:\\Users\\Aziz\\Anaconda3\\lib\\site-packages\\gensim\\utils.py:1209: UserWarning: detected Windows; aliasing chunkize to chunkize_serial\n",
      "  warnings.warn(\"detected Windows; aliasing chunkize to chunkize_serial\")\n"
     ]
    }
   ],
   "source": [
    "#importing libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sn\n",
    "import sqlite3\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "from prettytable import PrettyTable\n",
    "\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "from sklearn.feature_extraction.text import TfidfTransformer\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "from sklearn.cross_validation import train_test_split\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.cross_validation import cross_val_score\n",
    "from collections import Counter\n",
    "from sklearn.metrics import accuracy_score\n",
    "from sklearn.metrics import f1_score\n",
    "from sklearn.metrics import confusion_matrix\n",
    "from sklearn import cross_validation\n",
    "from gensim.models import Word2Vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(364171, 12)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using the CleanedText column saved in final.sqlite db\n",
    "con = sqlite3.connect('final.sqlite')\n",
    "filtered_data = pd.read_sql_query(\"SELECT * FROM Reviews\", con)\n",
    "filtered_data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#randomly selecting 60k points from the dataset\n",
    "#tried with 100k points but showed memory error\n",
    "df=filtered_data.sample(60000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#sort the dataset by timestamp\n",
    "df = df.sort_values('Time')\n",
    "#splitting the dataset into train(70%) & test(30%)\n",
    "train_data = df[0:42000]\n",
    "test_data = df[42000:60000]\n",
    "#saving the train and test datasets in csv files\n",
    "train_data.to_csv('train.csv')\n",
    "test_data.to_csv('test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#selecting 10k points to implement kd-tree\n",
    "train_data_kd = df[0:7000]\n",
    "test_data_kd = df[7000:10000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BoW"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cross Validation(brute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(42000, 2000)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#applying fit transform on train datasset\n",
    "count_vect = CountVectorizer(max_features=2000, min_df=50)\n",
    "x_train_bow = count_vect.fit_transform(train_data['CleanedText'].values)\n",
    "x_train_bow.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(18000, 2000)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#applying transform on test dataset\n",
    "x_test_bow = count_vect.transform(test_data['CleanedText'].values)\n",
    "x_test_bow.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_bow = train_data['Score']\n",
    "y_test_bow = test_data['Score']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CV f1-score for k = 1 is 0.900763\n",
      "\n",
      "CV f1-score for k = 3 is 0.917187\n",
      "\n",
      "CV f1-score for k = 5 is 0.920492\n",
      "\n",
      "CV f1-score for k = 7 is 0.920743\n",
      "\n",
      "CV f1-score for k = 9 is 0.921038\n",
      "\n",
      "CV f1-score for k = 11 is 0.920895\n",
      "\n",
      "CV f1-score for k = 13 is 0.920606\n",
      "\n",
      "CV f1-score for k = 15 is 0.920694\n",
      "\n",
      "CV f1-score for k = 17 is 0.920800\n",
      "\n",
      "CV f1-score for k = 19 is 0.920813\n",
      "\n",
      "CV f1-score for k = 21 is 0.920860\n",
      "\n",
      "CV f1-score for k = 23 is 0.920774\n",
      "\n",
      "CV f1-score for k = 25 is 0.920715\n",
      "\n",
      "CV f1-score for k = 27 is 0.920597\n",
      "\n",
      "CV f1-score for k = 29 is 0.920518\n",
      "\n",
      "The optimal number of neighbors is 9.\n",
      "\n",
      "****Test f1-score for k = 9 is 0.904950****\n",
      "\n",
      "****Test accuracy for k = 9 is 82.750000%****\n"
     ]
    }
   ],
   "source": [
    "# split the train data set into cross validation train and cross validation test\n",
    "X_tr, X_cv, y_tr, y_cv = cross_validation.train_test_split(x_train_bow, y_train_bow, test_size=0.3)\n",
    "\n",
    "f1_scores=[]\n",
    "myList = list(range(0,30))\n",
    "neighbors = list(filter(lambda x: x % 2 != 0, myList))\n",
    "\n",
    "for i in neighbors:\n",
    "    # instantiate learning model (k = 30)\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, algorithm='brute')\n",
    "\n",
    "    # fitting the model on crossvalidation train\n",
    "    knn.fit(X_tr, y_tr)\n",
    "\n",
    "    # predict the response on the crossvalidation train\n",
    "    pred = knn.predict(X_cv)\n",
    "    \n",
    "    #evaluate CV f1-score\n",
    "    f1 = f1_score(y_cv, pred, pos_label='positive', average='binary')\n",
    "    \n",
    "    #printing f1-score of positive class for each k\n",
    "    print('\\nCV f1-score for k = %d is %f' % (i, f1))\n",
    "    f1_scores.append(f1)\n",
    "    \n",
    "\n",
    "# determining optimal k\n",
    "optimal_k = neighbors[f1_scores.index(max(f1_scores))]\n",
    "print('\\nThe optimal number of neighbors is %d.' % optimal_k)\n",
    "\n",
    "knn = KNeighborsClassifier(optimal_k)\n",
    "knn.fit(X_tr,y_tr)\n",
    "pred = knn.predict(x_test_bow)\n",
    "\n",
    "#determining the Test f1 score for optimal k\n",
    "f1 = f1_score(y_test_bow, pred, pos_label='positive', average='binary')\n",
    "print('\\n****Test f1-score for k = %d is %f****' % (optimal_k,f1))\n",
    "\n",
    "#determining the Test accuracy for optimal k\n",
    "acc = accuracy_score(y_test_bow, pred, normalize=True) * float(100)\n",
    "print('\\n****Test accuracy for k = %d is %f%%****' % (optimal_k,acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1550eb57080>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The f1-score for each k value is :  [0.90076 0.91719 0.92049 0.92074 0.92104 0.9209  0.92061 0.92069 0.9208\n",
      " 0.92081 0.92086 0.92077 0.92072 0.9206  0.92052]\n"
     ]
    }
   ],
   "source": [
    "# plot f1-score vs k \n",
    "plt.figure(figsize=(15,10))\n",
    "plt.plot(neighbors, f1_scores)\n",
    "for xy in zip(neighbors, np.round(f1_scores,3)):\n",
    "    plt.annotate('(%s, %s)' % xy, xy=xy, textcoords='data')\n",
    "\n",
    "plt.xlabel('Number of Neighbors K')\n",
    "plt.ylabel('f1-score')\n",
    "plt.show()\n",
    "\n",
    "print(\"The f1-score for each k value is : \", np.round(f1_scores,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cross Validation (kd-tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#applying fit transform on train datasset\n",
    "count_vect = CountVectorizer(max_features=2000, min_df=50)\n",
    "x_train_bow_kd = count_vect.fit_transform(train_data_kd['CleanedText'].values)\n",
    "\n",
    "#applying transform on test dataset\n",
    "x_test_bow_kd = count_vect.transform(test_data_kd['CleanedText'].values)\n",
    "\n",
    "#class labels for train & test datasets\n",
    "y_train_bow_kd = train_data_kd['Score']\n",
    "y_test_bow_kd = test_data_kd['Score']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CV f1-score for k = 1 is 0.897166\n",
      "\n",
      "CV f1-score for k = 3 is 0.923837\n",
      "\n",
      "CV f1-score for k = 5 is 0.933539\n",
      "\n",
      "CV f1-score for k = 7 is 0.937277\n",
      "\n",
      "CV f1-score for k = 9 is 0.937707\n",
      "\n",
      "CV f1-score for k = 11 is 0.939117\n",
      "\n",
      "CV f1-score for k = 13 is 0.941743\n",
      "\n",
      "CV f1-score for k = 15 is 0.940582\n",
      "\n",
      "CV f1-score for k = 17 is 0.941355\n",
      "\n",
      "CV f1-score for k = 19 is 0.940612\n",
      "\n",
      "CV f1-score for k = 21 is 0.940434\n",
      "\n",
      "CV f1-score for k = 23 is 0.940167\n",
      "\n",
      "CV f1-score for k = 25 is 0.940434\n",
      "\n",
      "CV f1-score for k = 27 is 0.940197\n",
      "\n",
      "CV f1-score for k = 29 is 0.940197\n",
      "\n",
      "The optimal number of neighbors is 13.\n",
      "\n",
      "****Test f1-score for k = 13 is 0.936420****\n",
      "\n",
      "****Test accuracy for k = 13 is 88.100000%****\n"
     ]
    }
   ],
   "source": [
    "# split the train data set into cross validation train and cross validation test\n",
    "X_tr, X_cv, y_tr, y_cv = cross_validation.train_test_split(x_train_bow_kd.toarray(), y_train_bow_kd, test_size=0.3)\n",
    "\n",
    "f1_scores=[]\n",
    "myList = list(range(0,30))\n",
    "neighbors = list(filter(lambda x: x % 2 != 0, myList))\n",
    "\n",
    "for i in neighbors:\n",
    "    # instantiate learning model (k = 30)\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, algorithm='kd_tree')\n",
    "\n",
    "    # fitting the model on crossvalidation train\n",
    "    knn.fit(X_tr, y_tr)\n",
    "\n",
    "    # predict the response on the crossvalidation train\n",
    "    pred = knn.predict(X_cv)\n",
    "    \n",
    "    #evaluate CV f1-score\n",
    "    f1 = f1_score(y_cv, pred, pos_label='positive', average='binary')\n",
    "    \n",
    "    #printing f1-score of positive class for each k\n",
    "    print('\\nCV f1-score for k = %d is %f' % (i, f1))\n",
    "    f1_scores.append(f1)\n",
    "\n",
    "# determining optimal k\n",
    "optimal_k = neighbors[f1_scores.index(max(f1_scores))]\n",
    "print('\\nThe optimal number of neighbors is %d.' % optimal_k)\n",
    "\n",
    "knn = KNeighborsClassifier(optimal_k)\n",
    "knn.fit(X_tr,y_tr)\n",
    "pred = knn.predict(x_test_bow_kd.toarray())\n",
    "#determining the Test f1 score for optimal k\n",
    "f1 = f1_score(y_test_bow_kd, pred, pos_label='positive', average='binary')\n",
    "print('\\n****Test f1-score for k = %d is %f****' % (optimal_k,f1))\n",
    "#determining the Test accuracy for optimal k\n",
    "acc = accuracy_score(y_test_bow_kd, pred, normalize=True) * float(100)\n",
    "print('\\n****Test accuracy for k = %d is %f%%****' % (optimal_k,acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  114  3033]\n",
      " [   72 14781]]\n"
     ]
    }
   ],
   "source": [
    "#computing confusion matrix\n",
    "cm = confusion_matrix(y_test_bow, pred)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x15516f73b00>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1550e65de80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plotting confusion matrix as heatmap\n",
    "df_cm = pd.DataFrame(cm, range(2),range(2))\n",
    "sn.set(font_scale=1.4) #for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 16}) #font size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TF-IDF"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cross Validation(brute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(42000, 2000)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#applying fit transform on train datasset\n",
    "tf_idf_vect = TfidfVectorizer(max_features=2000, min_df=50)\n",
    "x_train_tfidf = tf_idf_vect.fit_transform(train_data['CleanedText'].values)\n",
    "x_train_tfidf.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(18000, 2000)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#applying transform on test dataset\n",
    "x_test_tfidf = tf_idf_vect.transform(test_data['CleanedText'].values)\n",
    "x_test_tfidf.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train_tfidf = train_data['Score']\n",
    "y_test_tfidf = test_data['Score']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CV f1-score for k = 1 is 0.913115\n",
      "\n",
      "CV f1-score for k = 3 is 0.918770\n",
      "\n",
      "CV f1-score for k = 5 is 0.922333\n",
      "\n",
      "CV f1-score for k = 7 is 0.923303\n",
      "\n",
      "CV f1-score for k = 9 is 0.923721\n",
      "\n",
      "CV f1-score for k = 11 is 0.923727\n",
      "\n",
      "CV f1-score for k = 13 is 0.924039\n",
      "\n",
      "CV f1-score for k = 15 is 0.923840\n",
      "\n",
      "CV f1-score for k = 17 is 0.923482\n",
      "\n",
      "CV f1-score for k = 19 is 0.923495\n",
      "\n",
      "CV f1-score for k = 21 is 0.923435\n",
      "\n",
      "CV f1-score for k = 23 is 0.923534\n",
      "\n",
      "CV f1-score for k = 25 is 0.923594\n",
      "\n",
      "CV f1-score for k = 27 is 0.923382\n",
      "\n",
      "CV f1-score for k = 29 is 0.923541\n",
      "\n",
      "The optimal number of neighbors is 13.\n",
      "\n",
      "****Test f1-score for k = 13 is 0.910450****\n",
      "\n",
      "****Test accuracy for k = 13 is 83.822222%****\n"
     ]
    }
   ],
   "source": [
    "# split the train data set into cross validation train and cross validation test\n",
    "X_tr, X_cv, y_tr, y_cv = cross_validation.train_test_split(x_train_tfidf, y_train_tfidf, test_size=0.3)\n",
    "\n",
    "f1_scores=[]\n",
    "myList = list(range(0,30))\n",
    "neighbors = list(filter(lambda x: x % 2 != 0, myList))\n",
    "\n",
    "for i in neighbors:\n",
    "    # instantiate learning model (k = 30)\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, algorithm='brute')\n",
    "\n",
    "    # fitting the model on crossvalidation train\n",
    "    knn.fit(X_tr, y_tr)\n",
    "\n",
    "    # predict the response on the crossvalidation train\n",
    "    pred = knn.predict(X_cv)\n",
    "    \n",
    "    #evaluate CV f1-score\n",
    "    f1 = f1_score(y_cv, pred, pos_label='positive', average='binary')\n",
    "    \n",
    "    #printing f1-score of positive class for each k\n",
    "    print('\\nCV f1-score for k = %d is %f' % (i, f1))\n",
    "    f1_scores.append(f1)\n",
    "    \n",
    "\n",
    "# determining optimal k\n",
    "optimal_k = neighbors[f1_scores.index(max(f1_scores))]\n",
    "print('\\nThe optimal number of neighbors is %d.' % optimal_k)\n",
    "\n",
    "knn = KNeighborsClassifier(optimal_k)\n",
    "knn.fit(X_tr,y_tr)\n",
    "pred = knn.predict(x_test_tfidf)\n",
    "\n",
    "#determining the Test f1 score for optimal k\n",
    "f1 = f1_score(y_test_tfidf, pred, pos_label='positive', average='binary')\n",
    "print('\\n****Test f1-score for k = %d is %f****' % (optimal_k,f1))\n",
    "\n",
    "#determining the Test accuracy for optimal k\n",
    "acc = accuracy_score(y_test_tfidf, pred, normalize=True) * float(100)\n",
    "print('\\n****Test accuracy for k = %d is %f%%****' % (optimal_k,acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1550bf50278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The f1-score for each k value is :  [0.91312 0.91877 0.92233 0.9233  0.92372 0.92373 0.92404 0.92384 0.92348\n",
      " 0.92349 0.92344 0.92353 0.92359 0.92338 0.92354]\n"
     ]
    }
   ],
   "source": [
    "# plot f1-score vs k \n",
    "plt.figure(figsize=(15,10))\n",
    "plt.plot(neighbors, f1_scores)\n",
    "for xy in zip(neighbors, np.round(f1_scores,3)):\n",
    "    plt.annotate('(%s, %s)' % xy, xy=xy, textcoords='data')\n",
    "\n",
    "plt.xlabel('Number of Neighbors K')\n",
    "plt.ylabel('f1-score')\n",
    "plt.show()\n",
    "\n",
    "print(\"The f1-score for each k value is : \", np.round(f1_scores,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cross Validation (kd-tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#applying fit transform on train datasset\n",
    "count_vect = CountVectorizer(max_features=2000, min_df=50)\n",
    "x_train_tfidf_kd = count_vect.fit_transform(train_data_kd['CleanedText'].values)\n",
    "\n",
    "#applying transform on test dataset\n",
    "x_test_tfidf_kd = count_vect.transform(test_data_kd['CleanedText'].values)\n",
    "\n",
    "#class labels for train & test datasets\n",
    "y_train_tfidf_kd = train_data_kd['Score']\n",
    "y_test_tfidf_kd = test_data_kd['Score']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CV f1-score for k = 1 is 0.917127\n",
      "\n",
      "CV f1-score for k = 3 is 0.940367\n",
      "\n",
      "CV f1-score for k = 5 is 0.943024\n",
      "\n",
      "CV f1-score for k = 7 is 0.944683\n",
      "\n",
      "CV f1-score for k = 9 is 0.943253\n",
      "\n",
      "CV f1-score for k = 11 is 0.944318\n",
      "\n",
      "CV f1-score for k = 13 is 0.943815\n",
      "\n",
      "CV f1-score for k = 15 is 0.944640\n",
      "\n",
      "CV f1-score for k = 17 is 0.944109\n",
      "\n",
      "CV f1-score for k = 19 is 0.943634\n",
      "\n",
      "CV f1-score for k = 21 is 0.944403\n",
      "\n",
      "CV f1-score for k = 23 is 0.944403\n",
      "\n",
      "CV f1-score for k = 25 is 0.944165\n",
      "\n",
      "CV f1-score for k = 27 is 0.943928\n",
      "\n",
      "CV f1-score for k = 29 is 0.943928\n",
      "\n",
      "The optimal number of neighbors is 7.\n",
      "\n",
      "****Test f1-score for k = 7 is 0.933929****\n",
      "\n",
      "****Test accuracy for k = 7 is 87.666667%****\n"
     ]
    }
   ],
   "source": [
    "# split the train data set into cross validation train and cross validation test\n",
    "X_tr, X_cv, y_tr, y_cv = cross_validation.train_test_split(x_train_tfidf_kd.toarray(), y_train_tfidf_kd, test_size=0.3)\n",
    "\n",
    "f1_scores=[]\n",
    "myList = list(range(0,30))\n",
    "neighbors = list(filter(lambda x: x % 2 != 0, myList))\n",
    "\n",
    "for i in neighbors:\n",
    "    # instantiate learning model (k = 30)\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, algorithm='kd_tree')\n",
    "\n",
    "    # fitting the model on crossvalidation train\n",
    "    knn.fit(X_tr, y_tr)\n",
    "\n",
    "    # predict the response on the crossvalidation train\n",
    "    pred = knn.predict(X_cv)\n",
    "    \n",
    "    #evaluate CV f1-score\n",
    "    f1 = f1_score(y_cv, pred, pos_label='positive', average='binary')\n",
    "    \n",
    "    #printing f1-score of positive class for each k\n",
    "    print('\\nCV f1-score for k = %d is %f' % (i, f1))\n",
    "    f1_scores.append(f1)\n",
    "\n",
    "# determining optimal k\n",
    "optimal_k = neighbors[f1_scores.index(max(f1_scores))]\n",
    "print('\\nThe optimal number of neighbors is %d.' % optimal_k)\n",
    "\n",
    "knn = KNeighborsClassifier(optimal_k)\n",
    "knn.fit(X_tr,y_tr)\n",
    "pred = knn.predict(x_test_tfidf_kd.toarray())\n",
    "#determining the Test f1 score for optimal k\n",
    "f1 = f1_score(y_test_tfidf_kd, pred, pos_label='positive', average='binary')\n",
    "print('\\n****Test f1-score for k = %d is %f****' % (optimal_k,f1))\n",
    "#determining the Test accuracy for optimal k\n",
    "acc = accuracy_score(y_test_tfidf_kd, pred, normalize=True) * float(100)\n",
    "print('\\n****Test accuracy for k = %d is %f%%****' % (optimal_k,acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  285  2862]\n",
      " [   50 14803]]\n"
     ]
    }
   ],
   "source": [
    "#computing confusion matrix\n",
    "cm = confusion_matrix(y_test_tfidf, pred)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1550e79d9b0>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1550e65dda0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plotting confusion matrix as heatmap\n",
    "df_cm = pd.DataFrame(cm, range(2),range(2))\n",
    "sn.set(font_scale=1.4) #for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 16}) #font size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Avg Word2Vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cross Validation (brute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training Word2Vec Model for train dataset\n",
    "i=0\n",
    "list_of_sent=[]\n",
    "for sent in train_data['CleanedText'].values:\n",
    "    list_of_sent.append(sent.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "w2v_model=Word2Vec(list_of_sent,min_count=5,size=50, workers=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Aziz\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "X = w2v_model[w2v_model.wv.vocab]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████| 42000/42000 [03:32<00:00, 197.75it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42000\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "#computing Avg Word2Vec for train dataset\n",
    "w2v_words = list(w2v_model.wv.vocab)\n",
    "sent_vectors = []; # the avg-w2v for each sentence/review is stored in this list\n",
    "for sent in tqdm(list_of_sent): # for each review/sentence\n",
    "    sent_vec = np.zeros(50) # as word vectors are of zero length\n",
    "    cnt_words =0; # num of words with a valid vector in the sentence/review\n",
    "    for word in sent: # for each word in a review/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            sent_vec += vec\n",
    "            cnt_words += 1\n",
    "    if cnt_words != 0:\n",
    "        sent_vec /= cnt_words\n",
    "    sent_vectors.append(sent_vec)\n",
    "print(len(sent_vectors))\n",
    "print(len(sent_vectors[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(42000, 50)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train_w2v = np.array(sent_vectors)\n",
    "y_train_w2v = train_data['Score']\n",
    "x_train_w2v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training Word2Vec Model for test dataset\n",
    "i=0\n",
    "list_of_sent=[]\n",
    "for sent in test_data['CleanedText'].values:\n",
    "    list_of_sent.append(sent.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████| 18000/18000 [01:51<00:00, 161.90it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18000\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "#computing Avg Word2Vec for test dataset\n",
    "w2v_words = list(w2v_model.wv.vocab)\n",
    "sent_vectors = []; # the avg-w2v for each sentence/review is stored in this list\n",
    "for sent in tqdm(list_of_sent): # for each review/sentence\n",
    "    sent_vec = np.zeros(50) # as word vectors are of zero length\n",
    "    cnt_words =0; # num of words with a valid vector in the sentence/review\n",
    "    for word in sent: # for each word in a review/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            sent_vec += vec\n",
    "            cnt_words += 1\n",
    "    if cnt_words != 0:\n",
    "        sent_vec /= cnt_words\n",
    "    sent_vectors.append(sent_vec)\n",
    "print(len(sent_vectors))\n",
    "print(len(sent_vectors[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(18000, 50)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test_w2v = np.array(sent_vectors)\n",
    "y_test_w2v = test_data['Score']\n",
    "x_test_w2v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CV f1-score for k = 1 is 0.904874\n",
      "\n",
      "CV f1-score for k = 3 is 0.922530\n",
      "\n",
      "CV f1-score for k = 5 is 0.928206\n",
      "\n",
      "CV f1-score for k = 7 is 0.930175\n",
      "\n",
      "CV f1-score for k = 9 is 0.931214\n",
      "\n",
      "CV f1-score for k = 11 is 0.931748\n",
      "\n",
      "CV f1-score for k = 13 is 0.931580\n",
      "\n",
      "CV f1-score for k = 15 is 0.932022\n",
      "\n",
      "CV f1-score for k = 17 is 0.932363\n",
      "\n",
      "CV f1-score for k = 19 is 0.932241\n",
      "\n",
      "CV f1-score for k = 21 is 0.932242\n",
      "\n",
      "CV f1-score for k = 23 is 0.932068\n",
      "\n",
      "CV f1-score for k = 25 is 0.931636\n",
      "\n",
      "CV f1-score for k = 27 is 0.930940\n",
      "\n",
      "CV f1-score for k = 29 is 0.931244\n",
      "\n",
      "The optimal number of neighbors is 17.\n",
      "\n",
      "****Test f1-score for k = 17 is 0.919124****\n",
      "\n",
      "****Test accuracy for k = 17 is 85.677778%****\n"
     ]
    }
   ],
   "source": [
    "# split the train data set into cross validation train and cross validation test\n",
    "X_tr, X_cv, y_tr, y_cv = cross_validation.train_test_split(x_train_w2v, y_train_w2v, test_size=0.3)\n",
    "\n",
    "f1_scores=[]\n",
    "myList = list(range(0,30))\n",
    "neighbors = list(filter(lambda x: x % 2 != 0, myList))\n",
    "\n",
    "for i in neighbors:\n",
    "    # instantiate learning model (k = 30)\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, algorithm='brute')\n",
    "\n",
    "    # fitting the model on crossvalidation train\n",
    "    knn.fit(X_tr, y_tr)\n",
    "\n",
    "    # predict the response on the crossvalidation train\n",
    "    pred = knn.predict(X_cv)\n",
    "    \n",
    "    #evaluate CV f1-score\n",
    "    f1 = f1_score(y_cv, pred, pos_label='positive', average='binary')\n",
    "    \n",
    "    #printing f1-score of positive class for each k\n",
    "    print('\\nCV f1-score for k = %d is %f' % (i, f1))\n",
    "    f1_scores.append(f1)\n",
    "    \n",
    "\n",
    "# determining optimal k\n",
    "optimal_k = neighbors[f1_scores.index(max(f1_scores))]\n",
    "print('\\nThe optimal number of neighbors is %d.' % optimal_k)\n",
    "\n",
    "knn = KNeighborsClassifier(optimal_k)\n",
    "knn.fit(X_tr,y_tr)\n",
    "pred = knn.predict(x_test_w2v)\n",
    "\n",
    "#determining the Test f1 score for optimal k\n",
    "f1 = f1_score(y_test_w2v, pred, pos_label='positive', average='binary')\n",
    "print('\\n****Test f1-score for k = %d is %f****' % (optimal_k,f1))\n",
    "\n",
    "#determining the Test accuracy for optimal k\n",
    "acc = accuracy_score(y_test_w2v, pred, normalize=True) * float(100)\n",
    "print('\\n****Test accuracy for k = %d is %f%%****' % (optimal_k,acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x155244f7ac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The f1-score for each k value is :  [0.90487 0.92253 0.92821 0.93017 0.93121 0.93175 0.93158 0.93202 0.93236\n",
      " 0.93224 0.93224 0.93207 0.93164 0.93094 0.93124]\n"
     ]
    }
   ],
   "source": [
    "# plot f1-score vs k \n",
    "plt.figure(figsize=(15,10))\n",
    "plt.plot(neighbors, f1_scores)\n",
    "for xy in zip(neighbors, np.round(f1_scores,3)):\n",
    "    plt.annotate('(%s, %s)' % xy, xy=xy, textcoords='data')\n",
    "\n",
    "plt.xlabel('Number of Neighbors K')\n",
    "plt.ylabel('f1-score')\n",
    "plt.show()\n",
    "\n",
    "print(\"The f1-score for each k value is : \", np.round(f1_scores,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cross Validation (kd-tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training Word2Vec Model for train dataset\n",
    "i=0\n",
    "list_of_sent=[]\n",
    "for sent in train_data_kd['CleanedText'].values:\n",
    "    list_of_sent.append(sent.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Aziz\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:2: DeprecationWarning: Call to deprecated `__getitem__` (Method will be removed in 4.0.0, use self.wv.__getitem__() instead).\n",
      "  \n"
     ]
    }
   ],
   "source": [
    "w2v_model=Word2Vec(list_of_sent,min_count=5,size=50, workers=4)\n",
    "X = w2v_model[w2v_model.wv.vocab]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████| 7000/7000 [00:25<00:00, 271.90it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7000\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "#computing Avg Word2Vec for train dataset\n",
    "w2v_words = list(w2v_model.wv.vocab)\n",
    "sent_vectors = []; # the avg-w2v for each sentence/review is stored in this list\n",
    "for sent in tqdm(list_of_sent): # for each review/sentence\n",
    "    sent_vec = np.zeros(50) # as word vectors are of zero length\n",
    "    cnt_words =0; # num of words with a valid vector in the sentence/review\n",
    "    for word in sent: # for each word in a review/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            sent_vec += vec\n",
    "            cnt_words += 1\n",
    "    if cnt_words != 0:\n",
    "        sent_vec /= cnt_words\n",
    "    sent_vectors.append(sent_vec)\n",
    "print(len(sent_vectors))\n",
    "print(len(sent_vectors[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7000, 50)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train_w2v_kd = np.array(sent_vectors)\n",
    "y_train_w2v_kd = train_data_kd['Score']\n",
    "x_train_w2v_kd.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#training Word2Vec Model for test dataset\n",
    "i=0\n",
    "list_of_sent=[]\n",
    "for sent in test_data_kd['CleanedText'].values:\n",
    "    list_of_sent.append(sent.split())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████| 3000/3000 [00:12<00:00, 239.76it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3000\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "#computing Avg Word2Vec for test dataset\n",
    "w2v_words = list(w2v_model.wv.vocab)\n",
    "sent_vectors = []; # the avg-w2v for each sentence/review is stored in this list\n",
    "for sent in tqdm(list_of_sent): # for each review/sentence\n",
    "    sent_vec = np.zeros(50) # as word vectors are of zero length\n",
    "    cnt_words =0; # num of words with a valid vector in the sentence/review\n",
    "    for word in sent: # for each word in a review/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            sent_vec += vec\n",
    "            cnt_words += 1\n",
    "    if cnt_words != 0:\n",
    "        sent_vec /= cnt_words\n",
    "    sent_vectors.append(sent_vec)\n",
    "print(len(sent_vectors))\n",
    "print(len(sent_vectors[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3000, 50)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test_w2v_kd = np.array(sent_vectors)\n",
    "y_test_w2v_kd = test_data_kd['Score']\n",
    "x_test_w2v_kd.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CV f1-score for k = 1 is 0.897422\n",
      "\n",
      "CV f1-score for k = 3 is 0.922638\n",
      "\n",
      "CV f1-score for k = 5 is 0.931556\n",
      "\n",
      "CV f1-score for k = 7 is 0.935813\n",
      "\n",
      "CV f1-score for k = 9 is 0.937595\n",
      "\n",
      "CV f1-score for k = 11 is 0.938228\n",
      "\n",
      "CV f1-score for k = 13 is 0.939302\n",
      "\n",
      "CV f1-score for k = 15 is 0.939601\n",
      "\n",
      "CV f1-score for k = 17 is 0.939869\n",
      "\n",
      "CV f1-score for k = 19 is 0.939601\n",
      "\n",
      "CV f1-score for k = 21 is 0.940136\n",
      "\n",
      "CV f1-score for k = 23 is 0.940404\n",
      "\n",
      "CV f1-score for k = 25 is 0.940909\n",
      "\n",
      "CV f1-score for k = 27 is 0.940909\n",
      "\n",
      "CV f1-score for k = 29 is 0.940909\n",
      "\n",
      "The optimal number of neighbors is 25.\n",
      "\n",
      "****Test f1-score for k = 25 is 0.935535****\n",
      "\n",
      "****Test accuracy for k = 25 is 87.900000%****\n"
     ]
    }
   ],
   "source": [
    "# split the train data set into cross validation train and cross validation test\n",
    "X_tr, X_cv, y_tr, y_cv = cross_validation.train_test_split(x_train_w2v_kd, y_train_w2v_kd, test_size=0.3)\n",
    "\n",
    "f1_scores=[]\n",
    "myList = list(range(0,30))\n",
    "neighbors = list(filter(lambda x: x % 2 != 0, myList))\n",
    "\n",
    "for i in neighbors:\n",
    "    # instantiate learning model (k = 30)\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, algorithm='kd_tree')\n",
    "\n",
    "    # fitting the model on crossvalidation train\n",
    "    knn.fit(X_tr, y_tr)\n",
    "\n",
    "    # predict the response on the crossvalidation train\n",
    "    pred = knn.predict(X_cv)\n",
    "    \n",
    "    #evaluate CV f1-score\n",
    "    f1 = f1_score(y_cv, pred, pos_label='positive', average='binary')\n",
    "    \n",
    "    #printing f1-score of positive class for each k\n",
    "    print('\\nCV f1-score for k = %d is %f' % (i, f1))\n",
    "    f1_scores.append(f1)\n",
    "    \n",
    "\n",
    "# determining optimal k\n",
    "optimal_k = neighbors[f1_scores.index(max(f1_scores))]\n",
    "print('\\nThe optimal number of neighbors is %d.' % optimal_k)\n",
    "\n",
    "knn = KNeighborsClassifier(optimal_k)\n",
    "knn.fit(X_tr,y_tr)\n",
    "pred = knn.predict(x_test_w2v_kd)\n",
    "\n",
    "#determining the Test f1 score for optimal k\n",
    "f1 = f1_score(y_test_w2v_kd, pred, pos_label='positive', average='binary')\n",
    "print('\\n****Test f1-score for k = %d is %f****' % (optimal_k,f1))\n",
    "\n",
    "#determining the Test accuracy for optimal k\n",
    "acc = accuracy_score(y_test_w2v_kd, pred, normalize=True) * float(100)\n",
    "print('\\n****Test accuracy for k = %d is %f%%****' % (optimal_k,acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  773  2374]\n",
      " [  204 14649]]\n"
     ]
    }
   ],
   "source": [
    "#computing confusion matrix\n",
    "cm = confusion_matrix(y_test_w2v, pred)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x15527dda9e8>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x155244f7fd0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plotting confusion matrix as heatmap\n",
    "df_cm = pd.DataFrame(cm, range(2),range(2))\n",
    "sn.set(font_scale=1.4) #for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 16}) #font size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TF-IDF Word2Vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cross Validation (brute)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training model for train dataset\n",
    "model = TfidfVectorizer()\n",
    "tf_idf_matrix = model.fit_transform(train_data['CleanedText'].values)\n",
    "# we are converting a dictionary with word as a key, and the idf as a value\n",
    "dictionary = dict(zip(model.get_feature_names(), list(model.idf_)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████| 42000/42000 [04:31<00:00, 154.46it/s]\n"
     ]
    }
   ],
   "source": [
    "# TF-IDF weighted Word2Vec\n",
    "tfidf_feat = model.get_feature_names() # tfidf words/col-names\n",
    "# final_tf_idf is the sparse matrix with row= sentence, col=word and cell_val = tfidf\n",
    "\n",
    "tfidf_sent_vectors = []; # the tfidf-w2v for each sentence/review is stored in this list\n",
    "row=0;\n",
    "for sent in tqdm(list_of_sent): # for each review/sentence \n",
    "    sent_vec = np.zeros(50) # as word vectors are of zero length\n",
    "    weight_sum =0; # num of words with a valid vector in the sentence/review\n",
    "    for word in sent: # for each word in a review/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            # tf_idf = tf_idf_matrix[row, tfidf_feat.index(word)]\n",
    "            # to reduce the computation we are \n",
    "            # dictionary[word] = idf value of word in whole courpus\n",
    "            # sent.count(word) = tf valeus of word in this review\n",
    "            tf_idf = dictionary[word]*(sent.count(word)/len(sent))\n",
    "            sent_vec += (vec * tf_idf)\n",
    "            weight_sum += tf_idf\n",
    "    if weight_sum != 0:\n",
    "        sent_vec /= weight_sum\n",
    "    tfidf_sent_vectors.append(sent_vec)\n",
    "    row += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(42000, 50)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train_tfw2v = np.array(tfidf_sent_vectors)\n",
    "y_train_tfw2v = train_data['Score']\n",
    "x_train_tfw2v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training model for test dataset\n",
    "model = TfidfVectorizer()\n",
    "tf_idf_matrix = model.fit_transform(test_data['CleanedText'].values)\n",
    "# we are converting a dictionary with word as a key, and the idf as a value\n",
    "dictionary = dict(zip(model.get_feature_names(), list(model.idf_)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|███████████████████████████████████| 18000/18000 [02:00<00:00, 149.97it/s]\n"
     ]
    }
   ],
   "source": [
    "# TF-IDF weighted Word2Vec\n",
    "tfidf_feat = model.get_feature_names() # tfidf words/col-names\n",
    "# final_tf_idf is the sparse matrix with row= sentence, col=word and cell_val = tfidf\n",
    "\n",
    "tfidf_sent_vectors = []; # the tfidf-w2v for each sentence/review is stored in this list\n",
    "row=0;\n",
    "for sent in tqdm(list_of_sent): # for each review/sentence \n",
    "    sent_vec = np.zeros(50) # as word vectors are of zero length\n",
    "    weight_sum =0; # num of words with a valid vector in the sentence/review\n",
    "    for word in sent: # for each word in a review/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            # tf_idf = tf_idf_matrix[row, tfidf_feat.index(word)]\n",
    "            # to reduce the computation we are \n",
    "            # dictionary[word] = idf value of word in whole courpus\n",
    "            # sent.count(word) = tf valeus of word in this review\n",
    "            tf_idf = dictionary[word]*(sent.count(word)/len(sent))\n",
    "            sent_vec += (vec * tf_idf)\n",
    "            weight_sum += tf_idf\n",
    "    if weight_sum != 0:\n",
    "        sent_vec /= weight_sum\n",
    "    tfidf_sent_vectors.append(sent_vec)\n",
    "    row += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(18000, 50)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test_tfw2v = np.array(tfidf_sent_vectors)\n",
    "y_test_tfw2v = test_data['Score']\n",
    "x_test_tfw2v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CV f1-score for k = 1 is 0.895784\n",
      "\n",
      "CV f1-score for k = 3 is 0.917117\n",
      "\n",
      "CV f1-score for k = 5 is 0.922605\n",
      "\n",
      "CV f1-score for k = 7 is 0.925572\n",
      "\n",
      "CV f1-score for k = 9 is 0.927377\n",
      "\n",
      "CV f1-score for k = 11 is 0.928361\n",
      "\n",
      "CV f1-score for k = 13 is 0.928518\n",
      "\n",
      "CV f1-score for k = 15 is 0.928443\n",
      "\n",
      "CV f1-score for k = 17 is 0.928312\n",
      "\n",
      "CV f1-score for k = 19 is 0.928113\n",
      "\n",
      "CV f1-score for k = 21 is 0.927907\n",
      "\n",
      "CV f1-score for k = 23 is 0.927615\n",
      "\n",
      "CV f1-score for k = 25 is 0.927612\n",
      "\n",
      "CV f1-score for k = 27 is 0.927743\n",
      "\n",
      "CV f1-score for k = 29 is 0.927834\n",
      "\n",
      "The optimal number of neighbors is 13.\n",
      "\n",
      "****Test f1-score for k = 13 is 0.913751****\n",
      "\n",
      "****Test accuracy for k = 13 is 84.688889%****\n"
     ]
    }
   ],
   "source": [
    "# split the train data set into cross validation train and cross validation test\n",
    "X_tr, X_cv, y_tr, y_cv = cross_validation.train_test_split(x_train_tfw2v, y_train_tfw2v, test_size=0.3)\n",
    "\n",
    "f1_scores=[]\n",
    "myList = list(range(0,30))\n",
    "neighbors = list(filter(lambda x: x % 2 != 0, myList))\n",
    "\n",
    "for i in neighbors:\n",
    "    # instantiate learning model (k = 30)\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, algorithm='brute')\n",
    "\n",
    "    # fitting the model on crossvalidation train\n",
    "    knn.fit(X_tr, y_tr)\n",
    "\n",
    "    # predict the response on the crossvalidation train\n",
    "    pred = knn.predict(X_cv)\n",
    "    \n",
    "    #evaluate CV f1-score\n",
    "    f1 = f1_score(y_cv, pred, pos_label='positive', average='binary')\n",
    "    \n",
    "    #printing f1-score of positive class for each k\n",
    "    print('\\nCV f1-score for k = %d is %f' % (i, f1))\n",
    "    f1_scores.append(f1)\n",
    "    \n",
    "\n",
    "# determining optimal k\n",
    "optimal_k = neighbors[f1_scores.index(max(f1_scores))]\n",
    "print('\\nThe optimal number of neighbors is %d.' % optimal_k)\n",
    "\n",
    "knn = KNeighborsClassifier(optimal_k)\n",
    "knn.fit(X_tr,y_tr)\n",
    "pred = knn.predict(x_test_tfw2v)\n",
    "\n",
    "#determining the Test f1 score for optimal k\n",
    "f1 = f1_score(y_test_tfw2v, pred, pos_label='positive', average='binary')\n",
    "print('\\n****Test f1-score for k = %d is %f****' % (optimal_k,f1))\n",
    "\n",
    "#determining the Test accuracy for optimal k\n",
    "acc = accuracy_score(y_test_tfw2v, pred, normalize=True) * float(100)\n",
    "print('\\n****Test accuracy for k = %d is %f%%****' % (optimal_k,acc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1552be08278>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The f1-score for each k value is :  [0.89578 0.91712 0.9226  0.92557 0.92738 0.92836 0.92852 0.92844 0.92831\n",
      " 0.92811 0.92791 0.92761 0.92761 0.92774 0.92783]\n"
     ]
    }
   ],
   "source": [
    "# plot f1-score vs k \n",
    "plt.figure(figsize=(15,10))\n",
    "plt.plot(neighbors, f1_scores)\n",
    "for xy in zip(neighbors, np.round(f1_scores,3)):\n",
    "    plt.annotate('(%s, %s)' % xy, xy=xy, textcoords='data')\n",
    "\n",
    "plt.xlabel('Number of Neighbors K')\n",
    "plt.ylabel('f1-score')\n",
    "plt.show()\n",
    "\n",
    "print(\"The f1-score for each k value is : \", np.round(f1_scores,5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Cross Validation (kd-tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training model for train dataset\n",
    "model = TfidfVectorizer()\n",
    "tf_idf_matrix = model.fit_transform(train_data_kd['CleanedText'].values)\n",
    "# we are converting a dictionary with word as a key, and the idf as a value\n",
    "dictionary = dict(zip(model.get_feature_names(), list(model.idf_)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████| 7000/7000 [00:34<00:00, 202.16it/s]\n"
     ]
    }
   ],
   "source": [
    "# TF-IDF weighted Word2Vec\n",
    "tfidf_feat = model.get_feature_names() # tfidf words/col-names\n",
    "# final_tf_idf is the sparse matrix with row= sentence, col=word and cell_val = tfidf\n",
    "\n",
    "tfidf_sent_vectors = []; # the tfidf-w2v for each sentence/review is stored in this list\n",
    "row=0;\n",
    "for sent in tqdm(list_of_sent): # for each review/sentence \n",
    "    sent_vec = np.zeros(50) # as word vectors are of zero length\n",
    "    weight_sum =0; # num of words with a valid vector in the sentence/review\n",
    "    for word in sent: # for each word in a review/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            # tf_idf = tf_idf_matrix[row, tfidf_feat.index(word)]\n",
    "            # to reduce the computation we are \n",
    "            # dictionary[word] = idf value of word in whole courpus\n",
    "            # sent.count(word) = tf valeus of word in this review\n",
    "            tf_idf = dictionary[word]*(sent.count(word)/len(sent))\n",
    "            sent_vec += (vec * tf_idf)\n",
    "            weight_sum += tf_idf\n",
    "    if weight_sum != 0:\n",
    "        sent_vec /= weight_sum\n",
    "    tfidf_sent_vectors.append(sent_vec)\n",
    "    row += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7000, 50)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_train_tfw2v_kd = np.array(tfidf_sent_vectors)\n",
    "y_train_tfw2v_kd = train_data_kd['Score']\n",
    "x_train_tfw2v_kd.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# training model for test dataset\n",
    "model = TfidfVectorizer()\n",
    "tf_idf_matrix = model.fit_transform(test_data_kd['CleanedText'].values)\n",
    "# we are converting a dictionary with word as a key, and the idf as a value\n",
    "dictionary = dict(zip(model.get_feature_names(), list(model.idf_)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|█████████████████████████████████████| 3000/3000 [00:15<00:00, 189.16it/s]\n"
     ]
    }
   ],
   "source": [
    "# TF-IDF weighted Word2Vec\n",
    "tfidf_feat = model.get_feature_names() # tfidf words/col-names\n",
    "# final_tf_idf is the sparse matrix with row= sentence, col=word and cell_val = tfidf\n",
    "\n",
    "tfidf_sent_vectors = []; # the tfidf-w2v for each sentence/review is stored in this list\n",
    "row=0;\n",
    "for sent in tqdm(list_of_sent): # for each review/sentence \n",
    "    sent_vec = np.zeros(50) # as word vectors are of zero length\n",
    "    weight_sum =0; # num of words with a valid vector in the sentence/review\n",
    "    for word in sent: # for each word in a review/sentence\n",
    "        if word in w2v_words:\n",
    "            vec = w2v_model.wv[word]\n",
    "            # tf_idf = tf_idf_matrix[row, tfidf_feat.index(word)]\n",
    "            # to reduce the computation we are \n",
    "            # dictionary[word] = idf value of word in whole courpus\n",
    "            # sent.count(word) = tf valeus of word in this review\n",
    "            tf_idf = dictionary[word]*(sent.count(word)/len(sent))\n",
    "            sent_vec += (vec * tf_idf)\n",
    "            weight_sum += tf_idf\n",
    "    if weight_sum != 0:\n",
    "        sent_vec /= weight_sum\n",
    "    tfidf_sent_vectors.append(sent_vec)\n",
    "    row += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3000, 50)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_test_tfw2v_kd = np.array(tfidf_sent_vectors)\n",
    "y_test_tfw2v_kd = test_data_kd['Score']\n",
    "x_test_tfw2v_kd.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "CV f1-score for k = 1 is 0.891775\n",
      "\n",
      "CV f1-score for k = 3 is 0.921319\n",
      "\n",
      "CV f1-score for k = 5 is 0.934594\n",
      "\n",
      "CV f1-score for k = 7 is 0.937611\n",
      "\n",
      "CV f1-score for k = 9 is 0.938579\n",
      "\n",
      "CV f1-score for k = 11 is 0.938403\n",
      "\n",
      "CV f1-score for k = 13 is 0.938734\n",
      "\n",
      "CV f1-score for k = 15 is 0.939034\n",
      "\n",
      "CV f1-score for k = 17 is 0.938528\n",
      "\n",
      "CV f1-score for k = 19 is 0.938528\n",
      "\n",
      "CV f1-score for k = 21 is 0.938796\n",
      "\n",
      "CV f1-score for k = 23 is 0.938796\n",
      "\n",
      "CV f1-score for k = 25 is 0.938322\n",
      "\n",
      "CV f1-score for k = 27 is 0.938322\n",
      "\n",
      "CV f1-score for k = 29 is 0.938322\n",
      "\n",
      "The optimal number of neighbors is 15.\n",
      "\n",
      "****Test f1-score for k = 15 is 0.935724****\n",
      "\n",
      "****Test accuracy for k = 15 is 87.933333%****\n"
     ]
    }
   ],
   "source": [
    "# split the train data set into cross validation train and cross validation test\n",
    "X_tr, X_cv, y_tr, y_cv = cross_validation.train_test_split(x_train_tfw2v_kd, y_train_tfw2v_kd, test_size=0.3)\n",
    "\n",
    "f1_scores=[]\n",
    "myList = list(range(0,30))\n",
    "neighbors = list(filter(lambda x: x % 2 != 0, myList))\n",
    "\n",
    "for i in neighbors:\n",
    "    # instantiate learning model (k = 30)\n",
    "    knn = KNeighborsClassifier(n_neighbors=i, algorithm='kd_tree')\n",
    "\n",
    "    # fitting the model on crossvalidation train\n",
    "    knn.fit(X_tr, y_tr)\n",
    "\n",
    "    # predict the response on the crossvalidation train\n",
    "    pred = knn.predict(X_cv)\n",
    "    \n",
    "    #evaluate CV f1-score\n",
    "    f1 = f1_score(y_cv, pred, pos_label='positive', average='binary')\n",
    "    \n",
    "    #printing f1-score of positive class for each k\n",
    "    print('\\nCV f1-score for k = %d is %f' % (i, f1))\n",
    "    f1_scores.append(f1)\n",
    "\n",
    "# determining optimal k\n",
    "optimal_k = neighbors[f1_scores.index(max(f1_scores))]\n",
    "print('\\nThe optimal number of neighbors is %d.' % optimal_k)\n",
    "\n",
    "knn = KNeighborsClassifier(optimal_k)\n",
    "knn.fit(X_tr,y_tr)\n",
    "pred = knn.predict(x_test_tfw2v_kd)\n",
    "#determining the Test f1 score for optimal k\n",
    "f1 = f1_score(y_test_tfw2v_kd, pred, pos_label='positive', average='binary')\n",
    "print('\\n****Test f1-score for k = %d is %f****' % (optimal_k,f1))\n",
    "#determining the Test accuracy for optimal k\n",
    "acc = accuracy_score(y_test_tfw2v_kd, pred, normalize=True) * float(100)\n",
    "print('\\n****Test accuracy for k = %d is %f%%****' % (optimal_k,acc))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Confusion Matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  645  2502]\n",
      " [  254 14599]]\n"
     ]
    }
   ],
   "source": [
    "#computing confusion matrix\n",
    "cm = confusion_matrix(y_test_w2v, pred)\n",
    "print(cm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x1552be08cf8>"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1552be06c50>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plotting confusion matrix as heatmap\n",
    "df_cm = pd.DataFrame(cm, range(2),range(2))\n",
    "sn.set(font_scale=1.4) #for label size\n",
    "sn.heatmap(df_cm, annot=True,annot_kws={\"size\": 16}) #font size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+---------+-----------+----------+----------+\n",
      "|  Vectorizer  |  Model  | optimal k | f1-score | accuracy |\n",
      "+--------------+---------+-----------+----------+----------+\n",
      "|     BoW      |  Brute  |     9     | 0.904950 |  82.75%  |\n",
      "|    Tfidf     |  Brute  |     13    | 0.910450 |  83.82%  |\n",
      "| Avg Word2Vec |  Brute  |     17    | 0.91912  |  85.67%  |\n",
      "|  Tfidf-W2V   |  Brute  |     13    | 0.91375  |  84.68%  |\n",
      "|     BoW      | Kd-Tree |     13    | 0.936420 |  88.10%  |\n",
      "|    Tfidf     | Kd-Tree |     7     | 0.93392  |  83.66%  |\n",
      "| Avg Word2Vec | Kd-Tree |     25    | 0.93553  |  87.90%  |\n",
      "|  Tfidf-W2V   | Kd-Tree |     15    | 0.93572  |  87.93%  |\n",
      "+--------------+---------+-----------+----------+----------+\n"
     ]
    }
   ],
   "source": [
    "x=PrettyTable()\n",
    "x.field_names = ['Vectorizer','Model','optimal k','f1-score','accuracy']\n",
    "x.add_row(['BoW','Brute','9','0.904950','82.75%'])\n",
    "x.add_row(['Tfidf','Brute','13','0.910450','83.82%'])\n",
    "x.add_row(['Avg Word2Vec','Brute','17','0.91912','85.67%'])\n",
    "x.add_row(['Tfidf-W2V','Brute','13','0.91375','84.68%'])\n",
    "x.add_row(['BoW','Kd-Tree','13','0.936420','88.10%'])\n",
    "x.add_row(['Tfidf','Kd-Tree','7','0.93392','83.66%'])\n",
    "x.add_row(['Avg Word2Vec','Kd-Tree','25','0.93553','87.90%'])\n",
    "x.add_row(['Tfidf-W2V','Kd-Tree','15','0.93572','87.93%'])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From the above table, we conclude:-\n",
    "1. For Brute Force implementation, Avg Word2Vec gives the largest value of f1-score(0.919) as well as the highest accuracy(85.67). \n",
    "2. For Kd-Tree implementation, BoW gives the largest value of f1-score(0.936) as well as the highest accuracy(88.10).\n",
    "3. Therefore, Kd-Tree implementation of KNN is more efficient as compared to Brute Force implementation for all featurization methods."
   ]
  }
 ],
 "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.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}