NB for Amazon Food Reviews.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "import sqlite3\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import nltk\n",
    "import string\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import math\n",
    "from prettytable import PrettyTable\n",
    "from scipy import sparse\n",
    "import csv\n",
    "\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer\n",
    "from nltk.stem.snowball import SnowballStemmer\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import cross_val_score, cross_validate, GridSearchCV\n",
    "from sklearn.preprocessing import StandardScaler, Normalizer\n",
    "from sklearn.metrics import accuracy_score, confusion_matrix, roc_curve, auc\n",
    "from sklearn.metrics import confusion_matrix, classification_report, precision_score\n",
    "from sklearn.decomposition import TruncatedSVD\n",
    "from sklearn.naive_bayes import GaussianNB, MultinomialNB, BernoulliNB\n",
    "\n",
    "import re\n",
    "from nltk.corpus import stopwords\n",
    "from nltk.stem.wordnet import WordNetLemmatizer\n",
    "from nltk.tokenize import word_tokenize\n",
    "\n",
    "from gensim.models import Word2Vec\n",
    "from gensim.models import KeyedVectors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "pt = PrettyTable()\n",
    "pt.field_names = [\"Text Vectorizer Model\", \"Optimal K-value\", \"Scoring Metric\", \"Accuracy\", \"TPR\", \"TNR\", \"FPR\", \"FNR\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150000, 10)\n",
      "Wall time: 4.64 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "con = sqlite3.connect('database.sqlite')\n",
    "raw_data = pd.read_sql_query(\"\"\" SELECT * FROM Reviews WHERE Score != 3 \"\"\", con)\n",
    "raw_data = raw_data.sample(150000, random_state=42)\n",
    "raw_data = raw_data.sort_values('Time')\n",
    "print(raw_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess(data):\n",
    "    '''\n",
    "    Preprocess I/P data :-\n",
    "    1. Update Score with 0 (-ve Review) and 1 (+ve Review).\n",
    "    2. Add another feature with Review length and use Log to reduce scale.\n",
    "    3. Select unique rows based on - UserId, ProfileName, Time and Text.\n",
    "    4. Remove rows which have helpfulness denominator greater than helpfulness numerator.\n",
    "    5. Remove html tags from Reviews.\n",
    "    6. Remove punctuations and special characters.\n",
    "    7. Performing Stemming using Snowball Stemmer.\n",
    "    8. Extract Adjectives, Nouns, Verbs, Adverbs from 'Summary' column and add it to the 'CleanedText' column.\n",
    "    '''\n",
    "    # Update 'Score' with 0 -> Negative Review and 1 -> Positive Review\n",
    "    data['Score'] = data['Score'].map(lambda x: 0 if x<3 else 1)\n",
    "    data['TextLength'] = data['Text'].apply(lambda x: math.log(len(x.split())))\n",
    "\n",
    "    data = data.drop_duplicates(subset={'UserId', 'ProfileName', 'Time', 'Text'})\n",
    "    data = data[data['HelpfulnessNumerator'] <= data['HelpfulnessDenominator']]\n",
    "\n",
    "    stops = set(stopwords.words('english')) - set(['not'])\n",
    "    snow = SnowballStemmer('english')\n",
    "\n",
    "    # Function to clean the word of any html-tags\n",
    "    def cleanhtml(sentence):\n",
    "        cleanr = re.compile('<.*?>')\n",
    "        cleantext = re.sub(cleanr, ' ', sentence)\n",
    "        return cleantext\n",
    "\n",
    "    # Function to clean the word of any punctuation or special characters\n",
    "    def cleanpunc(sentence):\n",
    "        cleaned = re.sub(r'[?|!|\\'|\"|:|#]',r' ',sentence)\n",
    "        cleaned = re.sub(r'[.|,|)|(|\\|/]',r' ',cleaned)\n",
    "        return  cleaned\n",
    "\n",
    "    filtered_reviews = []\n",
    "    s = ''\n",
    "\n",
    "    for review in data['Text'].values:\n",
    "        filtered_sent = []\n",
    "        review = cleanhtml(review)\n",
    "        review = cleanpunc(review)\n",
    "        for word in review.split():\n",
    "            if word.isalpha() and len(word) > 2:\n",
    "                if word.lower() not in stops:\n",
    "                    s = snow.stem(word.lower())\n",
    "                    filtered_sent.append(s)\n",
    "        filtered_reviews.append(' '.join(filtered_sent))\n",
    "        \n",
    "    tags = []\n",
    "    for review in data['Summary'].values:\n",
    "        review = cleanhtml(review)\n",
    "        review = cleanpunc(review)\n",
    "        adjs = [x[0] for x in nltk.pos_tag(word_tokenize(review)) if x[1].startswith('JJ') \\\n",
    "                or x[1].startswith('RB') or x[1].startswith('VB') or x[1] == 'NNP']\n",
    "        if len(adjs) > 0:\n",
    "            adjs = ' '.join([snow.stem(word.lower()) if len(word) > 2 and word.lower() not in stops else '' for word in adjs])\n",
    "        tags.append(adjs)\n",
    "    \n",
    "    print('Total Data-points :-',len(filtered_reviews))\n",
    "    data['CleanedText'] = [str(filtered_reviews[i]) + ' ' + str(tags[i]) for i in range(len(tags))]\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_scores(nb_optimal):\n",
    "    _, = plt.plot(list(nb_optimal.cv_results_['param_alpha']), \\\n",
    "                      list(nb_optimal.cv_results_['mean_train_score']), 'g-', \\\n",
    "                     label='Training Scores')\n",
    "    _, = plt.plot(list(nb_optimal.cv_results_['param_alpha']), \\\n",
    "                      list(nb_optimal.cv_results_['mean_test_score']), 'r-', \\\n",
    "                      label='Test Scores')\n",
    "    _, = plt.plot(nb_optimal.best_params_['alpha'], nb_optimal.best_score_, 'bo', \\\n",
    "                     label=f\"Optimal Value (a={nb_optimal.best_params_['alpha']}, Score={round(nb_optimal.best_score_,2)})\")\n",
    "\n",
    "    plt.xscale('log')\n",
    "    plt.xlabel('Laplace Smoothing Parameter (Alpha)')\n",
    "    plt.ylabel('Scores')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def normalize_data(train, train_vectors, test, test_vectors):\n",
    "    sc = Normalizer()\n",
    "    \n",
    "    y_train = train['Score']\n",
    "    X_train = train.drop(['Id', 'ProductId', 'UserId', 'ProfileName', 'Score', 'Summary', 'Text', 'CleanedText'], axis=1)\n",
    "    X_train = sc.fit_transform(X_train)\n",
    "    print(X_train.shape, train_vectors.shape)\n",
    "    X_train = sparse.hstack((X_train, train_vectors))\n",
    "    \n",
    "    print('X_Train: {0}'.format(X_train.shape))\n",
    "    print('y_Train: {0}'.format(y_train.shape))\n",
    "    \n",
    "    y_test = test['Score']\n",
    "    X_test = test.drop(['Id', 'ProductId', 'UserId', 'ProfileName', 'Score', 'Summary', 'Text', 'CleanedText'], axis=1)\n",
    "    X_test = sc.transform(X_test)\n",
    "    X_test = sparse.hstack((X_test, test_vectors))\n",
    "    \n",
    "    print('X_Test: {0}'.format(X_test.shape))\n",
    "    print('y_Test: {0}'.format(y_test.shape))\n",
    "    \n",
    "    return X_train, y_train, X_test, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_NB(train, train_vectors, test, test_vectors, metric='precision_macro'):\n",
    "    '''\n",
    "    Perform Multinomial NB modelling on the I/P Train and Test data.\n",
    "    1. Remove not required Columns, Normalize data and concatenate data with the text vectors.\n",
    "    2. Perform Cross Validation and find Optimal 'alpha' - Laplace Smoothing parameter.\n",
    "    3. Use the Optimal 'alpha' based model on the Training data and evaluate the Test data.\n",
    "    4. Calculate Accuracy of Model and TPR, TNR, FPR, FNR.\n",
    "    '''\n",
    "    # Drop not required Columns, Normalize data and concatenate data with text vectors\n",
    "    X_train, y_train, X_test, y_test = normalize_data(train, train_vectors, test, test_vectors)\n",
    "    del train, train_vectors, test, test_vectors\n",
    "\n",
    "    params = {'alpha': (0.0, 0.0001, 0.001, 0.01, 0.1, 0.5, 1.0, 2.0, 10.0, 12.0, 15.0, 20.0, 22.0)}\n",
    "    nb = MultinomialNB()\n",
    "    nb_optimal = GridSearchCV(nb, param_grid=params, cv=3, scoring=metric, verbose=1, refit=True)\n",
    "    nb_optimal.fit(X_train, y_train)\n",
    "    \n",
    "    # Plot Train vs Test Scores and the Optimal Parameter\n",
    "    plot_scores(nb_optimal)\n",
    "\n",
    "    print(f'coef_ shape: {nb_optimal.best_estimator_.coef_.shape}')\n",
    "    del X_train, y_train\n",
    "    pred = []\n",
    "    \n",
    "    for i in range(0, X_test.shape[0], 2000):\n",
    "        test_batch = X_test.todok()[i:i+2000]\n",
    "        pred.extend(nb_optimal.predict(test_batch))\n",
    "\n",
    "    acc = accuracy_score(y_test, pred) * 100\n",
    "    print(f'\\nThe Accuracy of the Multinomial NB classifier for alpha = {nb_optimal.best_params_[\"alpha\"]} is {acc} %')\n",
    "    \n",
    "    conf_matrix = confusion_matrix(y_test, pred)\n",
    "    TPR = conf_matrix[1,1]/(conf_matrix[0,1] + conf_matrix[1,1])\n",
    "    TNR = conf_matrix[0,0]/(conf_matrix[0,0] + conf_matrix[1,0])\n",
    "    FPR = conf_matrix[1,0]/(conf_matrix[0,0] + conf_matrix[1,0])\n",
    "    FNR = conf_matrix[0,1]/(conf_matrix[0,1] + conf_matrix[1,1])\n",
    "    print('\\nConfusion Matrix :-')\n",
    "    print(conf_matrix)\n",
    "    print(\"\\nTPR: {0} %\\nTNR: {1} %\\nFPR: {2} %\\nFNR: {3} %\\n\".format(TPR*100, TNR*100, FPR*100, FNR*100))\n",
    "    sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='coolwarm')\n",
    "    print('\\nClassification Report :-\\n')\n",
    "    print(classification_report(y_test, pred))\n",
    "    \n",
    "    return [nb_optimal.best_params_[\"alpha\"], metric, round(acc,2), round(TPR*100,2), round(TNR*100,2), \\\n",
    "            round(FPR*100,2), round(FNR*100,2), nb_optimal.best_estimator_.coef_[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data(data_points):\n",
    "    '''\n",
    "    Perform pre-processing on raw data and extract required datapoints :: 70-30 Split.\n",
    "    '''\n",
    "    split = int(data_points * 0.70)\n",
    "    data = preprocess(raw_data)\n",
    "    train = data[:split]\n",
    "    test = data[split:data_points]\n",
    "\n",
    "    print(train['Score'].value_counts())\n",
    "    print(test['Score'].value_counts())\n",
    "    return train, test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def save_model_info(model, info):\n",
    "    '''\n",
    "    Save Model info in a csv file for future use.\n",
    "    '''\n",
    "    with open(\"Model_Scores.csv\",\"a\") as f:\n",
    "        out = csv.writer(f, delimiter=',',quoting=csv.QUOTE_ALL)\n",
    "        out.writerow([model] + info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_best_metric(d_train, vec_train, d_test, vec_test, vectorizer=\"BOW\"):\n",
    "    pt = PrettyTable()\n",
    "    pt.field_names = [\"Text Vectorizer Model\", \"NB Model\", \"Scoring Metric\", \"Score\", \"TPR\", \"TNR\", \"FPR\", \"FNR\"]\n",
    "    metrics = ['accuracy', 'adjusted_mutual_info_score', 'adjusted_rand_score', 'average_precision', \\\n",
    "              'completeness_score', 'explained_variance', 'f1', 'f1_macro', 'f1_micro',\\\n",
    "              'f1_weighted', 'homogeneity_score', 'mutual_info_score',\\\n",
    "              'neg_log_loss', 'neg_mean_absolute_error', 'neg_mean_squared_error', 'neg_mean_squared_log_error',\\\n",
    "              'neg_median_absolute_error', 'normalized_mutual_info_score', 'precision', 'precision_macro',\\\n",
    "              'precision_micro', 'precision_weighted', 'r2', 'recall', 'recall_macro',\\\n",
    "              'recall_micro', 'recall_weighted', 'roc_auc', 'v_measure_score']\n",
    "\n",
    "    scores = []\n",
    "    for i in metrics:\n",
    "        info = run_NB(d_train, vec_train, d_test, vec_test, metric=i)\n",
    "        pt.add_row([vectorizer] + info)\n",
    "    return pt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Data-points :- 24655\n",
      "0    12473\n",
      "1     1527\n",
      "Name: Score, dtype: int64\n",
      "0    5250\n",
      "1     750\n",
      "Name: Score, dtype: int64\n",
      "Wall time: 40.2 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "data_train, data_test = get_data(20000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(14000, 3332) (6000, 3332)\n",
      "+-----------------------+----------+------------------------------+-------+-------+-------+-------+------+\n",
      "| Text Vectorizer Model | NB Model |        Scoring Metric        | Score |  TPR  |  TNR  |  FPR  | FNR  |\n",
      "+-----------------------+----------+------------------------------+-------+-------+-------+-------+------+\n",
      "|          BOW          |   10.0   |            recall            |  89.8 | 90.76 | 69.93 | 30.07 | 9.24 |\n",
      "|          BOW          |   10.0   |       precision_macro        |  89.8 | 90.76 | 69.93 | 30.07 | 9.24 |\n",
      "|          BOW          |   10.0   |              f1              |  89.8 | 90.76 | 69.93 | 30.07 | 9.24 |\n",
      "|          BOW          |   10.0   |      explained_variance      |  89.8 | 90.76 | 69.93 | 30.07 | 9.24 |\n",
      "|          BOW          |  0.0001  |       recall_weighted        | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |  0.0001  |         recall_micro         | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |  0.0001  |              r2              | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |  0.0001  |       precision_micro        | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |  0.0001  |  neg_mean_squared_log_error  | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |  0.0001  |    neg_mean_squared_error    | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |  0.0001  |   neg_mean_absolute_error    | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |  0.0001  |           f1_micro           | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |  0.0001  |           accuracy           | 89.77 | 93.25 | 58.88 | 41.12 | 6.75 |\n",
      "|          BOW          |   0.0    |  neg_median_absolute_error   | 89.63 | 93.02 |  58.5 |  41.5 | 6.98 |\n",
      "|          BOW          |   0.1    |         f1_weighted          | 89.82 | 93.74 | 58.35 | 41.65 | 6.26 |\n",
      "|          BOW          |   0.5    |       v_measure_score        | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |         recall_macro         | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |      precision_weighted      | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |          precision           | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    | normalized_mutual_info_score | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |         neg_log_loss         | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |      mutual_info_score       | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |      homogeneity_score       | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |           f1_macro           | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |      completeness_score      | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |     adjusted_rand_score      | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   0.5    |  adjusted_mutual_info_score  | 89.68 | 93.88 | 57.45 | 42.55 | 6.12 |\n",
      "|          BOW          |   1.0    |           roc_auc            | 89.48 | 93.73 | 56.62 | 43.38 | 6.27 |\n",
      "|          BOW          |   2.0    |      average_precision       | 89.35 | 93.44 | 56.28 | 43.72 | 6.56 |\n",
      "+-----------------------+----------+------------------------------+-------+-------+-------+-------+------+\n",
      "Wall time: 15min 35s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "cv_model = CountVectorizer(max_features=7000, min_df=10)\n",
    "bow_counts_train = cv_model.fit_transform(data_train['CleanedText'].values)\n",
    "bow_counts_test = cv_model.transform(data_test['CleanedText'].values)\n",
    "print(bow_counts_train.shape, bow_counts_test.shape)\n",
    "\n",
    "pt = get_best_metric(data_train, bow_counts_train.toarray(), data_test, bow_counts_test.toarray())\n",
    "print(pt.get_string(sortby='TNR', reversesort=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Data-points :- 124264\n",
      "1    48338\n",
      "0     7662\n",
      "Name: Score, dtype: int64\n",
      "1    19901\n",
      "0     4099\n",
      "Name: Score, dtype: int64\n",
      "Wall time: 3min 22s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "data_train, data_test = get_data(80000)\n",
    "del raw_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train = pd.read_csv('./Matrices/data_train.csv')\n",
    "data_test = pd.read_csv('./Matrices/data_test.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# BOW model with 80k datapoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56000, 9397) (24000, 9397)\n",
      "(56000, 4) (56000, 9397)\n",
      "X_Train: (56000, 9401)\n",
      "y_Train: (56000,)\n",
      "X_Test: (24000, 9401)\n",
      "y_Test: (24000,)\n",
      "Fitting 3 folds for each of 13 candidates, totalling 39 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done  39 out of  39 | elapsed:    2.0s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2bde248f2b0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "coef_ shape: (1, 9401)\n",
      "\n",
      "The Accuracy of the Multinomial NB classifier for alpha = 20.0 is 87.10833333333333 %\n",
      "\n",
      "Confusion Matrix :-\n",
      "[[ 1186  2913]\n",
      " [  181 19720]]\n",
      "\n",
      "TPR: 87.1294128043123 %\n",
      "TNR: 86.75932699341624 %\n",
      "FPR: 13.240673006583762 %\n",
      "FNR: 12.870587195687714 %\n",
      "\n",
      "\n",
      "Classification Report :-\n",
      "\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.87      0.29      0.43      4099\n",
      "          1       0.87      0.99      0.93     19901\n",
      "\n",
      "avg / total       0.87      0.87      0.84     24000\n",
      "\n",
      "Wall time: 16.9 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2bdf0790ac8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "cv_model = CountVectorizer(max_features=15000, min_df=5)\n",
    "bow_counts_train = cv_model.fit_transform(data_train['CleanedText'].values)\n",
    "bow_counts_test = cv_model.transform(data_test['CleanedText'].values)\n",
    "print(bow_counts_train.shape, bow_counts_test.shape)\n",
    "\n",
    "info = run_NB(data_train, bow_counts_train, data_test, bow_counts_test, metric='precision_macro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+------------------------+---------------+---------------+\n",
      "| Lowest_Coeff |     Worst_Features     | Highest Coeff | Best_Features |\n",
      "+--------------+------------------------+---------------+---------------+\n",
      "|   -11.555    |          bleh          |     -3.764    |      Time     |\n",
      "|   -11.555    |        dislodg         |     -4.476    |      not      |\n",
      "|   -11.555    |       misfortun        |     -4.487    |     great     |\n",
      "|   -11.555    |        nastiest        |     -4.561    |      like     |\n",
      "|   -11.555    |       toxicolog        |     -4.565    |      good     |\n",
      "|   -11.555    |        unremark        |     -4.624    |      tast     |\n",
      "|   -11.555    |  HelpfulnessNumerator  |     -4.638    |      love     |\n",
      "|   -11.555    | HelpfulnessDenominator |     -4.771    |     flavor    |\n",
      "|   -11.555    |       TextLength       |     -4.874    |      tea      |\n",
      "|   -11.506    |         atroci         |     -4.911    |      use      |\n",
      "|   -11.506    |        autolyz         |     -4.919    |      one      |\n",
      "|   -11.506    |       bandwagon        |     -5.021    |    product    |\n",
      "|   -11.506    |         bismol         |     -5.03     |      tri      |\n",
      "|   -11.506    |       carageenan       |     -5.118    |     coffe     |\n",
      "|   -11.506    |        catalina        |     -5.163    |      best     |\n",
      "|   -11.506    |         crumbi         |     -5.174    |      make     |\n",
      "|   -11.506    |        embarras        |     -5.198    |      get      |\n",
      "|   -11.506    |         fraud          |     -5.232    |      food     |\n",
      "|   -11.506    |        fraudul         |     -5.46     |      eat      |\n",
      "|   -11.506    |        grayish         |     -5.512    |      buy      |\n",
      "+--------------+------------------------+---------------+---------------+\n",
      "Wall time: 15.6 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "n = 20; coeffs = info[-1]; coef_pt = PrettyTable();\n",
    "coef_pt.field_names = [\"Lowest_Coeff\", \"Worst_Features\", \"Highest Coeff\", \"Best_Features\"]\n",
    "feature_names = ['HelpfulnessNumerator', 'HelpfulnessDenominator', 'Time', 'TextLength'] + cv_model.get_feature_names()\n",
    "coefs_with_fns = sorted(zip(coeffs, feature_names))\n",
    "top = zip(coefs_with_fns[:n], coefs_with_fns[:-(n + 1):-1])\n",
    "for (coef_1, fn_1), (coef_2, fn_2) in top:\n",
    "    coef_pt.add_row([round(coef_1,3), fn_1, round(coef_2,3), fn_2])\n",
    "print(coef_pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------------------+-----------------+-----------------+----------+-------+-------+-------+-------+\n",
      "| Text Vectorizer Model | Optimal K-value |  Scoring Metric | Accuracy |  TPR  |  TNR  |  FPR  |  FNR  |\n",
      "+-----------------------+-----------------+-----------------+----------+-------+-------+-------+-------+\n",
      "|          BOW          |       20.0      | precision_macro |  87.11   | 87.13 | 86.76 | 13.24 | 12.87 |\n",
      "+-----------------------+-----------------+-----------------+----------+-------+-------+-------+-------+\n"
     ]
    }
   ],
   "source": [
    "pt.add_row([\"BOW\"] + info[:-1])\n",
    "print(pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "del cv_model, bow_counts_train, bow_counts_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TFIDF model with 80k datapoints"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56000, 9397) (24000, 9397)\n",
      "(56000, 4) (56000, 9397)\n",
      "X_Train: (56000, 9401)\n",
      "y_Train: (56000,)\n",
      "X_Test: (24000, 9401)\n",
      "y_Test: (24000,)\n",
      "Fitting 3 folds for each of 13 candidates, totalling 39 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done  39 out of  39 | elapsed:    2.1s finished\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2bd87be4a58>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "coef_ shape: (1, 9401)\n",
      "\n",
      "The Accuracy of the Multinomial NB classifier for alpha = 0.01 is 87.10833333333333 %\n",
      "\n",
      "Confusion Matrix :-\n",
      "[[ 1099  3000]\n",
      " [   94 19807]]\n",
      "\n",
      "TPR: 86.84614372780287 %\n",
      "TNR: 92.12070410729254 %\n",
      "FPR: 7.879295892707461 %\n",
      "FNR: 13.153856272197132 %\n",
      "\n",
      "\n",
      "Classification Report :-\n",
      "\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.92      0.27      0.42      4099\n",
      "          1       0.87      1.00      0.93     19901\n",
      "\n",
      "avg / total       0.88      0.87      0.84     24000\n",
      "\n",
      "Wall time: 16.9 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2bdf0729e48>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "tfidf_model = TfidfVectorizer(max_features=15000, min_df=5)\n",
    "tfidf_train = tfidf_model.fit_transform(data_train['CleanedText'].values)\n",
    "tfidf_test = tfidf_model.transform(data_test['CleanedText'].values)\n",
    "print(tfidf_train.shape, tfidf_test.shape)\n",
    "\n",
    "info = run_NB(data_train, tfidf_train, data_test, tfidf_test, metric='precision_macro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+--------------+------------------------+---------------+---------------+\n",
      "| Lowest_Coeff |     Worst_Features     | Highest Coeff | Best_Features |\n",
      "+--------------+------------------------+---------------+---------------+\n",
      "|    -17.12    |          bleh          |     -1.729    |      Time     |\n",
      "|    -17.12    |        dislodg         |     -4.985    |     great     |\n",
      "|    -17.12    |       misfortun        |     -5.118    |      love     |\n",
      "|    -17.12    |        nastiest        |     -5.147    |      good     |\n",
      "|    -17.12    |       toxicolog        |     -5.252    |      tea      |\n",
      "|    -17.12    |        unremark        |     -5.309    |      tast     |\n",
      "|    -17.11    |  HelpfulnessNumerator  |     -5.333    |      like     |\n",
      "|   -17.109    | HelpfulnessDenominator |     -5.356    |      not      |\n",
      "|   -17.105    |       TextLength       |     -5.39     |     flavor    |\n",
      "|    -15.0     |       professor        |     -5.401    |     coffe     |\n",
      "|   -14.964    |         fraud          |     -5.49     |      best     |\n",
      "|   -14.964    |        fraudul         |     -5.519    |    product    |\n",
      "|   -14.876    |       bandwagon        |     -5.556    |      use      |\n",
      "|   -14.814    |         unsuit         |     -5.601    |      one      |\n",
      "|   -14.778    |        weakest         |     -5.653    |      tri      |\n",
      "|   -14.582    |         violat         |     -5.751    |      make     |\n",
      "|   -14.386    |        embarras        |     -5.773    |      get      |\n",
      "|   -14.352    |       carageenan       |     -5.803    |      food     |\n",
      "|   -14.339    |        tastless        |     -5.856    |      dog      |\n",
      "|   -14.325    |        myocardi        |     -5.865    |     price     |\n",
      "+--------------+------------------------+---------------+---------------+\n",
      "Wall time: 15.6 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "n = 20; coeffs = info[-1]; coef_pt = PrettyTable();\n",
    "coef_pt.field_names = [\"Lowest_Coeff\", \"Worst_Features\", \"Highest Coeff\", \"Best_Features\"]\n",
    "feature_names = ['HelpfulnessNumerator', 'HelpfulnessDenominator', 'Time', 'TextLength'] \\\n",
    "                    + tfidf_model.get_feature_names()\n",
    "coefs_with_fns = sorted(zip(coeffs, feature_names))\n",
    "top = zip(coefs_with_fns[:n], coefs_with_fns[:-(n + 1):-1])\n",
    "for (coef_1, fn_1), (coef_2, fn_2) in top:\n",
    "    coef_pt.add_row([round(coef_1,3), fn_1, round(coef_2,3), fn_2])\n",
    "print(coef_pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------------------+-----------------+-----------------+----------+-------+-------+-------+-------+\n",
      "| Text Vectorizer Model | Optimal K-value |  Scoring Metric | Accuracy |  TPR  |  TNR  |  FPR  |  FNR  |\n",
      "+-----------------------+-----------------+-----------------+----------+-------+-------+-------+-------+\n",
      "|          BOW          |       20.0      | precision_macro |  87.11   | 87.13 | 86.76 | 13.24 | 12.87 |\n",
      "|         TFIDF         |       0.01      | precision_macro |  87.11   | 86.85 | 92.12 |  7.88 | 13.15 |\n",
      "+-----------------------+-----------------+-----------------+----------+-------+-------+-------+-------+\n"
     ]
    }
   ],
   "source": [
    "pt.add_row([\"TFIDF\"] + info[:-1])\n",
    "print(pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "del tfidf_model, tfidf_train, tfidf_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusions :-\n",
    "-  For this Classification problem, Multinomial NB has been selected as the dataset contains discrete data - frequency of words through the use of Text Vectors (BOW and TFIDF).\n",
    "-  The Dataset being highly imbalanced (8:1) the Scoring metric has been selected based on the Model performance of - high TPR & TNR and low FPR & FNR.\n",
    "-  Based on the above performance criteria, both 'recall' and 'precision_macro' have shown to provide high True Negative Rate (TNR) or low False Positive Rate (FPR). Here, a subset of data has been taken and various Scoring Metrics have been applied to determine the best one. 'precision_macro' metric has been used here to evaluate the models. \n",
    "-  From the Performances obtained on the two Vectorizer models, it has been observed that TFIDF Vectorizer is giving the best performance - high TPR with a higher TNR.\n",
    "-  The Model performance might improve if the unbalancedness of the dataset can be treated with Oversampling - repeating Minority class or creating Synthetic datapoints using SMOTE.\n",
    "-  Reducing the 'n_components' in the Vectorizer models has proved to increase the True Negative Rate.\n",
    "-  The best features in both the Text-Vectorizer models shows similar results."
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}