Logistic Regression 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.linear_model import LogisticRegression\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 = [\"Model\", \"Optimal Parameters\", \"Scoring Metric\", \"Score\", \"TPR\", \"TNR\", \"FPR\", \"FNR\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def standardize_data(train, train_vectors, test, test_vectors):\n",
    "    sc = StandardScaler()\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 = np.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 = np.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": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_scores(optimal_model):\n",
    "    _, = plt.plot(list(optimal_model.cv_results_['param_C']), \\\n",
    "                      list(optimal_model.cv_results_['mean_train_score']), 'g-', \\\n",
    "                     label='Training Scores')\n",
    "    _, = plt.plot(list(optimal_model.cv_results_['param_C']), \\\n",
    "                      list(optimal_model.cv_results_['mean_test_score']), 'r-', \\\n",
    "                      label='Test Scores')\n",
    "    _, = plt.plot(optimal_model.best_params_['C'], optimal_model.best_score_, 'bo', \\\n",
    "                     label=f\"Optimal Value (a={optimal_model.best_params_['C']}, Score={round(optimal_model.best_score_,2)})\")\n",
    "\n",
    "    plt.xscale('log')\n",
    "    plt.xlabel('C-Values')\n",
    "    plt.ylabel('Scores')\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_LR(train, train_vectors, test, test_vectors, metric='precision_macro'):\n",
    "    '''\n",
    "    Perform Logisitic Regression modelling on the I/P Train and Test data.\n",
    "    1. Remove not required Columns, Standardize data and concatenate data with the text vectors.\n",
    "    2. Perform Cross Validation and find Optimal parameters - 'penalty' & 'c'.\n",
    "    3. Use the Optimal parameters 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, Standardize data and concatenate data with text vectors\n",
    "    X_train, y_train, X_test, y_test = standardize_data(train, train_vectors, test, test_vectors)\n",
    "\n",
    "    del train, train_vectors, test, test_vectors\n",
    "\n",
    "    lr = LogisticRegression(random_state=42, warm_start=True)\n",
    "    parameters = {'penalty':('l1', 'l2'), 'C':(0.01, 0.1, 1.0, 10.0), 'solver':('liblinear',)}\n",
    "    lr_optimal = GridSearchCV(lr, param_grid=parameters, cv=3, scoring=metric, verbose=0)\n",
    "    lr_optimal.fit(X_train, y_train)\n",
    "\n",
    "    # Plot Train vs Test Scores and the Optimal Parameter\n",
    "    plot_scores(lr_optimal)\n",
    "\n",
    "    # Confusion Matrix for Train Data\n",
    "    pred = []\n",
    "    for i in range(0, X_train.shape[0], 2000):\n",
    "        test_batch = X_train[i:i+2000]\n",
    "        pred.extend(lr_optimal.predict(test_batch))\n",
    "    conf_matrix = confusion_matrix(y_train, 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 for Train Data :-')\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",
    "    \n",
    "    del X_train, y_train\n",
    "    \n",
    "    # Confusion Matrix for Test Data\n",
    "    pred = []\n",
    "    for i in range(0, X_test.shape[0], 2000):\n",
    "        test_batch = X_test[i:i+2000]\n",
    "        pred.extend(lr_optimal.predict(test_batch))\n",
    "\n",
    "    ps = precision_score(y_test, pred, average='macro') * 100\n",
    "    print(f'\\nPrecision_Score of the Optimal LR classifier with parameters-{lr_optimal.best_params_} is {ps} %')\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 for Test Data :-')\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 [lr_optimal.best_params_, metric, round(ps,2), round(TPR*100,2), round(TNR*100,2), \\\n",
    "            round(FPR*100,2), round(FNR*100,2), lr_optimal.cv_results_, lr_optimal.best_estimator_.coef_[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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": [
    "## Collinearity Test using VIF for BOW Vectorizer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train = pd.read_csv('./Matrices/sample2_data_train.csv')\n",
    "data_test = pd.read_csv('./Matrices/sample2_data_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(28000, 6857) (12000, 6857)\n",
      "Wall time: 1.37 s\n"
     ]
    }
   ],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(28000, 4) (28000, 6857)\n",
      "X_Train: (28000, 6861)\n",
      "y_Train: (28000,)\n",
      "X_Test: (12000, 6861)\n",
      "y_Test: (12000,)\n",
      "Wall time: 2.04 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "X_train, y_train, X_test, y_test = standardize_data(data_train, bow_counts_train.toarray(), \\\n",
    "                                                    data_test, bow_counts_test.toarray())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('HelpfulnessDenominator', 22.15), ('HelpfulnessNumerator', 22.07), ('adam', 2.19), ('actor', 1.91), ('acid', 1.79), ('afterlif', 1.64), ('administr', 1.58), ('aerogarden', 1.56), ('TextLength', 1.49), ('abund', 1.35), ('acidophilus', 1.31), ('acerola', 1.26), ('abil', 1.24), ('add', 1.23), ('achiev', 1.2), ('ad', 1.19), ('abdomin', 1.18), ('abnorm', 1.18), ('accord', 1.18), ('activ', 1.18), ('accid', 1.17), ('advers', 1.17), ('addit', 1.16), ('affect', 1.16), ('affili', 1.16), ('acquir', 1.14), ('actual', 1.14), ('africa', 1.14), ('acn', 1.13), ('adhes', 1.13), ('abus', 1.12), ('adequ', 1.12), ('absorpt', 1.11), ('act', 1.11), ('adult', 1.11), ('aesthet', 1.11), ('accident', 1.1), ('action', 1.1), ('advoc', 1.1), ('abl', 1.09), ('accumul', 1.09), ('adher', 1.09), ('advantag', 1.09), ('advis', 1.09), ('aforement', 1.09), ('access', 1.08), ('accustom', 1.08), ('ach', 1.08), ('across', 1.08), ('adjust', 1.08), ('administ', 1.08), ('adopt', 1.08), ('adventur', 1.08), ('african', 1.08), ('aftertast', 1.08), ('absent', 1.07), ('absorb', 1.07), ('accent', 1.07), ('acr', 1.07), ('admir', 1.07), ('admiss', 1.07), ('admit', 1.07), ('afraid', 1.07), ('absolut', 1.06), ('absurd', 1.06), ('accept', 1.06), ('accomplish', 1.06), ('account', 1.06), ('acknowledg', 1.06), ('adapt', 1.06), ('addict', 1.06), ('address', 1.06), ('advertis', 1.06), ('afternoon', 1.06), ('Time', 1.05), ('abandon', 1.05), ('absenc', 1.05), ('advic', 1.05), ('aerat', 1.05), ('accur', 1.04), ('afford', 1.04), ('abc', 1.03), ('acai', 1.03), ('accompani', 1.03), ('ador', 1.03), ('aerogrow', 1.03), ('aficionado', 1.03), ('abroad', 1.02), ('accommod', 1.02), ('acquaint', 1.02), ('acrid', 1.02), ('advanc', 1.02), ('advert', 1.02), ('aero', 1.02), ('afghanistan', 1.02), ('absolutley', 1.01), ('acut', 1.01), ('adagio', 1.01), ('aeropress', 1.01), ('afficionado', 1.01)]\n",
      "Wall time: 7min 29s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "import statsmodels.api as sm\n",
    "from operator import itemgetter\n",
    "\n",
    "feat_names = feature_names = ['HelpfulnessNumerator', 'HelpfulnessDenominator', 'Time', 'TextLength'] \\\n",
    "                + cv_model.get_feature_names()\n",
    "vifs = []\n",
    "for i in range(100):\n",
    "    y = X_train[:,i]\n",
    "    x = np.delete(X_train[:, :500], i, 1)\n",
    "    rsq = sm.OLS(y, x).fit().rsquared\n",
    "    vif = round(1/(1-rsq), 2)\n",
    "    vifs.append((feat_names[i], vif))\n",
    "vifs.sort(key=itemgetter(1), reverse=True)\n",
    "print(vifs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion :-\n",
    "-  From the above results, only words 'HelpfulnessDenominator' and 'HelpfulnessNumerator' have very high collinearity, other features have values < 5%."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sparsity Comparison between 'L2' & 'L1' Regularized Models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 4 candidates, totalling 12 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done  12 out of  12 | elapsed:   29.4s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 30.9 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "lr = LogisticRegression(random_state=42, warm_start=True)\n",
    "parameters = {'penalty':('l2',), 'C':(0.01, 0.1, 1.0, 10.0), 'solver':('liblinear',)}\n",
    "lr_optimal = GridSearchCV(lr, param_grid=parameters, cv=3, scoring='precision_macro', verbose=1)\n",
    "lr_optimal.fit(X_train, y_train)\n",
    "l2_sparsity = lr_optimal.best_estimator_.coef_[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L2 Regularizer based Model Weight Vector has 0 zeros with Sparsity -> 0.0\n",
      "Weight Vector with values between 0 and 1 -> 4162\n"
     ]
    }
   ],
   "source": [
    "# Check for Sparsity (# of 0's) in L2 based Model Weight Vector\n",
    "print(f'L2 Regularizer based Model Weight Vector has {list(l2_sparsity).count(0)} zeros with Sparsity -> {list(l2_sparsity).count(0)/len(l2_sparsity)}')\n",
    "print(f'Weight Vector with values between 0 and 1 -> {len(l2_sparsity[(l2_sparsity > 0) & (l2_sparsity < 1)])}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 3 folds for each of 4 candidates, totalling 12 fits\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "[Parallel(n_jobs=1)]: Done  12 out of  12 | elapsed:   25.3s finished\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 26.6 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "lr = LogisticRegression(random_state=42, warm_start=True)\n",
    "parameters = {'penalty':('l1',), 'C':(0.01, 0.1, 1.0, 10.0), 'solver':('liblinear',)}\n",
    "lr_optimal = GridSearchCV(lr, param_grid=parameters, cv=3, scoring='precision_macro', verbose=1)\n",
    "lr_optimal.fit(X_train, y_train)\n",
    "l1_sparsity = lr_optimal.best_estimator_.coef_[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L1 Regularizer based Model Weight Vector has 6471 zeros with Sparsity -> 0.9431569742020114\n",
      "Weight Vector with values between 0 and 1 -> 207\n"
     ]
    }
   ],
   "source": [
    "# Check for Sparsity (# of 0's) in L2 based Model Weight Vector\n",
    "print(f'L1 Regularizer based Model Weight Vector has {list(l1_sparsity).count(0)} zeros with Sparsity -> {list(l1_sparsity).count(0)/len(l1_sparsity)}')\n",
    "print(f'Weight Vector with values between 0 and 1 -> {len(l1_sparsity[(l1_sparsity > 0) & (l1_sparsity < 1)])}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conclusion :-\n",
    "- From the results obtained above, it is seen that 'L1' Regularizer based Models create a lot sparser Weight Vector than 'L2' Regularizer based Model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BOW Vectorizer based model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56000, 9397) (24000, 9397)\n",
      "Wall time: 2.91 s\n"
     ]
    }
   ],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56000, 4) (56000, 9397)\n",
      "X_Train: (56000, 9401)\n",
      "y_Train: (56000,)\n",
      "X_Test: (24000, 9401)\n",
      "y_Test: (24000,)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEOCAYAAAB4nTvgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3Xd4VFX6wPHvm0JCL6ETmhBKSKEEFBXpTSQgWEAsWMDu6iq77FrBxs9eV0VFUFEUXSW7ohQFkbVAUEKVIiKGmtBDaEne3x93MpkUyAQymZT38zzzMHPuuXfeySXz5txz7jmiqhhjjDGnE+DvAIwxxpR+liyMMcYUypKFMcaYQlmyMMYYUyhLFsYYYwplycIYY0yhLFkYY4wplM+ShYhME5E9IrLmFNtFRF4Skc0iskpEOntsu05ENrke1/kqRmOMMd7xZctiOjDoNNsHAxGux3jgNQARqQM8DJwLdAMeFpHaPozTGGNMIXyWLFR1CbDvNFWGAe+q40eglog0AgYCC1R1n6ruBxZw+qRjjDHGx4L8+N5NgD89Xie7yk5Vflp169bVFi1aFGd8xhhT7q1YsSJVVesVVs+fyUIKKNPTlOc/gMh4nEtYNGvWjMTExOKLzhhjKgAR+cObev4cDZUMNPV4HQ7sOE15Pqo6VVXjVDWuXr1CE6Mxxpgz5M9kkQBc6xoVdR5wUFV3AvOAASJS29WxPcBVZowxxk98dhlKRD4EegF1RSQZZ4RTMICqvg7MBS4GNgPpwPWubftE5FFguetQk1X1dB3lxhhjfMxnyUJVRxeyXYHbT7FtGjDtbGM4efIkycnJHDt27GwPZUyFERoaSnh4OMHBwf4OxZQi/uzg9rnk5GSqV69OixYtECmo39wY40lV2bt3L8nJybRs2dLf4ZhSpFxP93Hs2DHCwsIsURjjJREhLCzMWuMmn3KdLABLFMYUkf3OlB2qypo9a9h+aLvP36vcJwt/2rt3Lx07dqRjx440bNiQJk2auF+fOHHCq2Ncf/31bNiw4bR1Xn31VWbOnFkcITNnzhw6duxIbGwskZGRvPXWW8VyXGNM8TiReYKFWxZy15d30fLFlkS/Fs11n/t+Cr1y3Wfhb2FhYaxcuRKARx55hGrVqnHfffflqqOqqCoBAQXn7XfeeafQ97n99gLHCRTZ8ePHufXWW0lMTKRx48YcP36cP/7w6n6dUyrs8xljCrf/6H6+3PwlCRsS+HLzlxw6fojKQZXp36o/QQFBpJ1I83kM9hvsB5s3byYqKopbbrmFzp07s3PnTsaPH09cXBwdOnRg8uTJ7roXXnghK1euJCMjg1q1ajFx4kRiY2Pp3r07e/bsAeCBBx7ghRdecNefOHEi3bp1o23btnz//fcAHDlyhJEjRxIbG8vo0aOJi4tzJ7JsBw8eRFWpU6cOACEhIbRp0waAXbt2MWzYMGJiYoiNjeWnn34C4KmnniIqKoqoqChefvnlU36+L7/8ku7du9O5c2euvPJKjhw5AsCECROIjIwkJiaGv//97776kRtT5mzZv4UXfnyBPjP6UO/peoz59xgWb13MFZFXkDAqgdS/pTJn1Bxa12ldIvFUmJbF3V/dzcpdKwuvWAQdG3bkhUEvnNG+69at45133uH1118HYMqUKdSpU4eMjAx69+7NZZddRmRkZK59Dh48SM+ePZkyZQp//etfmTZtGhMnTsx3bFVl2bJlJCQkMHnyZL766itefvllGjZsyKeffkpSUhKdO3fOt1/9+vUZOHAgzZs3p2/fvgwdOpQrr7ySgIAAbr/9dvr3788dd9xBRkYG6enpLFu2jJkzZ7Js2TIyMzPp1q0bPXv2pEqVKrk+3549e5gyZQpff/01VapU4fHHH+fFF1/kxhtvZO7cuaxduxYR4cCBA2f0szSmPMjSLJZtX0bChgQSNiSwNmUtAB3qdeBvF/yN+LbxdGvSjQDxz9/4FSZZlDatWrWia9eu7tcffvghb7/9NhkZGezYsYN169blSxaVK1dm8ODBAHTp0oXvvvuuwGOPGDHCXWfr1q0ALF261P2Xe2xsLB06dChw3+nTp7Nq1SoWLlzo/oJ/6623WLx4MbNmzQIgKCiIGjVq8N133zFy5EiqVKkCwPDhw1m6dCkDBgzI9fm+//571q1bx/nnnw/AiRMnuPDCC6lTpw4BAQGMGzeOIUOGcMkllxT552hMWZZ+Mp2FWxaSsCGB/278L7uP7CZQArmo+UXc1PkmhrYZSqs6rfwdJlCBksWZtgB8pWrVqu7nmzZt4sUXX2TZsmXUqlWLq6++usChi5UqVXI/DwwMJCMjo8Bjh4SE5Kvj3APpnZiYGGJiYrjqqqto3769u5M77yiZ0x3T8/OpKoMGDeK9997LVy8xMZEFCxYwa9YsXnvtNebPn+91nMaURbvSdvHfjf8lYUMCC7Ys4FjGMWqE1GBw68HEt41ncOvB1K5c+pbwsT6LUuDQoUNUr16dGjVqsHPnTubNK/6psC688EI+/vhjAFavXs26desKjGPJkiXu1ytXrqR58+YA9O7d233JLDMzk0OHDnHRRRfx2WefcfToUdLS0pgzZw49evTId9zzzz+fb7/9li1btgBO/8mmTZs4fPgwhw4d4pJLLuH555/nl19+KfbPbYy/ZQ9vfeK7JzjvrfNo9Gwjxv1nHKt2r2Jc53EsuGYBKRNSmHXZLK6KvqpUJgqoQC2L0qxz585ERkYSFRXFOeecwwUXXFDs73HnnXdy7bXXEhMTQ+fOnYmKiqJmzZq56qgqTz75JOPGjaNy5cpUq1aNadOcWVdeeeUVxo0bxxtvvEFQUBBvvPEG3bp1Y/To0e7LTbfeeivR0dFs3rw513EbNGjA22+/zZVXXukeMvzEE09QuXJlRowYwfHjx8nKyuK5554r9s9tjD+czDzJd9u+c/c//H7gdwC6Nu7Ko70fJb5tPNH1o4vlnpY5o+agBa/iUKykKJcnSrO4uDjNu57F+vXrad++vZ8iKl0yMjLIyMggNDSUTZs2MWDAADZt2kRQkP29YPKz352iO3jsoHt469xNczl4/CAhgSH0O6cf8W3juaTNJTSu3tjfYeYjIitUNa6wevZNUUGkpaXRt29fMjIyUFV3C8EYc+a2HtjKfzb8h4SNCSzeupiMrAzqVanHiPYjiG8bT/9z+lO1UtXCD1QG2LdFBVGrVi1WrFjh7zCMKdOyNIsVO1Y4l5c2JrBq9yoA2tdtz73d7yW+bTznNjmXwIBAP0da/CxZGGPMaRw9eZRvfv+GhA0J/Gfjf9iZtpMACaBHsx48O+BZhrYZSkRYhL/D9DlLFsYYk8eeI3v4YuMXJGxMYP5v80k/mU61StVyDW8NqxLm7zBLlCULY0yFp6r8mvqr+/LSD3/+gKI0rdGU6zteT3zbeHo270lIUIi/Q/UbnyYLERkEvAgEAm+p6pQ825vjrIhXD9gHXK2qya5tTwFDcO4FWQD8RcvL0C1jjN9lZGXwv23/cyeIzfucId+dG3XmkV6PEN82ntgGsTZlu4sv1+AOBF4F+gPJwHIRSVBVz7vBngHeVdUZItIHeBK4RkTOBy4AYlz1lgI9gcW+itcX9u7dS9++fQFnIr7AwEDq1asHwLJly3LdkX0606ZN4+KLL6Zhw4b5tv3vf//jr3/9K8ePH+f48eNcddVVPPjgg8X3IYwpRw4dP8S8zfNI2JjAFxu/YP+x/VQKrESfln3463l/ZWjboYTXCPd3mKWSL1sW3YDNqroFQERmAcMAz2QRCdzjer4I+Nz1XIFQoBIgQDCw24ex+oQ3U5R7Y9q0aXTu3LnAZHHdddfx+eefExUVRWZmZqFrX3gjMzOTwMDyN5rDVEzbDm5zD29d9PsiTmadJKxyGEPbDiW+TTwDWg2gekh1f4dZ6vlyuo8mwJ8er5NdZZ6SgJGu55cC1UUkTFV/wEkeO12Peaq63oexlrgZM2bQrVs3OnbsyG233UZWVhYZGRlcc801REdHExUVxUsvvcRHH33EypUrufLKKwtcNCklJcWdRAIDA92TDx4+fJjrrruO6OhoYmJi+PxzJw+///777uP/85//BHBPf/7AAw/QrVs3li1bxvLly+nZsyddunRh8ODB7N7t5Ornn3+eyMhIYmNjufrqq0vqx2WM11SVFTtW8PCih+n0Rieav9CcO768g9/3/85fzv0LS8YuYdd9u5gxfAYjI0daovCSL1sWBV3oy9vncB/wioiMBZYA24EMEWkNtAey24MLROQiVV3iubOIjAfGAzRr1uz00dx9N6ws3inK6dgRXij6BIVr1qzhs88+4/vvvycoKIjx48cza9YsWrVqRWpqKqtXrwbgwIED1KpVi5dffplXXnmFjh075jvW3XffTUREBL1792bw4MFce+21hISE8Mgjj1CvXj1Wr16NqnLgwAGSk5N54IEHSExMpGbNmvTr14///ve/DBo0iIMHD9K5c2cee+wxjh8/Tu/evUlISKBu3brMnDmTBx98kKlTp/LUU0/xxx9/UKlSJZtS3JQaxzKOsej3Re7hrdsPbydAAji/6fk81e8p4tvG07ZuW3+HWab5MlkkA009XocDOzwrqOoOYASAiFQDRqrqQVcS+FFV01zbvgTOw0konvtPBaaCM92Hjz5HsVu4cCHLly8nLs65w/7o0aM0bdqUgQMHsmHDBv7yl79w8cUXM2DAgEKPNWnSJK655hrmz5/Pu+++y0cffcTChQtZuHChuzUhItSuXZtvvvmGPn36ULduXQCuuuoqlixZwqBBg6hUqRKXXnop4Ez1sHbtWvr16wc4l6XCw5283aFDB66++mqGDRvG8OHDi/1nY4y3UtNT3cNb522ex5GTR6gaXJWBrQcS3yaeiyMupl7Vev4Os9zwZbJYDkSISEucFsMo4CrPCiJSF9inqlnAP3BGRgFsA8aJyJM4LZSewNnNMX4GLQBfUVVuuOEGHn300XzbVq1axZdffslLL73Ep59+ytSpUws9XuvWrWndujXjxo0jLCzMveJdUaYUr1y5sru+qhITE1Pgehnz5s3j22+/Zc6cOTz22GOsWbPG+jdMidmQusE9eun7P78nS7NoXL0x18RcQ3zbeHq37E1oUKi/wyyXfNZnoaoZwB3APGA98LGqrhWRySIS76rWC9ggIhuBBsDjrvJPgN+A1Tj9Gkmq+h9fxVrS+vXrx8cff0xqairgjJratm0bKSkpqCqXX345kyZN4ueffwagevXqHD58uMBjffHFF+4ksHHjRkJCQqhevToDBgzglVdeAZwv//3793PeeeexaNEi9u7dS0ZGBrNmzaJnz575jhkZGcn27dtZtmwZ4CxWtHbtWjIzM0lOTqZPnz48/fTTpKSkkJ6eXuw/H2OyZWZlsnTbUv624G+0faUt7V5tx98W/o20E2k80OMBEsclknxPMq9d8hqDIwZbovAhn95noapzgbl5yh7yeP4JTmLIu18mcLMvY/On6OhoHn74Yfr160dWVhbBwcG8/vrrBAYGcuONN7pbBf/3f/8HwPXXX89NN91E5cqV8w25nT59Ovfccw9VqlQhODiYDz74gICAAB5++GFuu+02oqKiCAwM5NFHHyU+Pp7JkyfTq1cvVJWhQ4cyZMiQfIsohYSE8Mknn3DXXXdx+PBhMjIyuPfee2ndujVXXXUVhw8fJisri7///e9Ur26dg6Z4pZ1IY/5v892rx+09upfggGB6t+zNXd3uYmjboTSrWUgfpSl2NkW5MSafkv7d2X5oO//Z+B8SNiTw9e9fcyLzBLVDazOkzRDi28QzsPVAaoTUKLF4KhKbotwYU2qpKkm7k9yLA63Y6cyI3Kp2K+7oegfxbeO5oNkFBAXYV1RpYWfCGFMijmcc59s/vnUniD8P/YkgdG/anSl9pxDfNp52ddvZ9BqllCULY4zP7Du6j7mb5pKwIYGvNn/F4ROHqRJchQGtBjCp1ySGtBlC/ar1/R2m8YIlC2NMsdq8b7O79bB021IyNZOG1RoyKmoU8W3j6duyL5WDK/s7TFNEliyMMWclMyuTn7b/5E4Q61OdmXmi60cz8cKJxLeNJ65xHAHiy9mFjK9ZsjDGFNmRE0dYsGWBe3hrSnoKQQFB9Gzek1vibmFom6G0rN3S32GaYmSp3seSk5MZNmwYERERtGrVir/85S/5JgPM68CBA/zrX/9yv96xYweXXXZZscTzyCOP8Mwzz+QqW7x4Md27d89VlpGRQYMGDdi5c2eRjnWmjh49Ss+ePcnMzDyr4+zbt4/+/fsTERFB//792b9/f4H1Bg0aRK1atbjkkku8Ou6GDRvo1asXHTt2pH379owfP/6s4iwOM2bMICIigoiICGbMmFFgnaSkJLp37050dDRDhw7l0KFDAKxevZqxY8cW6f1UlRkrZ3DJB5cQ9lQYl350Kf9e/2/6ndOPD0d+SMqEFBZeu5C7zr3LEkU5ZMnCw8yZ0KIFBAQ4/86ceXbHU1VGjBjB8OHD2bRpExs3biQtLY3777//tPvlTRaNGzfmk0/y3btYbC666CKSk5PZunWru2zhwoVERUXRqFEjn72vp2nTpjFixIiznjpkypQp9O3bl02bNtG3b1+mTJlSYL0JEybw3nvveX3cu+66i3vuuYeVK1eyfv167rzzzrOKEzirxLhv3z4mTZrETz/9xLJly5g0aVKBifGmm25iypQprF69mksvvZSnn34acG4MTU5OZtu2bV6/58a9Gxk7Zyyr96zmlrhb+Prar0mZkMIHIz9gVNQoaoXWOuPPY0o/SxYuM2fC+PHwxx+g6vw7fvzZJYxvvvmG0NBQrr/+esCZQvz5559n2rRppKenM336dIYNG8agQYNo27YtkyZNAmDixIn89ttvdOzYkQkTJrB161aioqIA547t4cOHM3ToUFq2bMkrr7zCc889R6dOnTjvvPPYt28fAG+++SZdu3YlNjaWkSNHnnZajoCAAC6//HI++ugjd9msWbMYPXq018fq1asX2TdFpqam0qJFC8D5QpwwYQJdu3YlJiaGN954o8AYZs6cybBhwwBIS0ujb9++dO7cmejoaObMmeP1z3zOnDlcd911QM5aHwXp27dvke4+37lzp3syRXC+bMH5fPfdd597KviXX34ZgK+//ppOnToRHR3NDTfcwPHjxwFo0aIFkydP5sILL2T27Nn89ttvDBo0iC5dutCjRw9+/fVXr+KZN28e/fv3p06dOtSuXZv+/fvz1Vdf5au3YcMGLrroIgD69+/Pp59+6t42dOhQZs2a5fXP4GTWSQCeHfAsLwx6gT4t+xAcGOz1/qZss2Thcv/9kPc7MD3dKT9Ta9eupUuXLrnKatSoQbNmzdi82VnCcdmyZcycOZOVK1cye/ZsEhMTmTJlCq1atWLlypXuvwQ9rVmzhg8++IBly5Zx//33U6VKFX755Re6d+/Ou+++C8CIESNYvnw5SUlJtG/fnrfffvu0sY4ePdr9xXH8+HHmzp3LyJEjz+hYnt5++21q1qzJ8uXLWb58OW+++Sa///57rjonTpxgy5Yt7gQTGhrKZ599xs8//8yiRYu499573fNf9ejRg44dO+Z7LFy4EIDdu3e7W0ONGjViz549Xsd6Ovfccw99+vRh8ODBPP/88+7p2adOncrvv//OL7/8wqpVqxgzZgzHjh1j7NixfPTRR6xevZqMjAxee+0197FCQ0NZunQpo0aNYvz48bz88susWLGCZ555httuuw1wkmdBnzP7cuT27dtp2jRnUufw8HC2b9+eL+6oqCgSEhIAmD17Nn/+mbPETFxcXIGTRRpTEOvgdjlVa7wIrfR8Cpr5NW95//79CQsLA5wv5aVLlxY69Xfv3r2pXr061atXp2bNmgwdOhRw/tpdtWoV4CSUBx54gAMHDpCWlsbAgQNPe8yuXbuSlpbGhg0bWL9+Peeddx61a9c+o2N5mj9/PqtWrXJfRjt48CCbNm2iZcuca9qpqanUqpVzCUNV+ec//8mSJUsICAhg+/bt7N69m4YNG/rty+36669n4MCBfPXVV8yZM4c33niDpKQkFi5cyC233EJQkPOrVKdOHZKSkmjZsiVt2rQBnBbOq6++yt133w3AlVdeCTgtqO+//57LL7/c/T7ZLZAxY8YwZsyYU8ZT0DQ9Bf1fmzZtGnfddReTJ08mPj4+17xi9evXZ8eOHfn2MaYglixcmjVzLj0VVH6mOnTokKvZD3Do0CH+/PNPWrVqxYoVK/L9gntz92pISIj7eUBAgPt1QECAe1LAsWPH8vnnnxMbG8v06dNZvHhxoccdNWoUs2bNYv369e5LUN4eKygoiKysLACOHTvmLldVXn755dMmmMqVK+faZ+bMmaSkpLBixQqCg4Np0aKFe3uPHj0KnIH3mWeeoV+/fu5O+UaNGrFz507q1y++G74aN27MDTfcwA033EBUVBRr1qwp8lTwAFWrVgUgKyuLWrVquZfe9TRz5swCW5WtW7fmk08+ITw8PNd5SE5OplevXvnqt2vXjvnz5wPOrMRffPGFe9uxY8eoXNnudzDesctQLo8/DlWq5C6rUsUpP1N9+/YlPT3dfWkoMzOTe++9l7Fjx1LF9WYLFixg3759HD16lM8//5wLLrjgtFOSe+vw4cM0atSIkydPMtPLjpfRo0fz/vvv88033xAfH+8u9+ZYLVq0YMUKZ34fz874gQMH8tprr3HypHO9e+PGjRw5ciTXvrVr1yYzM9OdEA4ePEj9+vUJDg5m0aJF/OGRxb/77jtWrlyZ75G9UFN8fLx7ZNCMGTPc/SDe+sc//sFnn32Wr/yrr75yf4Zdu3axd+9emjRpwoABA3j99dfdSXrfvn20a9eOrVu3ui81vvfeewVOBV+jRg1atmzJ7NmzAdd8SUlJgNOyKOhzZv9sBw4cyPz589m/fz/79+9n/vz5BSbk7MtwWVlZPPbYY9xyyy3ubRs3bnT3hRlTGEsWLmPGwNSp0Lw5iDj/Tp3qlJ8pEeGzzz5j9uzZRERE0KZNG0JDQ3niiSfcdS688EKuueYaOnbsyMiRI4mLiyMsLIwLLriAqKgoJkyYcEbv/eijj3LuuefSv39/2rVr59U+kZGRVKlShT59+rj/+vX2WPfddx+vvfYa559/vnudDnBG40RGRtK5c2eioqK4+eab802JDjBgwACWLl0KOF+UiYmJxMXFMXPmTK/jB2dwwIIFC4iIiGDBggVMnDgRgMTERG666SZ3vR49enD55Zfz9ddfEx4ezrx58wBnSGn2muae5s+fT1RUFLGxsQwcOJCnn36ahg0bctNNN9GsWTNiYmKIjY3lgw8+IDQ0lHfeeYfLL7+c6OhoAgICcn1Je5o5cyZvv/02sbGxdOjQwevO/Dp16vDggw/StWtXunbtykMPPUSdOnUA52eePdjgww8/pE2bNrRr147GjRu7B1sALFq0iCFDhnj1fsagquXi0aVLF81r3bp1+cpKk3feeUdvv/12f4dRKvz888969dVX+zsMHTBggL9DKBHHjh3Tc889V0+ePFng9oJ+d1bvXq08gs5eO9vX4ZkSBCSqF9+x1rIwpUKnTp3o3bv3Wd+Ud7ayWxjl3bZt25gyZYq7Y96Ywvg0WYjIIBHZICKbRWRiAdubi8jXIrJKRBaLSLjHtmYiMl9E1ovIOhFp4ctY/WHs2LHupU8N3HDDDbaedwmJiIgosEPcmFPxWbIQkUDgVWAwEAmMFpHIPNWeAd5V1RhgMvCkx7Z3gadVtT3QDSieAfPGGGOKzJcti27AZlXdoqongFlA3qEpkcDXrueLsre7kkqQqi4AUNU0VT31LcinoeVk2VhjSor9zpiC+DJZNAH+9Hid7CrzlASMdD2/FKguImFAG+CAiPxbRH4RkaddLZUiCQ0NZe/evfaf3xgvqSp79+4lNDTU36GYUsaXvVsF3V2W91v7PuAVERkLLAG2AxmuuHoAnYBtwEfAWCDXPBMiMh4YD9CsgLvnwsPDSU5OJiUl5Sw+hjEVS2hoaK55sIwB3yaLZKCpx+twINfcAqq6AxgBICLVgJGqelBEkoFfVHWLa9vnwHnkSRaqOhWYChAXF5ev+RAcHJxrWgljjDFnxpfJYjkQISItcVoMo4CrPCuISF1gn6pmAf8ApnnsW1tE6qlqCtAHSPRhrMaYAmRkZbBx70aSdiWxeOtif4dj/MhnyUJVM0TkDmAeEAhMU9W1IjIZ5yaQBKAX8KSIKM5lqNtd+2aKyH3A1+JMvLMCeNNXsRpj4MCxA6zavYqkXUms3LWSpN1JrE1Zy7EMZxqW4IBgujTqQqeGnfwcqfEHKS+dv3FxcZo9xYEx5tSyNIvf9/9O0u6cpJC0K4k/DubMwVW3Sl1iG8Q6j4axdGzYkXZ121EpsNJpjmzKIhFZoapxhdWz2zeNKceOnDjCmj1rciWGVbtXkXYiDYAACaBNWBvOCz+Pm7vcTMeGHYltGEujao28mgHZVByWLIwpB1SV7Ye357qElLQ7iU17N6GuQYg1QmoQ0yCG62KvI7aB01roUL8DVYKrFHJ0YyxZGFPmHM84zvrU9fkSw76j+9x1WtZqSWzDWEZHjXZaCw1iaVGrhbUWzBmzZGFMKZZyJMXdp7By90qSdiWxPnU9GVnONO+hQaFE149mRLsR7r6F6PrR1Ayt6efITXljycKYUiAzK9MZoponMexM2+mu07h6Y2IbxDIkYoi7byGiTgSBATb5ovE9SxbGlLCDxw46Q1Q9Op3X7FnjHqIaFBBEZL1I+p3Tz923ENswlrpV6vo5clORWbIwxkeyNIutB7aStCspV2LYemCru05Y5TBiG8Zya9yt7r6F9vXa2xBVU+pYsjCmGKSfTHeGqO7KPUT18AlnLXVBaBPWhm5NujGu8zh3YmhcvbF1OpsywZKFMUWgquw4vCNf38KmfZvI0iwAqleqTkyDGK6JucZ9CSmqfpQNUTVlmiULY07hROYJ1qesz3en896je911WtRqQWyDWK7scKU7MbSo1YIAsRWLTfliycIYIDU9NV/fwvqU9ZzMOgk4Q1Sj6kcxvN1w9yWkmAYxNkTVVBiWLEyFkpmVyaZ9m/IIwOWiAAAedklEQVTd0LbjcM7s+Y2qNSK2YSyDWw92J4aIsAiCAuzXxVRc9r/flFuHjh/KN4vqmj1rOJpxFHCGqLav254+LfvQsYFzCSm2QSz1qtbzc+TGlD6WLEyZp6rOENU8fQu/H/jdXadO5TrENojNNVle+7rtCQkK8WPkxpQdlixMmXL05NECZ1E9dPwQ4AxRjQiLIK5xHDd1vsk9xXaT6k1siKoxZ8GShSmVVJWdaTvzdTpv3LvRPUS1WqVqxDSIYUz0GHffQlT9KKpWqurn6I0pfyxZmFLpsSWP8dDih9yvm9dsTmzDWK6IvMLdt9CydksbompMCfFpshCRQcCLOMuqvqWqU/Jsb46z7nY9YB9wtaome2yvAawHPlPVO3wZqyldNu/fTN0qdfn0ik+JaRBDrdBa/g7JmArNZ3+WiUgg8CowGIgERotIZJ5qzwDvqmoMMBl4Ms/2R4FvfRWjKd2qVarGRc0vskRhTCngyzZ8N2Czqm5R1RPALGBYnjqRwNeu54s8t4tIF6ABMN+HMRpjjPGCL5NFE+BPj9fJrjJPScBI1/NLgeoiEiYiAcCzwITTvYGIjBeRRBFJTElJKaawjTHG5OXLZFHQOEXN8/o+oKeI/AL0BLYDGcBtwFxV/ZPTUNWpqhqnqnH16tmNVMYY4yu+7OBOBpp6vA4HdnhWUNUdwAgAEakGjFTVgyLSHeghIrcB1YBKIpKmqhN9GK8xxphT8GWyWA5EiEhLnBbDKOAqzwoiUhfYp6pZwD9wRkahqmM86owF4ixRGGOM//jsMpSqZgB3APNwhr9+rKprRWSyiMS7qvUCNojIRpzO7Md9FY8xxpgz59P7LFR1LjA3T9lDHs8/AT4p5BjTgek+CM8YY4yX7PZXY4wxhbJkYYwxplCWLIwxxhTKkoUxxphCWbIwxhhTKEsWxhhjCmXJwhhjTKEsWRhjjCmUJQtjjDGFsmRhjDGmUF4lCxG5XESqu54/ICL/FpHOvg3NGGNMaeFty+JBVT0sIhcCA4EZwGu+C8sYY0xp4m2yyHT9OwR4TVXnAJV8E5IxxpjSxttksV1E3gCuAOaKSEgR9jXGGFPGefuFfwXOuhSDVPUAUIdC1sc2xhhTfniVLFQ1HdgDXOgqygA2+SooY4wxpYu3o6EeBv6Os/QpQDDwvhf7DRKRDSKyWUTyLYsqIs1F5GsRWSUii0Uk3FXeUUR+EJG1rm1Xev+RjDHGFDdvL0NdCsQDRwBUdQdQ/XQ7iEgg8CowGIgERotIZJ5qzwDvqmoMMBl40lWeDlyrqh2AQcALIlLLy1iNMcYUM2+TxQlVVUABRKSqF/t0Azar6hZVPQHMAoblqRMJfO16vih7u6puVNVNruc7cC6B1fMyVmOMMcXM22TxsWs0VC0RGQcsBN4sZJ8mwJ8er5NdZZ6SgJGu55cC1UUkzLOCiHTDGab7m5exGmOMKWZB3lRS1WdEpD9wCGgLPKSqCwrZTQo6VJ7X9wGviMhYYAmwHafz3DmASCPgPeA6Vc3K9wYi44HxAM2aNfPmoxhjjDkDhSYLV9/DPFXtBxSWIDwlA009XocDOzwruC4xjXC9TzVgpKoedL2uAXwBPKCqPxb0Bqo6FZgKEBcXlzcRGWOMKSaFXoZS1UwgXURqFvHYy4EIEWkpIpWAUUCCZwURqSsi2TH8A5jmKq8EfIbT+T27iO9rjDGmmHl1GQo4BqwWkQW4RkQBqOpdp9pBVTNE5A6cm/kCgWmqulZEJgOJqpoA9AKeFBHFuQx1u2v3K4CLgDDXJSqAsaq60utPVgSHjx8mS7OoEVIDkYKunhljTMXmbbL4wvUoElWdC8zNU/aQx/NPgE8K2O99vLiPozikn0yn0bONOHLyCMEBwdStUjfXo16VevnLquaUhQaFlkSYxhjjV952cM9wXRpq4yraoKonfRdWyTly4ghHTh5hWNthtK/bntT0VFKPppKansqq3atITU9l39F9aL6+eUfV4Kq5kkdBCcbzdZ3KdQgMCCzhT2mMMWfHq2QhIr1wpiXfijPKqamIXKeqS3wXWsnqf05/bu92e4HbMrMy2X9sP6npqaQcSXESiuuRkp779a+pv5KankraibQCjyUIdSrXKbQF45mAqleqbpfHjDF+5e1lqGeBAaq6AUBE2gAfAl18FVhpEhgQ6P7ible3nVf7HMs4xt70vfmSiTvZuFovW/ZvYdn2ZaSmp3Iyq+DGWqXASoUnlzyvQ4JCivNHYIyp4LxNFsHZiQKcO6xFJNhHMZULoUGhNKnRhCY18t6HWDBV5fCJw161XlbuWum+PHYq1StVL1LrpXZobbs8Zow5JW+TRaKIvI1zgxzAGGCFb0KqmESEGiE1qBFSg3Nqn+PVPhlZGew/ur/Q1sueI3tYl7KO1PRUjpw8UuCxAiQg3+Wxwlov1SpVs8tjxlQQ3iaLW3GGtd6F02exBPiXr4Iy3gkKCKJe1XrUq+r9tFlHTx5l79G9hbZeNu/bzI/JP5KankpGVkaBxwoJDClS66VulbpUCrQFFo0pi7xNFkHAi6r6HLjv6raL4mVQ5eDKhAeHE14j3Kv6qsqh44dO3XpxtWBSjqTw886fSU1PZf+x/ac8Xo2QGl61XvYfPfUxjDElz9tk8TXQD8ge4lMZmA+c74ugTOkhItQMrUnN0Jq0rtPaq30ysjLYd3Rfoa2XXWm7WLNnDanpqaSfTM93nDZhbQo4ujHGH7xNFqGq6h4LqqppIlLFRzGZMi4oIIj6VetTv2p9r/dJP5meK5GkpqcSUSfCh1EaY4rC22RxREQ6q+rPACISBxz1XVimoqkSXIVmNZvRrKbNHmxMaeRtsrgbmC0iO3CmGW8M2FKnxhhTQZx21lkR6SoiDVV1OdAO+AhnvYmvgN9LID5jjDGlQGFTlL8BnHA97w78E2dd7f241pEwxhhT/hV2GSpQVbNvE74SmKqqnwKfiohPpgs3xhhT+hTWsggUkeyE0hf4xmObt/0dxhhjyrjCvvA/BL4VkVSc0U/fAYhIa+Cgj2MzxhhTSpw2Wajq4yLyNdAImK+q2Ys6BAB3+jo4Y4wxpYM3a3D/qKqfqarncqobs++5OB0RGSQiG0Rks4hMLGB7cxH5WkRWichiEQn32HadiGxyPa4ryocyxhhTvApNFmfKNX/Uq8BgIBIYLSKReao9A7yrqjHAZOBJ1751gIeBc4FuwMMiUttXsRpjjDk9nyULnC/5zaq6RVVPALOAYXnqROLMOwWwyGP7QGCBqu5T1f3AAmCQD2M1xhhzGr5MFk2APz1eJ7vKPCUBI13PLwWqi0iYl/uacmrmTGjRAgICnH9nzvR3RMYYXyaLglbF0Tyv7wN6isgvQE9gO84d4t7si4iMF5FEEUlMSUk523hNKTBzJowfD3/8AarOv+PHW8Iwxt98mSySgaYer8OBHZ4VVHWHqo5Q1U7A/a6yg97s66o7VVXjVDWuXj3vFwAypdf990N6ntnK09Ph/r9nONnDGOMXvryxbjkQISItcVoMo4CrPCuISF1gn6pmAf8Aprk2zQOe8OjUHuDabsq5bdtOUb49AOrXh5iYnEd0NHToAJUrl2yQxlRAPksWqpohInfgfPEHAtNUda2ITAYSVTUB6AU8KSKKs1Tr7a5994nIozgJB2Cyx7Qjphxr1sy59JSvvHYaDB8Oq1bB1Kk5zY+AAIiIyJ9EWrQAWx/cmGLj0yk7VHUuMDdP2UMezz8BPjnFvtPIaWmYCuLxx50+Cs9LUVWqwOMv14AxbzoFWVmwZYuTOLIfP/8Ms2fn7FS9upM0PJNIVBTUrFmyH8iYcsLmdwJGroXow4thRQAEB0NQkPM4m+en2mZ/7Z7WmDHOv/ffnMq2I3Vo1jyAxx/PKQec1kTr1s5jxIic8rQ0WLMGVq/OSSKzZsHrr+fUad48dwKJiXGOE2S/Csacjmg56TSMi4vTxMTEIu+XmryJuk1LcK3ngGJMSKX9+dkkxuuugyVL4PezXDZFFZKTncThmUR+/RUyM506oaEQGZk/idigCVMBiMgKVY0rrJ79OZWRAcD3tw/j/AffgJMnnbKMjNL3/OhROHy46PtmZfnnZxsQcOaJ5tdfi6fjWgSaNnUeQ4bklB8/DuvX504iX30F06fn1GnQIH8Cad8eQkLOPi5jyhhLFi4nK1dyvhzKo6ysnASSN6GUlkSY93nr1tC7t+9+JiEh0LGj8/C0Z09O8sj+99VX4dgxZ3tgILRtmz+JhIfbJUZTrlmyqAgCAqBSJedhTq9+fejb13lky8iAzZtzLmGtXg0//uj0h2SrVavgDvVq1Ur+MxjjA5YsjClMUBC0a+c8rrgip/zgQadD3XNU1rvvOpcKs7VqlT+JnHOO00IxpgyxZGHMmapZEy64wHlky56jxDOBrF4NCQk5fUdVqjitDs8kEh0NYWH++RzGeMGShTHFScS5IbBFC4iPzyk/ehTWrcudRObMgbffzqnTpElO4shOIm3b2uVDUypYsjCmJFSuDF26OI9sqrB7d+4EsmoVLFzodPKDMzKsffv8SaRRI+tQNyXKkoUx/iICDRs6jwEDcspPnoSNG3MnkMWL4f33c+qEheVPIB06OJe4jPEBSxbGlDbBwc4Xf4cOMHp0Tvn+/blvLFy1Ct56K2duFJGcebI8k0j24iDGnAVLFsaUFbVrw0UXOY9s2fNkeSaRlSvh009zpnSvVi1/Z3p0tDPc1xgvWbIwpizznCfr0ktzytPSYO3a3Enk44/hjTdy6jRrln+23jZtbJ4sUyD7X2FMeVStGpx7rvPIpgrbt+ce0ps9zYlr2htCQvLPkxUdXX5nNzBes2RhTEUh4kxLEh4OF1+cU378uDMXl2cSmT8fZszIqZO98FTnzvDPf9pU7xWQJQtjKrqQEIiNdR6eUlJyz5M1f74zrHfpUmeqk6ZNCz6eKZdsiIQxpmD16kGfPnD33c7Ng9u2wYMPwooVTt/G/ffDoUP+jtKUEJ8mCxEZJCIbRGSziEwsYHszEVkkIr+IyCoRudhVHiwiM0RktYisFxFbf9sYfxOByZNhwwZn0aknnnA61l97LafPw5RbPksWIhIIvAoMBiKB0SISmafaA8DHqtoJGAX8y1V+ORCiqtFAF+BmEWnhq1iNMUXQvDnMnAnLljmTK952m9MJ/t//5gzXNeWOL1sW3YDNqrpFVU8As4BheeooUMP1vCaww6O8qogEAZWBE4C1d40pTbp2hW+/hc8+c1YdHDoU+vWDX37xd2TGB3yZLJoAf3q8TnaVeXoEuFpEkoG5wJ2u8k+AI8BOYBvwjKru82GsxpgzIQLDhzv3dLz8MiQlOfNfXXcd/Pln4fubMsOXyaKgWc7ytlFHA9NVNRy4GHhPRAJwWiWZQGOgJXCviJyT7w1ExotIoogkpqSkFG/0xhjvBQfDHXc4i0RNmAAffeR0gj/wQO71PUyZ5ctkkQx4jq0LJ+cyU7YbgY8BVPUHIBSoC1wFfKWqJ1V1D/A/IN+C4qo6VVXjVDWuXr16PvgIxpgiqVUL/u//nPs2Lr0UHn/c6QR//XXrBC/jfJkslgMRItJSRCrhdGAn5KmzDegLICLtcZJFiqu8jziqAucBv/owVmNMcWrRAj74AH76yVmT49ZbnZv6vvjCOsHLKJ8lC1XNAO4A5gHrcUY9rRWRySKSvSrMvcA4EUkCPgTGqqrijKKqBqzBSTrvqOoqX8VqjPGRbt1yOsEzMuCSS5xO8JUr/R2ZKSKf3sGtqnNxOq49yx7yeL4OuKCA/dJwhs8aY8q67E7wiy92JjKcNMmZNuTaa+Gxx5zpR0ypZ3dwG2NKRqVKcOedTif4fffBhx9aJ3gZYsnCGFOyatWCp55y7gQfPjynE/yNN6wTvBSr8MkiNCgUgEbVG/k5EmMqmOxO8B9/dFoYt9ziTGY4d651gpdCFT5ZVAupBkCbsDZ+jsSYCurcc2HJEvj3v+HECRgyBPr3t07wUqbCJwtjTCkg4tyXsXYtvPiiM2VI585w/fXOgk3G7yxZGGNKj0qV4K674LffnE7wDz6AiAhnanTrBPcrSxbGmNInuxP8119h2DBniG1EBEydap3gfmLJwhhTerVs6Qyx/fFHZ8TUzTdDx47w5ZfWCV7CLFkYY0q/c8+F776DTz911gy/+GIYMMCZ5daUCEsWxpiyQcRZoW/tWnjhBfj5Z+jUCW64wTrBS4AlC2NM2VKpEvzlL86d4Pfe66zaFxEBDz0EaWn+jq7csmRhjCmbateGp5+G9eshPh4efdTp13jzTesE9wFLFsaYsu2cc2DWLPjhB2jVCsaPt05wH7BkYYwpH847D5YuhU8+gWPHnE7wgQOtE7yYWLIwxpQfIjByJKxbB88/D4mJOZ3gO/Iu1GmKwpJFcLAzBK9p08LrGmPKhkqV4O67nTvB77kH3n/f6QR/+GHrBD9Dlixq1YJ585wOMmNM+VK7Njz7rHMn+CWXwOTJTtJ46y3IzPR3dGWKT5OFiAwSkQ0isllEJhawvZmILBKRX0RklYhc7LEtRkR+EJG1IrJaREJ9Gasxphw75xz46CP4/nvnrvBx45xO8K++8ndkZYbPkoWIBOKspT0YiARGi0hknmoP4KzN3QkYBfzLtW8Q8D5wi6p2AHoBJ30VqzGmgujeHf73P5g9G9LTYfBgpxN81Sp/R1bq+bJl0Q3YrKpbVPUEMAsYlqeOAjVcz2sC2T1QA4BVqpoEoKp7VdXajMaYsycCl13mdII/9xwsX+60Mm680TrBT8OXyaIJ8KfH62RXmadHgKtFJBmYC9zpKm8DqIjME5GfReRvPozTGFMRhYQ4nd+bNzv/vvee05/xyCPWCV4AXyYLKaAs7x0yo4HpqhoOXAy8JyIBQBBwITDG9e+lItI33xuIjBeRRBFJTElJKd7ojTEVQ506Tif4+vXOKn2TJjnLvL79tnWCe/BlskgGPMejhpNzmSnbjcDHAKr6AxAK1HXt+62qpqpqOk6ro3PeN1DVqaoap6px9erV88FHMMZUGK1awccfO30aLVrATTc5l6fmzfN3ZKd38qTz8DFfJovlQISItBSRSjgd2Al56mwD+gKISHucZJECzANiRKSKq7O7J7DOh7EaY4zj/POdhPHxx3DkCAwa5DxWr/Z3ZAUbOhR69PD52/gsWahqBnAHzhf/epxRT2tFZLKIZN/UcC8wTkSSgA+BserYDzyHk3BWAj+r6he+itUYY3IRgcsvdy5NPfccLFvmtDJuuqnCdoKLlpOJtuLi4jQxMdHfYRhjyqN9+5ylXV95xZn14W9/c9YIr1rV35E5rZ4DB5zVBM+AiKxQ1bjC6tkd3MYYU5g6dZwWxvr1zgSFjzzijJyqQJ3gliyMMcZbrVo5N/T973/QvLlzWapTJ5g/39+R+ZwlC2OMKarzz3emDvnoI+eejIEDnctBa9b4OzKfsWRhjDFnQgSuuMK5NPXss/DTTxAb68w7tXOnv6MrdpYsjDHmbISEwF//6twJftddMGOG058xaZIz9LacsGRhjDHFISzMWXBp3TrnklR2J/i0aeWiE9yShTHGFKfWrZ2lXZcuhWbNnAkKO3eGBQv8HdlZsWRhjDG+cMEF8MMPMGsWHDrkrMg5eHCZ7QS3ZGGMMb4iAlde6azU98wzzo1zsbEwfjzs2uXv6IrEkoUxxvhaSAjce6/TCX7nnfDOO87lqsmTy0wnuCULY4wpKWFh8MILOZ3gDz/sTIf+zjulvhPckoUxxpS0iAinE/y77yA8HG64Abp0gYUL/R3ZKVmyMMYYf7nwQqcfY9YsOHgQ+vd35p5au9bfkeVjycIYY/wpuxN8/Xp4+mlnGpGYGLj55lLVCW7JwhhjSoPQUGfa899+gzvucG7ma90aHn0U0tP9HZ0lC2OMKVXCwuDFF51O8IED4aGHnD6O6dP92gluycIYY0qjiAj49FNYsgSaNIHrr/drJ7hPk4WIDBKRDSKyWUQmFrC9mYgsEpFfRGSViFxcwPY0EbnPl3EaY0yp1aOH0wn+4YfOinj9+8OQISXeCe6zZCEigcCrwGAgEhgtIpF5qj2AszZ3J2AU8K88258HvvRVjMYYUyYEBMCoUc6d4E895Sy+lN0Jvm9fyYTgw2N3Azar6hZVPQHMAoblqaNADdfzmoB7JXQRGQ5sAUrfGDJjjPGH0FCYMMG5E/z2251O8OXLS+StfZksmgB/erxOdpV5egS4WkSSgbnAnQAiUhX4OzDJh/EZY0zZVLcuvPSScylq9GiIj/f5Wwb58NhSQJnmeT0amK6qz4pId+A9EYnCSRLPq2qaSEGHcb2ByHhgPECzZs2KJ2pjjCkr2rSBDz4okbfyZbJIBpp6vA7H4zKTy43AIABV/UFEQoG6wLnAZSLyFFALyBKRY6r6iufOqjoVmAoQFxeXNxEZY4wpJr5MFsuBCBFpCWzH6cC+Kk+dbUBfYLqItAdCgRRV7ZFdQUQeAdLyJgpjjDElx2d9FqqaAdwBzAPW44x6Wisik0Uk+wLbvcA4EUkCPgTGqqq1EIwxppSR8vLdHBcXp4mJif4OwxhjyhQRWaGqcYXVszu4jTHGFMqShTHGmEJZsjDGGFMoSxbGGGMKVW46uEXkILCpgE01gYNelNUFUn0QWmEKiqWkjuPtPoXVO9X2opSXpnMC/jsvvj4np9tW2s9Laf9dOZs6/jwnzVW1XqG1VLVcPICp3pafoiyxNMVdEsfxdp/C6hXlZ18Wzok/z4uvz0lZPi+l/XflbOqUhXNSni5D/acI5aeq6w/FFcuZHMfbfQqrV5Sf/anKS9M5Af+dF1+fk9NtK+3npbT/rpxNnVJ/TsrNZaizJSKJ6sVYY1Ny7JyUTnZeSp+SOCflqWVxtqb6OwCTj52T0snOS+nj83NiLQtjjDGFspaFMcaYQlmyMMYYUyhLFsYYYwplyaIQIjJcRN4UkTkiMsDf8RiHiJwjIm+LyCf+jqUiE5GqIjLD9Tsyxt/xGIcvfj/KdbIQkWkiskdE1uQpHyQiG0Rks4hMPN0xVPVzVR0HjAWu9GG4FUYxnZctqnqjbyOtmIp4fkYAn7h+R3y/EHQFVpTz4ovfj3KdLIDpuJZtzSYigcCrwGAgEhgtIpEiEi0i/83zqO+x6wOu/czZm07xnRdT/Kbj5fnBWS75T1e1zBKMsSKajvfnpdj5cllVv1PVJSLSIk9xN2Czqm4BEJFZwDBVfRK4JO8xRESAKcCXqvqzbyOuGIrjvBjfKcr5AZJxEsZKyv8fn35VxPOyrrjfvyKe3Cbk/CUEzn/2JqepfyfQD7hMRG7xZWAVXJHOi4iEicjrQCcR+YevgzOnPD//BkaKyGuUrqlBKooCz4svfj/KdcviFKSAslPemaiqLwEv+S4c41LU87IXsORdcgo8P6p6BLi+pIMxbqc6L8X++1ERWxbJQFOP1+HADj/FYnLYeSnd7PyUTiV2XipislgORIhISxGpBIwCEvwck7HzUtrZ+SmdSuy8lOtkISIfAj8AbUUkWURuVNUM4A5gHrAe+FhV1/ozzorGzkvpZuendPL3ebGJBI0xxhSqXLcsjDHGFA9LFsYYYwplycIYY0yhLFkYY4wplCULY4wxhbJkYYwxplCWLIzJQ0QaisgsEflNRNaJyFwRaeOxvZeI/JBnnyAR2S0ijU5z3EdE5D5fxm6Mr1iyMMaDa5bhz4DFqtpKVSOBfwINPKotAcLzzADaD1ijqjtLKlZjSpIlC2Ny6w2cVNXXswtUdaWqfufxOguYTe7FsEYBHwKIyDgRWS4iSSLyqYhUyfsmIrJYROJcz+uKyFbX80ARedq1/yoRudlV3khElojIShFZIyI9iv+jG3NqliyMyS0KWOFFvQ9xEgQiEgJcDHzq2vZvVe2qqrE4UzAUZcWyG4GDqtoV6AqME5GWwFXAPFXtCMTirB9hTImpiFOUG3PWVHW5iFQTkbZAe+BHVd3v2hwlIo8BtYBqOPP2eGsAECMil7le1wQicCaMmyYiwcDnqmrJwpQoSxbG5LYWuCxvoYg8DgwBcP11DzALp3XRHtclKJfpwHBVTRKRsUCvAt4ng5yWfajnWwF3qmq+BCMiF7lieE9EnlbVd73+VMacJbsMZUxu3wAhIjIuu0BEugLzVbWjR6IAJ0FcDfQh97TQ1YGdrlbAmFO8z1agi+u5Z3KaB9zq2hcRaSMiVUWkObBHVd8E3gY6n+kHNOZMWMvCGA+qqiJyKfCCiEwEjuF8sd9dQN11IpIOrHCtGJftQeAn4A9gNU7yyOsZ4GMRuQYnQWV7C2gB/OwamZUCDMdpnUwQkZNAGnDtWXxMY4rMpig3xhhTKLsMZYwxplCWLIwxxhTKkoUxxphCWbIwxhhTKEsWxhhjCmXJwhhjTKEsWRhjjCmUJQtjjDGF+n/gJvOp9L1YOQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2af7054cc88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Confusion Matrix for Train Data :-\n",
      "[[ 5798  1864]\n",
      " [  563 47775]]\n",
      "\n",
      "TPR: 96.24488809202441 %\n",
      "TNR: 91.14919037887125 %\n",
      "FPR: 8.850809621128754 %\n",
      "FNR: 3.7551119079755835 %\n",
      "\n",
      "\n",
      "Precision_Score of the Optimal LR classifier with parameters-{'C': 0.1, 'penalty': 'l2', 'solver': 'liblinear'} is 90.02385326709651 %\n",
      "\n",
      "Confusion Matrix for Test Data :-\n",
      "[[ 2965  1134]\n",
      " [  500 19401]]\n",
      "\n",
      "TPR: 94.47772096420745 %\n",
      "TNR: 85.56998556998558 %\n",
      "FPR: 14.43001443001443 %\n",
      "FNR: 5.5222790357925495 %\n",
      "\n",
      "\n",
      "Classification Report :-\n",
      "\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.86      0.72      0.78      4099\n",
      "          1       0.94      0.97      0.96     19901\n",
      "\n",
      "avg / total       0.93      0.93      0.93     24000\n",
      "\n",
      "Wall time: 3min 30s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2af6f0234e0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "info = run_LR(data_train, bow_counts_train.toarray(), data_test, bow_counts_test.toarray())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+------------------------+-----------+------------------------+\n",
      "| Coeff_Neg | Best Negative Features | Coeff_Pos | Best Positive Features |\n",
      "+-----------+------------------------+-----------+------------------------+\n",
      "|   -3.634  | HelpfulnessDenominator |   3.429   |  HelpfulnessNumerator  |\n",
      "|   -1.754  |         worst          |   1.578   |         delici         |\n",
      "|   -1.486  |       disappoint       |   1.489   |         excel          |\n",
      "|   -1.426  |        horribl         |    1.3    |          best          |\n",
      "|   -1.367  |        unfortun        |    1.28   |        perfect         |\n",
      "|   -1.358  |           aw           |   1.201   |         awesom         |\n",
      "|   -1.296  |        terribl         |   1.157   |         great          |\n",
      "|   -1.077  |          poor          |   1.155   |         addict         |\n",
      "|   -1.017  |        disgust         |   1.119   |          amaz          |\n",
      "|   -0.986  |         bland          |   1.115   |         yummi          |\n",
      "|   -0.971  |         threw          |   1.065   |        fantast         |\n",
      "|   -0.963  |       tasteless        |   0.955   |          hook          |\n",
      "|   -0.945  |          wors          |   0.916   |          nice          |\n",
      "|   -0.944  |          weak          |   0.866   |         wonder         |\n",
      "|   -0.918  |          lack          |   0.829   |         tasti          |\n",
      "|   -0.912  |         sorri          |   0.807   |          easi          |\n",
      "|   -0.859  |       dissapoint       |   0.793   |        satisfi         |\n",
      "|   -0.849  |         earth          |   0.792   |          love          |\n",
      "|   -0.846  |          wast          |   0.735   |        pleasant        |\n",
      "|   -0.833  |         broke          |   0.735   |         smooth         |\n",
      "+-----------+------------------------+-----------+------------------------+\n",
      "Wall time: 47.7 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "n = 20; coeffs = info[-1]; coef_pt = PrettyTable();\n",
    "coef_pt.field_names = [\"Coeff_Neg\", \"Best Negative Features\", \"Coeff_Pos\", \"Best Positive Features\"]\n",
    "feature_names = ['HelpfulnessNumerator', 'HelpfulnessDenominator', 'Time', 'TextLength'] \\\n",
    "                + 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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "| Model |                 Optimal Parameters                 |  Scoring Metric | Score |  TPR  |  TNR  |  FPR  | FNR  |\n",
      "+-------+----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "|  BOW  | {'C': 0.1, 'penalty': 'l2', 'solver': 'liblinear'} | precision_macro | 90.02 | 94.48 | 85.57 | 14.43 | 5.52 |\n",
      "+-------+----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "Wall time: 1 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pt.add_row(['BOW'] + info[:-2])\n",
    "print(pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "del cv_model, bow_counts_train, bow_counts_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TFIDF Vectorizer based model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56000, 9397) (24000, 9397)\n",
      "Wall time: 5.53 s\n"
     ]
    }
   ],
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56000, 4) (56000, 9397)\n",
      "X_Train: (56000, 9401)\n",
      "y_Train: (56000,)\n",
      "X_Test: (24000, 9401)\n",
      "y_Test: (24000,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2af6f249940>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Confusion Matrix for Train Data :-\n",
      "[[ 5406  2256]\n",
      " [  530 47808]]\n",
      "\n",
      "TPR: 95.49376797698945 %\n",
      "TNR: 91.07142857142857 %\n",
      "FPR: 8.928571428571429 %\n",
      "FNR: 4.506232023010546 %\n",
      "\n",
      "\n",
      "Precision_Score of the Optimal LR classifier with parameters-{'C': 1.0, 'penalty': 'l2', 'solver': 'liblinear'} is 91.3064773861137 %\n",
      "\n",
      "Confusion Matrix for Test Data :-\n",
      "[[ 2812  1287]\n",
      " [  355 19546]]\n",
      "\n",
      "TPR: 93.82230115681851 %\n",
      "TNR: 88.7906536154089 %\n",
      "FPR: 11.209346384591095 %\n",
      "FNR: 6.177698843181491 %\n",
      "\n",
      "\n",
      "Classification Report :-\n",
      "\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.89      0.69      0.77      4099\n",
      "          1       0.94      0.98      0.96     19901\n",
      "\n",
      "avg / total       0.93      0.93      0.93     24000\n",
      "\n",
      "Wall time: 2min 35s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2af70c4fef0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "info = run_LR(data_train, tfidf_train.toarray(), data_test, tfidf_test.toarray())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+------------------------+-----------+------------------------+\n",
      "| Coeff_Neg | Best Negative Features | Coeff_Pos | Best Positive Features |\n",
      "+-----------+------------------------+-----------+------------------------+\n",
      "|   -8.065  |       disappoint       |   10.967  |         great          |\n",
      "|   -7.66   |          not           |   9.368   |          best          |\n",
      "|   -6.69   |         worst          |   8.244   |         delici         |\n",
      "|   -5.763  |        horribl         |   7.712   |          love          |\n",
      "|   -5.404  |        terribl         |   6.997   |         excel          |\n",
      "|   -5.288  |           aw           |   6.493   |        perfect         |\n",
      "|   -5.281  |        unfortun        |   6.486   |          good          |\n",
      "|   -4.28   |          wast          |   5.306   |          nice          |\n",
      "|   -4.245  |          weak          |   4.751   |        favorit         |\n",
      "|   -4.221  |          poor          |   4.722   |         wonder         |\n",
      "|   -4.214  | HelpfulnessDenominator |   4.626   |          amaz          |\n",
      "|   -4.073  |         stale          |   4.425   |         awesom         |\n",
      "|   -3.935  |        disgust         |   4.347   |         tasti          |\n",
      "|   -3.873  |         bland          |   4.224   |         addict         |\n",
      "|   -3.733  |         money          |   4.183   |         yummi          |\n",
      "|   -3.683  |          mayb          |   4.068   |  HelpfulnessNumerator  |\n",
      "|   -3.666  |          wors          |   3.765   |        fantast         |\n",
      "|   -3.641  |          bad           |   3.598   |          easi          |\n",
      "|    -3.6   |         threw          |   3.571   |          find          |\n",
      "|   -3.598  |        thought         |   3.555   |         thank          |\n",
      "+-----------+------------------------+-----------+------------------------+\n",
      "Wall time: 44.9 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "n = 20; coeffs = info[-1]; coef_pt = PrettyTable();\n",
    "coef_pt.field_names = [\"Coeff_Neg\", \"Best Negative Features\", \"Coeff_Pos\", \"Best Positive 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": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-------+----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "| Model |                 Optimal Parameters                 |  Scoring Metric | Score |  TPR  |  TNR  |  FPR  | FNR  |\n",
      "+-------+----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "|  BOW  | {'C': 0.1, 'penalty': 'l2', 'solver': 'liblinear'} | precision_macro | 90.02 | 94.48 | 85.57 | 14.43 | 5.52 |\n",
      "| TFIDF | {'C': 1.0, 'penalty': 'l2', 'solver': 'liblinear'} | precision_macro | 91.31 | 93.82 | 88.79 | 11.21 | 6.18 |\n",
      "+-------+----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "Wall time: 999 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pt.add_row(['TFIDF'] + info[:-2])\n",
    "print(pt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "del tfidf_model, tfidf_train, tfidf_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Avg. W2V Vectorizer based model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2.05 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sent_vectors_train = pd.read_csv('./Matrices/avg_w2v_train.csv')\n",
    "sent_vectors_test = pd.read_csv('./Matrices/avg_w2v_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56000, 4) (56000, 50)\n",
      "X_Train: (56000, 54)\n",
      "y_Train: (56000,)\n",
      "X_Test: (24000, 54)\n",
      "y_Test: (24000,)\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEOCAYAAACjJpHCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzt3XlYVdX+x/H3F0RAxXlCySGnREAkNC1zyDHvNU3rOqBlpVZmw80Gu+qvuWjSrEyzq2mGmWZm96ZppjZcK8VEcUhR00TNeQBxAtbvj304HgbhwOFwjvJ9PQ+P7H323mdttpwPa6291xJjDEoppVRR+Xi6AEoppa5sGiRKKaVcokGilFLKJRokSimlXKJBopRSyiUaJEoppVyiQaKUUsolGiRKKaVcokGilFLKJRokSimlXFLG0wUoCdWrVzcNGjTwdDGUUuqKsn79+qPGmBoFbVcqgqRBgwbEx8d7uhhKKXVFEZG9zmynTVtKKaVcokGilFLKJRokSimlXFIq+kjUlenixYskJydz7tw5TxdFqataQEAAISEh+Pn5FWl/DRLltZKTkwkKCqJBgwaIiKeLo9RVyRjDsWPHSE5OpmHDhkU6hjZtKa917tw5qlWrpiGilBuJCNWqVXOp5q9Bko9Vf6xi3f51ni5GqaYhopT7ufp7pkGSj9FLR/P6mtc9XQzlIceOHSMyMpLIyEhq165N3bp17csXLlxw6hj33HMP27dvz3ebKVOmEBcXVxxFZvHixURGRtKyZUtCQ0P597//XSzHVSo/2kei1GVUq1aNhIQEAJ577jkqVKjAE088kW0bYwzGGHx88v6b7KOPPirwfR566CHXCwucP3+eBx98kPj4eOrUqcP58+fZu9ep58kuq6DzUwq0RqJUoe3cuZOwsDAeeOABoqKiOHjwICNHjiQ6OpoWLVrwwgsv2Ldt3749CQkJpKenU7lyZcaOHUvLli1p164dhw8fBmD8+PG8/fbb9u3Hjh1LmzZtaNasGWvWrAHgzJkz9O/fn5YtWzJo0CCio6PtIZfl1KlTGGOoWrUqAP7+/jRt2hSAv/76iz59+hAREUHLli359ddfAXj99dcJCwsjLCyMd99997Lnt3TpUtq1a0dUVBQDBgzgzJkzADz55JOEhoYSERHB008/7a4fufJyWiNRV4THvnmMhL8SCt6wECJrR/J2z7eLtO/WrVv56KOPmDZtGgCxsbFUrVqV9PR0OnfuzB133EFoaGi2fU6dOkXHjh2JjY3l8ccfZ+bMmYwdOzbXsY0xrF27lq+++ooXXniBb775hnfffZfatWuzcOFCNm7cSFRUVK79atasSY8ePahfvz5dunShd+/eDBgwAB8fHx566CG6devG6NGjSU9PJy0tjbVr1xIXF8fatWvJyMigTZs2dOzYkXLlymU7v8OHDxMbG8t3331HuXLlePnll5k8eTL33XcfS5YsYcuWLYgIJ0+eLNLPUl35tEaiVBE0atSI1q1b25c//fRToqKiiIqKYtu2bWzdujXXPoGBgdx6660AXH/99ezZsyfPY/fr1y/XNj/99BMDBw4EoGXLlrRo0SLPfWfNmsW3335LdHQ0sbGxjBw5EoDVq1dz//33A1CmTBkqVqzIjz/+SP/+/SlXrhxBQUH07duXn376Kdf5rVmzhq1bt3LjjTcSGRlJXFwce/bsoWrVqvj4+DBixAgWLVpE+fLlC/MjVFcRrZGoK0JRaw7u4vihmZSUxOTJk1m7di2VK1dmyJAhed5KWbZsWfv3vr6+pKen53lsf3//XNsYY5wuW0REBBEREQwePJjmzZvbO9xz3pmT3zEdz88YQ8+ePZkzZ06u7eLj4/n222+ZN28eU6dOZfny5U6XU109tEailItOnz5NUFAQFStW5ODBgyxbtqzY36N9+/bMnz8fgMTExDxrPKdPn+aHH36wLyckJFC/fn0AOnfubG+Gy8jI4PTp03To0IFFixZx9uxZUlNTWbx4MTfffHOu49544418//337N69G7D6a5KSkkhJSeH06dP8/e9/Z9KkSWzYsKHYz1tdGbRGopSLoqKiCA0NJSwsjGuvvZabbrqp2N/j4Ycf5q677iIiIoKoqCjCwsKoVKlStm2MMbz66quMGDGCwMBAKlSowMyZMwF47733GDFiBB988AFlypThgw8+oE2bNgwaNMjehPXggw8SHh7Ozp07sx23Vq1azJgxgwEDBthve37llVcIDAykX79+nD9/nszMTCZOnFjs562uDFKYKvOVKjo62hRlPpIW77cgtEYoC+5c4IZSqYJs27aN5s2be7oYXiE9PZ309HQCAgJISkqie/fuJCUlUaaM/i2oikdev28ist4YE13Qvvq/UKkrQGpqKl26dCE9PR1jjL1moZQ30P+JSl0BKleuzPr16z1dDKXypJ3tSimlXKJBopRSyiUaJEoppVyiQaKUUsolbg0SEekpIttFZKeI5BpUSETqicgqEdkgIptEpJdtfYyIJDh8ZYpIpO21siIyXUR2iMjvItLfneegSq/iGEYeYObMmfz11195vva///2PG264gcjISJo3b86LL75YXMVXqsS47a4tEfEFpgDdgGRgnYh8ZYxxfCR3PDDfGDNVREKBJUADY0wcEGc7Tjiw2BiTNWLfOOCwMaapiPgAVd11Dqp0c2YYeWfMnDmTqKgoateuneu1u+++my+//JKwsDAyMjIKnLvEGRkZGfj6+rp8HKWc5c4aSRtgpzFmtzHmAjAP6JNjGwNUtH1fCTiQx3EGAZ86LN8LvApgjMk0xhwt1lIr5YTZs2fTpk0bIiMjGTVqFJmZmaSnpzN06FDCw8MJCwvjnXfe4bPPPiMhIYEBAwbkWZM5cuSIPWB8fX3tIwanpKRw9913Ex4eTkREBF9++SUAn3zyif34//rXvwDsQ9SPHz+eNm3asHbtWtatW0fHjh25/vrrufXWWzl06BAAkyZNIjQ0lJYtWzJkyJCS+nGpq5w7nyOpC+xzWE4GbsixzXPAchF5GCgPdM3jOAOwBZCIVLate1FEOgG7gNHGmEPFV2zllR57DBKKdxh5IiPh7cIPBrl582YWLVrEmjVrKFOmDCNHjmTevHk0atSIo0ePkpiYCMDJkyepXLky7777Lu+99x6RkZG5jvXYY4/RpEkTOnfuzK233spdd92Fv78/zz33HDVq1CAxMRFjDCdPniQ5OZnx48cTHx9PpUqV6Nq1K//973/p2bMnp06dIioqipdeeonz58/TuXNnvvrqK6pXr05cXBwTJkxg+vTpvP766+zdu5eyZcvqsO+q2LizRpLXJMA5x2MZBMwyxoQAvYA5tuYq6wAiNwBpxpjNtlVlgBDgf8aYKOBn4M0831xkpIjEi0j8kSNHXDwVpS5ZsWIF69atIzo6msjISL7//nt27dpF48aN2b59O48++ijLli3LNRZWXp5//nnWrVtH165d+fjjj/nb3/5mf4+smRNFhCpVqvDrr79yyy23UL16dfz8/Bg8eLB9kMayZcty++23A9ZQF1u2bKFr165ERkYSGxvLvn3W33QtWrRgyJAhxMXF4efn544fjyqF3FkjSQaucVgOIXfT1X1ATwBjzM8iEgBUBw7bXh9I9matY0AasMi2vMB2jFyMMdOB6WCNtVXks1DeoQg1B3cxxnDvvffm2TG+adMmli5dyjvvvMPChQuZPn16gcdr3LgxjRs3ZsSIEVSrVs0+02Fhhn0PDAy0b2+MISIigh9//DHXdsuWLeP7779n8eLFvPTSS2zevFn7U5TL3FkjWQc0EZGGIlIWKxS+yrHNn0AXABFpDgQAR2zLPsCdWH0rABjrN+k/QCfbqi5A7vG0lXKjrl27Mn/+fI4etbrnjh07xp9//smRI0cwxnDnnXfy/PPP89tvvwEQFBRESkpKnsf6+uuv7QGxY8cO/P39CQoKonv37rz33nuAFQwnTpygbdu2rFq1imPHjpGens68efPo2LFjrmOGhoayf/9+1q5dC8CFCxfYsmULGRkZJCcnc8stt/DGG29w5MgR0tLSiv3no0oft9VIjDHpIjIaWAb4AjONMVtE5AUg3hjzFTAG+FBE/onV7DXMXPqzqwOQbIzZnePQT2M1gb2NFTr3uOsclMpLeHg4zz77LF27diUzMxM/Pz+mTZuGr68v9913n7028dprrwFwzz33MHz4cAIDA1m7dm22Ca5mzZrFP//5T8qVK4efnx9z587Fx8eHZ599llGjRhEWFoavry8vvvgit912Gy+88AKdOnXCGEPv3r3529/+lmuCLH9/fz7//HMeeeQRUlJSSE9PZ8yYMTRu3JjBgweTkpJCZmYmTz/9NEFBQSX6s1NXJx1GPh86jLxn6TDySpUcV4aR1yfblVJKuUSDRCmllEs0SJRSSrlEg0QppZRLNEiUUkq5RINEKaWUSzRIlMpHcnIyffr0oUmTJjRq1IhHH320wCHkT548yfvvv29fPnDgAHfccUexlOe5557jzTezjwq0evVq2rVrl21deno6tWrV4uDBg4U6VlGdPXuWjh07kpGR4dJxjh8/Trdu3WjSpAndunXjxIkTeW43e/ZsmjRpQpMmTZg9e7Z9/bhx47jmmmuoUKGCU++XlpZGTEyMfSDM9u3bk5qa6tI5uGr9+vWEh4fTuHFjHnnkkTxHNDh16hS9e/emZcuWtGjRgo8++giAVatW2ac6iIyMJCAgwD7g58CBA0lKSnJLmTVI1FUjLg4aNAAfH+vfuDjXjmeMoV+/fvTt25ekpCR27NhBamoq48aNy3e/nEFSp04dPv/8c9cKk48OHTqQnJzMnj177OtWrFhBWFgYwcHBbntfRzNnzqRfv34uD7cSGxtLly5dSEpKokuXLsTGxuba5vjx4zz//PP8+uuvrF27lueff94eOL1797Y/0e+MyZMnU6tWLRITE9m8eTMzZsxweQyynA+IFtaDDz7I9OnTSUpKIikpiW+++SbXNlOmTCE0NJSNGzeyevVqxowZw4ULF+jcuTMJCQkkJCSwcuVKypUrR/fu3e3Hff31110q2+VokKirQlwcjBwJe/eCMda/I0e6FiYrV64kICCAe+6xBk/w9fVl0qRJzJw5k7S0NGbNmkWfPn3o2bMnzZo14/nnnwdg7Nix7Nq1i8jISJ588kn27NlDWFgYYD3J3rdvX3r37k3Dhg157733mDhxIq1ataJt27YcP34cgA8//JDWrVvTsmVL+vfvn+9QJj4+Ptx555189tln9nXz5s1j0KBBTh+rU6dOZD20e/ToURo0aABYc5s8+eSTtG7dmoiICD744IM8yxAXF0efPtYsEampqXTp0oWoqCjCw8NZvHix0z/zxYsXc/fddwOX5mrJadmyZXTr1o2qVatSpUoVunXrZv+wbdu2baHC8+DBg9StW9e+3KxZM/z9/QH4+OOPiYiIoGXLlgwdOhSAvXv30qVLFyIiIujSpQt//vknAMOGDePxxx+nc+fOPP3005w5c4Z7772X1q1b06pVK6d/BgcPHuT06dO0a9cOEeGuu+7K82cgIqSkpGCMITU1lapVq1KmTPaBSj7//HNuvfVWypUrB8DNN9/MihUrXA66vGiQqKvCuHGQ8/MxLc1aX1Rbtmzh+uuvz7auYsWK1KtXj507dwKwdu1a4uLiSEhIYMGCBcTHxxMbG0ujRo1ISEjgjTfeyHXczZs3M3fuXNauXcu4ceMoV64cGzZsoF27dnz88ccA9OvXj3Xr1rFx40aaN2/OjBkz8i3roEGDmDfPGpbu/PnzLFmyhP79+xfpWI5mzJhBpUqVWLduHevWrePDDz/kjz/+yLbNhQsX2L17tz18AgICWLRoEb/99hurVq1izJgx9uaZm2++OVvTS9bXihUrADh06JA9CIKDgzl8+DA57d+/n2uuuTQebEhICPv373f6nBzde++9vPbaa7Rr147x48fbm362bNnCyy+/zMqVK9m4cSOTJ08GYPTo0dx1111s2rSJmJgYHnnkEfuxduzYwYoVK3jrrbd4+eWXueWWW1i3bh2rVq3iySef5MyZM2zfvj3P84+MjOTkyZPs37+fkJCQAs9t9OjRbNu2jTp16hAeHs7kyZPx8cn+ce74xwRYf3A0btyYjRs3FulnlR93jv6rVImx/WHo9Hpn5DUCb8713bp1o1q1aoD1gf3TTz/Rt2/ffI/buXNngoKCCAoKolKlSvTu3RuwxvDatGkTYIXN+PHjOXnyJKmpqfTo0SPfY7Zu3ZrU1FS2b9/Otm3baNu2LVWqVCnSsRwtX76cTZs22ZvmTp06RVJSEg0bNrRvc/ToUSpXrmxfNsbwr3/9ix9++AEfHx/279/PoUOHqF27dp4jEhdWXn0GeV0nZ0RGRrJ7926WL1/OihUraN26NT///DMrV67kjjvuoHr16gBUrWpNxPrzzz/zxRdfADB06FCeeuop+7HuvPNOe9Pe8uXL+eqrr+x9UOfOnePPP/+kefPm9lk3XTm3ZcuWERkZycqVK9m1axfdunXj5ptvpmJFa57AgwcPkpiYmOta16xZkwMHDuT6A8lVGiTqqlCvntWcldf6omrRogULFy7Mtu706dPs27ePRo0asX79+ly/5M58oGU1nYD1V2LWso+Pj73ZYdiwYXz55Ze0bNmSWbNmsXr16gKPO3DgQObNm8e2bduy/SXqzLHKlClDZmYmYH3oZTHG8O677+YbPoGBgdn2iYuL48iRI6xfvx4/Pz8aNGhgf/3mm2/OcyTkN998k65du9pvEAgODubgwYPUrFkz17YhISHZziE5OZlOnTpdtnwFqVChAv369aNfv374+PiwZMkS/Pz8nLqWjtuUL1/e/r0xhoULF9KsWbNs22/fvp0BAwbkeazVq1cTEhJCcnKyfV1ycjJ16tTJte1HH33E2LFjEREaN25Mw4YN+f3332nTpg0A8+fP5/bbb8/V33Pu3DkCAwMLPK/C0qYtdVV4+WWwNQXblStnrS+qLl26kJaWZm9uysjIYMyYMQwbNsze7vztt99y/Phxzp49y5dffslNN92U77DxzkpJSSE4OJiLFy8S52RHz6BBg/jkk09YuXIlt912W6GO1aBBA9avXw+Q7caAHj16MHXqVC5evAhYzTdnzpzJtm+VKlXIyMiwh8WpU6eoWbMmfn5+rFq1ir0OCf/jjz/aO4Mdv7p2tSZHve222+x3Yc2ePdve7+KoR48eLF++nBMnTnDixAmWL19eYC1r0aJFPPPMM7nW/+9//7N31F+4cIGtW7dSv359unTpwvz58zl27BiAve/qxhtvtDchxsXF0b59+zzfr0ePHrz77rv2GsaGDRsAqw8mr/NPSEigcuXKBAcHExQUxC+//IIxho8//jjPn0G9evX47rvvAKs5cPv27Vx77bX21z/99NNsf0xk2bFjBy1atMj3Z1UUGiTqqhATA9OnQ/36IGL9O326tb6oRIRFixaxYMECmjRpQtOmTQkICOCVV16xb9O+fXuGDh1KZGQk/fv3Jzo6mmrVqnHTTTcRFhbGk08+WaT3fvHFF7nhhhvo1q0b1113nVP7hIaGUq5cOW655ZZsfx07c6wnnniCqVOncuONN9rnWQEYPnw4oaGhREVFERYWxv33359nZ2337t356aefAIiJiSE+Pp7o6Gji4uKcLj9YNyp8++23NGnShG+//ZaxY8cCEB8fz/DhwwGrmWnChAm0bt2a1q1b83//93/2pqennnqKkJAQ0tLSCAkJ4bnnngNg165d9mYfR7t27aJjx46Eh4fTqlUroqOj6d+/Py1atGDcuHF07NiRli1b8vjjjwPwzjvv8NFHHxEREcGcOXPsfSc5TZgwgYsXLxIREUFYWBgTJkxw+mcwdepUhg8fTuPGjWnUqBG33norANOmTWPatGn2469Zs4bw8HC6dOnCa6+9Zm+G27NnD/v27cs1V82hQ4cIDAx0y518Oox8PnQYec/y9mHkZ82aRXx8vH0CqtJsw4YNTJw4kTlz5ni6KHkaMmQIkyZNokaNGp4uisdMmjSJihUrct99eU4q69Iw8tpHopRyWatWrejcuTMZGRleOXXvJ5984ukieFzlypXttzEXNw0SpYpo2LBhDBs2zNPF8Br33nuvp4ug8pH1PJQ7aB+JUkopl2iQKK9WGvrwlPI0V3/PNEiU1woICODYsWMaJkq5kTGGY8eOERAQUORjaB+J8lpZD2cdOXLE00VR6qoWEBCQbWiWwtIgUV7Lz88v21AcSinvpE1bSimlXKJBopRSyiUaJEoppVyiQaKUUsolGiSXERcHO8Yv5/MBnxXLtK1KKXW10ru28pA1bWt6mjUFZ9a0reDaaLJKKXU10hpJHtwxbatSSl2tNEjy4I5pW5VS6mqlQZKHy03P6sq0rUopdbVya5CISE8R2S4iO0VkbB6v1xORVSKyQUQ2iUgv2/oYEUlw+MoUkcgc+34lIpvdUW53TNuqlFJXK7cFiYj4AlOAW4FQYJCIhObYbDww3xjTChgIvA9gjIkzxkQaYyKBocAeY0yCw7H7AanuKnvWtK11fPYiZBbLtK1KKXW1cmeNpA2w0xiz2xhzAZgH5JzF3gBZEylXAg7kcZxBwKdZCyJSAXgceKnYS+wgJga+r9mM/7Wtx549GiJKKXU57rz9ty6wz2E5GbghxzbPActF5GGgPNA1j+MMIHsAvQi8BaTlsa1SSqkS5s4aieSxLufEEoOAWcaYEKAXMEdE7GUSkRuANGPMZttyJNDYGLOowDcXGSki8SISr8OQK6WU+7gzSJKBaxyWQ8jddHUfMB/AGPMzEABUd3h9IA7NWkA74HoR2QP8BDQVkdV5vbkxZroxJtoYE12jRg0XTkMppVR+3Bkk64AmItJQRMpihcJXObb5E+gCICLNsYLkiG3ZB7gTq28FAGPMVGNMHWNMA6A9sMMY08mN56CUUqoAbgsSY0w6MBpYBmzDujtri4i8ICK32TYbA4wQkY1YNY9h5tK8qh2AZGPMbneVUSmllOvcOtaWMWYJsCTHuv9z+H4rcNNl9l0NtM3n2HuAsOIop1JKqaLTJ9uVUkq5RINEKaWUSzRIlFJKuUSDRCmllEs0SJRSSrlEg0QppZRLNEiUUkq5RINEKaWUSzRIlFJKuUSDpABnL57jyBkdPVgppS5HgyQfAX4BHDt7jOC3gukV14u5iXM5c+GMp4ullFJeRYMkHyFBdel+bTeeuPEJNh/eTMwXMdR6sxZDvhjC0qSlpGeme7qISinlcRokBagUUInYrrHseWwPq+9ezeDwwXyd9DW95vaizlt1eGTpI/ya/CuXBi1WSqnSRUrDB2B0dLSJj48v/I4tWkBoKCxYkG31+fTzLN25lLjEOP6z/T+czzhP46qNGRw2mJiIGJpWa1pMJVdKKc8RkfXGmOiCttMaSRH4l/Gn73V9WXDnAg49cYgZt82gXqV6vPjDizR7rxltPmzD5F8mcyj1kKeLqpRSbqdB4qJKAZW4t9W9fHfXd+z75z7e7PYmFzMv8tiyx6gzsQ49P+nJnI1zSDmf4umiKqWUW2jTVn4u07TljK1HthK3KY65m+ey5+QeAssE0ue6PsSEx9CjUQ/8fP0KXx6llCpBzjZtaZDkx4UgyWKMYc2+NXyy6RPmb53P8bPHqV6uOv8I/QcxETG0C2mHiBT5+Eop5S4aJA48GSSOLmRcYNnOZcQlxrF4+2LOpZ+jYeWGDA4fTEx4DM1rNC+W91FKqeKgne1eqKxvWXo36828O+Zx6IlDzOozi8ZVG/PqT68S+n4o10+/nok/T+RAygFPF1UppZymQeIhFf0rcnfk3SwfupzkfyYzqcckBGHM8jFcM+kaus3pxqyEWZw+f9rTRVVKqXw5FSQicqeIBNm+Hy8iX4hIlHuLVnoEBwXzWNvHiB8Zz+8P/c64m8ex+8Ru7ll8D7XerMU/FvyDxb8v5kLGBU8XVSmlcnG2RjLBGJMiIu2BHsBsYKr7ilV6NavejBc6v8DOh3ey5t413NfqPlbtWUXfz/oS/FYwD/z3AX7c+yOZJtPTRVVKKcD5IMmw/fs3YKoxZjFQ1j1FUgAiQrtr2vFer/c48PgBvh78NT0b92TOpjl0mNWBhpMb8syKZ9hyeIuni6qUKuWcDZL9IvIB8A9giYj4F2Jf5SI/Xz96NelFXL84Dj1xiDm3zyG0RihvrHmDsKlhRE6L5I3/vUHy6WRPF1UpVQo5Gwb/AJYBPY0xJ4GqwJNuK5W6rAplKzAkYghLY5ay//H9vNPzHfzL+PPUiqeoN6kenWd3ZsZvMzh57qSni6qUKiWcChJjTBpwGGhvW5UOJLmrUMo5tSrU4uEbHubX4b+yY/QOnu34LPtP72f4f4ZT+83a9J/fny+2fcH59POeLqpS6irm1AOJIvIsEA00M8Y0FZE6wAJjzE3uLmBx8JYHEkuCMYb4A/F8sukT5m2Zx+Ezh6nkX4k7Q+8kJiKGDvU74CPaKqmUKlhxP5B4O3AbcAbAGHMACCp68ZS7iAit67Zm8q2T2f/4fr6J+Ybbmt3Gp5s/pfPsztR/uz5Pf/s0mw5t8nRRlVJXCWeD5IKxqi4GQETKu69IqriU8SlDj8Y9+Pj2jzn0xCHm9ptLy1otmfjLRFpOa0n41HBif4rlz1N/erqoSqkrmLNBMt9211ZlERkBrAA+dF+xVHErX7Y8g8IH8d/B/+XA4weY0msKQWWDeOa7Z6j/dn06zurI9PXTOX72uKeLqpS6wjjb2f4m8DmwEGgG/J8x5t2C9hORniKyXUR2isjYPF6vJyKrRGSDiGwSkV629TEikuDwlSkikSJSTkS+FpHfRWSLiMQW7nQVQI3yNRjVehRr7lvDrkd28WLnFzl85jD3//d+ar9Zm77z+rJgywLOXjzr6aIqpa4ABXa2i4gvsMwY07VQB7b22wF0A5KBdcAgY8xWh22mAxuMMVNFJBRYYoxpkOM44cBiY8y1IlIOuMEYs0pEygLfAa8YY5bmV5bS1NleVMYYNvy1weqk3zyPg6kHqehfkf7N+xMTHkOnBp3w9fH1dDGVUiWo2DrbjTEZQJqIVCpkGdoAO40xu41AV7MwAAAdw0lEQVQxF4B5QJ+chwcq2r6vBOQ17O0g4FNbWdKMMats318AfgNCClkulQcRISo4iok9JrLvn/v4dui39Gvej8+3fk7XOV2p93Y9nlj+BBsObqA0TD2glHKes7f/zgfaAt9iu3MLwBjzSD773IH1AONw2/JQrNrEaIdtgoHlQBWgPNDVGLM+x3F2AX2MMZtzrK+MFSRdjTG783j/kcBIgHr16l2/d+/eAs8zl1JUI7mcsxfP8p8d/yEuMY6lSUu5mHmR5tWbExMew+DwwTSs0tDTRVRKuUlx3/77NTAB+AFY7/CVbxnyWJcztQYBs4wxIUAvYI7IpYccROQGIC2PECmDVUt5J68QATDGTDfGRBtjomvUqFFAUdXlBPoF8o8W/2DxwMUcHHOQaX+bRrVy1Ri/ajzXvnMt7We2Z+q6qRxNO+rpoiqlPMTZzvbZWB/cWQEy17YuP8nANQ7LIeRuuroPmG97j5+BAKC6w+sDbe+b03QgyRjztjPlV8WjWrlq3B99Pz/e8yN/PPoHr9zyCifPnWTUklEEvxVM7097M2/zPNIupnm6qEqpEuTsfCSdsIZEmQK8D+wQkQ4F7LYOaCIiDW0d4wOBr3Js8yfQxfYezbGC5Iht2Qe4E6tvxbEsL2H1pzzmTNmVezSo3IBnbn6GxAcTSbg/gcdueIwNBzcwaOEgar1Zi7u/vJvlu5aTnpnu6aIqpdzM2T6S9cBgY8x223JT4FNjzPUF7NcLeBvwBWYaY14WkReAeGPMV7Y7tT4EKmA1ez1ljFlu27cTEGuMaetwvBBgH/A7kDWA1HvGmH/nVw69a6tkZGRm8MPeH4hLjOPzrZ9z6vwpapWvxaCwQcRExHB98PWI5NXiqZTyRs72kTgbJJuMMREFrfNWGiQl71z6Ob7e8TVxiXF8nfQ1FzIu0LRaU2LCY4gJj6FR1UaeLqJSqgDFHSQzsWoMc2yrYoAyxph7XCplCdEg8awTZ0+wcNtC4hLjWL1nNQBtQ9oSEx7DgBYDqFFeb4ZQyhsVd5D4Aw9hDSMvWHdvvW+MuSLGJ9cg8R77Tu3j082fEpcYx6ZDm/AVX7o36s6QiCH0adaH8mV1GDelvEVxB0l54Jzt4cSsp9b9bfOUeD0NEu+UeCiRuMQ45ibOZd/pfZT3K0/f6/oSEx5Dt0bdKONTxtNFVKpUK+7nSL4DAh2WA7EGblSqyMJrhRPbNZY9j+3h+2HfExMew5KkJfSa24s6b9XhkaWP8Gvyr/okvVJeztkgCTDGpGYt2L4v554iqdLGR3zoUL8DH/T+gINjDrJowCI6NrBGI247oy1N32vKs6ueZcexHZ4uqlIqD84GyRkRicpaEJFoQIeGVcXOv4w/fa/ry4I7F3DoiUPMvG0m9SvV58UfXqTZe81o82EbpsVP01qKUl7E2SB5DFggIj+KyA9YDwmOLmAfpVxSKaAS97S6hxV3rWDfP/fxZrc3SbmQwoNfP8iBlLzG91RKeUK+QSIirUWktjFmHXAd8BmQDnwD/FEC5VMKgLoV6zLmxjE8deNTAPrEvFJepKAayQfABdv37YB/YQ2TcgJrvCullFKlXEH3V/oaY7LmXh0ATDfGLAQWikiCe4umlFLqSlBQjcTXNmQ7WIMrrnR4TW/yV0opVWAYfAp8LyJHse7S+hFARBoDp9xcNqWUUleAfIPENlrvd0AwsNxcuufSB3jY3YXzCtu2wfr1cH2+Ax0rpVSp5cyc7b8YYxYZYxyn2N1hjPnNvUXzAnfdBX/8AdHR0LYtzJkD5855ulRKKeVVnH2OpHR6+mnYvx/efhtOnLCC5Zpr4JlnYM8eT5dOKaW8ggZJQSpXhkcftZq4li+H9u3h9dehUSO47TZYtgwyMz1dSqWU8hgNEmf5+EC3brBokdXcNXYs/PIL9OwJzZrBpElWrUUppUoZDZKiqFcPXn4Z9u2DTz6BGjXg8cehbl0YPhw2bPB0CZVSqsRokLjC3x9iYmDNGvjtN+v7uXMhKgpuvBHi4uD8FTH3l1JKFZkGSXFp1Qo+/NDqnJ84EY4cgSFDrM75cePgzz89XUKllHILDZLiVqUK/POfsH07fPMNtGsHsbHQsCH07Qvffqud80qpq4oGibv4+ECPHrB4MezaBU89Bf/7H3TvDs2bw+TJcPKkp0uplFIu0yApCQ0awKuvWp3zH39s1Voee8zqnL//fti40dMlVEqpItMgKUkBATB0qHXbcHw8DBxoBUtkpPV8yqefwoULBR9HKaW8iAaJp1x/PcyYYXXOv/kmHDwIgwdbtxZPmADJyZ4uoVJKOUWDxNOqVoUxYyApCZYsscb1evllqzmsf3/47jvQ+cmVUl5Mg8Rb+PjArbfCf/9rdc6PGQPffw9du0JoKLz7LpzSkfuVUt5Hg8QbNWwIr71mdc7PmgVBQfDII1bn/IMPQmKip0uolFJ2GiTeLDAQ7r4b1q61vu68Ez76CCIioEMH+Owz7ZxXSnmcBsmVonVrK0T277dGH05Otu76ql8fnn3WWl8K+Pn6ARA1PYpOszrx8JKHmb5+Oj/v+5mU8ykeLp1SpZMYN3bkikhPYDLgC/zbGBOb4/V6wGygsm2bscaYJSISAzzpsGkEEGWMSRCR64FZQCCwBHjUFHAS0dHRJj4+vpjOyktkZFhPzk+ZYv3r4wO33w6jRkGnTiDi6RK6xZlDySS8+iiLIwP5KWM3mw9vJuXCpQBpULkB4TXDCa8ZTljNMMJrhdOsWjN7ACmlnCci640x0QVu564gERFfYAfQDUgG1gGDjDFbHbaZDmwwxkwVkVBgiTGmQY7jhAOLjTHX2pbXAo8Cv2AFyTvGmKX5leWqDBJHu3bBtGnW7cQnTlid86NGWc+sVKzo6dIVr9mzYdgwq9nv0UcxTz7JXp/TJB5KJPGw7etQItuPbSc9Mx0APx8/rqt+HeG1wu0hE14rnGsqXoNcpYGrVHHwhiBpBzxnjOlhW34GwBjzqsM2HwC7jTGv2bZ/yxhzY47jvGLtZsaJSDCwyhhzne21QUAnY8z9+ZXlqg+SLGfPwrx5Vi1l/XqoUMGa1XHUKGjRwtOlKx4ffQT33mvNA7NsGVSqZM0N8/DDUK6cfbPz6efZfmx7roDZd3qffZtK/pWsWostWLJqMVUCq3jizJTyOt4QJHcAPY0xw23LQ4EbjDGjHbYJBpYDVYDyQFdjzPocx9kF9DHGbBaRaCDWGNPV9trNwNPGmL/nV5ZSEyRZjLE656dMudQh37EjPPSQNXCk3xXczJMVJHv2WGOVjRsHX38NwcFWX9G99+Z7fifPnWTL4S32YMkKmZPnLo17Vjeobq7aS/PqzfEv418CJ6iU93A2SMq4swx5rMuZWoOAWcaYt2w1kjkiEmaMyQQQkRuANGPM5kIcE9u+I4GRAPXq1StK+a9cInDDDdbXW2/BzJkwdSr84x9Qpw6MHGl9BQd7uqSuadnSeu7mxx+tWskDD1ijBLz0knWHm0/ue0kqB1Tmpno3cVO9m+zrjDHsT9mfq/ay8o+VXMiw7orzFV+aVmuaK2AaVG6Aj+g9K6p083TT1hasWss+2/JuoK0x5rBteRJwxBjzim1Zm7aKKiPDenJ+yhSrSahMGejXz2r26tDhyumcd6yR1K9/ab0xVqj861+webM1P8yrr1qjLRfx3C5mXCTpeBKJhxLZfHizPWR2n9ht36a8X3la1GyRLVzCa4ZTo3wNF09UKc/zhqatMlid7V2A/Vid7YONMVsctlkKfGaMmSUizYHvgLrGGCMiPsCfQAdjzG6HfdYBDwO/YnW2v2uMWZJfWTRIckhKsmooH31kNQ+FhVmBMmSI9fCjN7tckGTJyLAGv5wwwdqmUycrUNq2LbYipF5IzbN57GjaUfs2tcrXylV7Ca0RSjm/cvkcWSnv4vEgsRWiF/A21q29M40xL4vIC0C8MeYr251aHwIVsJqonjLGLLft2wmrP6RtjmNGc+n236XAw6Xy9t/ikJZmfehOmWLNMx8UZD0AOWqUNWeKNyooSLKcP2/NWPnii3D4sNU39PLL1h1tbmCM4dCZQ9mCZfPhzWw5vIWz6WcBEIRGVRvlqr00rtoYXx9ft5RLKVd4RZB4Cw2SAhhjDW0/ZQosWGB1znfubHXO9+ljNYN5C2eDJEtqKrz9tvUQ55kz1l1szz3n3L7FICMzg90ndueqvew8vpNMqyuQgDIBhNYIzRUwtSvU1tuTlUdpkDjQICmEw4et51GmTbPmmc+afGvECKhd29OlK3yQZDl61Jry+L33rOAcNcrqT6nhmb6MsxfPsvXI1lwB81fqX/ZtqgVWy/P25CB/L29+VFcNDRIHGiRFkJFhdV5PmWLNM+/nZw1r/9BDcNNNnuucL2qQZNm3z6qRzJplPXfyxBPw+ONe0zd0NO1ors79zYc3k3oh1b6N49P7WQHTtFpTfXpfFTsNEgcaJC7asQPef9/68D11yho0ctQoiImxHnosSa4GSZZt22D8ePjiC6he3fr+gQfA3/ueFck0mew9uTdX7WX70e1kmAzAenq/eY3ml4aG0af3VTHQIHGgQVJMzpyBuXOtWsrGjdbwK8OGWaHSrFnJlKG4giTL2rXWMyirVlmzU77wgnX3mq/3d36fTz/P70d/t9danH16P7xWOJUDKnuw5OpKoUHiQIOkmBkDa9ZYgfL553DxInTpYjV79e7t3s754g4SsM5nxQp45hlraJkWLaw7vG677cp5vsbByXMnrWDJ8YDlqfOXJkYLqRiSa3BLV57eP5p2lFPnTlEnqA6BfoHFdSrKwzRIHGiQuNGhQ/Dvf1ud88nJcM01Vuf88OFQq1bxv587giSLMbBwoTXsyo4d1rMnsbHW8DJXOGMMyaeTczWPbTuyjYuZFwHXnt5v8m4Tdh7fCUCVgCrUCapj/6obVPfS9xWt72uVr6V9OlcADRIHGiQlID0d/vMfq5by3XdW5/ydd1q1lHbtiu8ve3cGSZb0dKs/6LnnrHleevaEV16xnpa/yjg+ve9Ye/nj5B/2bcr7lc/WPJb1vePT+9Vfr05YzTC6N+rOgZQDHEg5wP6U/RxIOcDBlIP2vpwsglCzfE17sNSpcClkHAOoWrlqOgSNB2mQONAgKWG//249OT9rFpw+DZGRVj/K4MFQvrxrxy6JIMly9qwVjK+8Yg3PP3Cg9YBj48bufV8vkHI+hS1HtuQKmGNnj9m3cXx6f1r8NO5tdS/v9Xov17EyMjM4mnbUHiwHUg6w/7Tt+9RLy0fSjuTa18/Hj+Cg4Nw1m6DsoVPRv6LeVOAGGiQONEg8JDUV4uKsD+PERGvI93vuseadb9q0aMcsySDJcvIkvPGG9WDjhQtWs92ECdYAmKWIMYa/Uv/Kdmty4qFEthzZwrn0c0zoMIEXOr9Q5ONfyLjAX6l/ZQ8aW9g4Ljv29WQp71e+wOa04ArB2n9TSBokDjRIPMwY+OknK1AWLrSajrp1s5q9/v73wt0h5YkgyXLwoDWy8PTpVtPdo4/C009D5dJ9B1RGZgZ/nvqTkIohJdLvcebCmUsh49CElnP5XPq5XPtWCaiSvQktR5Na3aC61KpQizI+XjSagwdpkDjQIPEiBw9anfMffGD1P9SrZz2/MXy4c0+ZezJIsuzaBf/3f9at0FWqWLcPjx6dbWIt5VnGGE6eO5kraPaf3m9vTsuv/6ZWhVoFNqdVL1f9qm9O0yBxoEHihS5ehK++smopq1ZB2bLWfCkPPWTNo3K5X1BvCJIsCQnWHV5LlljNXM8+azXdXckTh5UyGZkZHEk7krvvJkeTWl79N2V9yxJcITjf5rQ6QXUIKht0xQaOBokDDRIvt3Wr1Tk/ezakpFh3Rz30EAwalPuvfG8Kkiw//GA9g7JmjdURn8/EWurKlNV/ky1octZ2UvZz+vzpXPuW9ytfYHNacFAwAWUCirXM245sI/FwIv2b9y/y6NIaJA40SK4QKSnwySdWLWXLFqvZKKtzPutOKW8MEnDLxFrqypN6IZWDKQfz7bu5XP9N1cCqeTahOS4Xpv8m9qdYnvnuGc6OO1vkkPKGqXaVKpygICs0HnjA+it/yhR45x2YONF6lmPUKGswSW8kYj3V36vXpYm1evZ0y8RayntVKFuBJtWa0KRak8tuk9V/k9/t0JsPb+av1L9y9d/4iA+1ytcqsDmtWmA1d59qNlojUd7twAFrgqoPPrA66gMC4Nw576uR5HT+vHV314svwpEjbp9YS119HPtv8mtSu1z/jb+vPykXUkqkRqJBoq4MFy/Cl19atZRt22DnTq8Z+j1fKSnW8ydvvGENenn33dYT8/Xqebpk6ipxPv28/fmbnCFTLbAaE3tMLHJnvwaJAw0S5XFHj1pNXFOmWP0pDz1kddB7aGItpZzhbJDobSVKlYTq1eGtt6zBIIcMgcmToVEja9j6lBRPl04pl2iQKFWS6tWzpjLevNl6uv/ZZ61Aeecdq19FqSuQBolSntC8uTVczK+/QliYNdxKs2bWszTeemeaUpehQaKUJ7VpYw27v3y51fw1bBi0bGk99V8K+i/V1UGDRClPE7GaudauhfnzrRGG+/SBm26ynqdRystpkCjlLXx8rKFVtmyxnkHZu9eanbFXL2tcL6W8lAaJUt7Gzw9GjLCelXn9dfjlF2vIlcGDrXVKeRkNEqW8VWAgPPkk7N5tjeG1eLHVST9qlPWUv1JeQoNEKW9XubI1vMrOnTBypDVkTKNGVricPOnp0imlQaLUFSM42Hoy/vff4fbbrSflr73Wav5KS/N06VQppkGi1JWmUSOIi4MNG6BdO2u63yZNrA76ixc9XTpVCmmQKHWlioyEr7+G77+HBg3g/vuhRQvrFuLMTE+XTpUiGiRKXek6dICffrIeYvT3hwEDoHVr6yFHfahRlQC3BomI9BSR7SKyU0TG5vF6PRFZJSIbRGSTiPRyeC1CRH4WkS0ikigiAbb1g2zLm0TkGxGp7s5zUOqKkDWxVkICfPwxHD8OPXpAly7WMCxKuZHbgkREfIEpwK1AKDBIRHLO6jMemG+MaQUMBN637VsG+AR4wBjTAugEXLStnwx0NsZEAJuA0e46B6WuOL6+MHSo1SH/zjvW4JBt20K/frB1q6dLp65S7qyRtAF2GmN2G2MuAPOAPjm2MUBF2/eVgAO277sDm4wxGwGMMceMMRmA2L7KizVTS0WHfZRSWfz94eGHYdcua6j6FSsgPNya7/7PPz1dOnWVcWeQ1AX2OSwn29Y5eg4YIiLJwBLgYdv6poARkWUi8puIPAVgjLkIPAgkYgVIKDDDbWeg1JUuKMiaP373bnjsMZg717rD6/HHrcm2lCoG7gySvOZ2zNnzNwiYZYwJAXoBc0TEBygDtAdibP/eLiJdRMQPK0haAXWwmraeyfPNRUaKSLyIxB85kntOY6VKlbwm1rr2Wp1YSxULdwZJMnCNw3IIuZuh7gPmAxhjfgYCgOq2fb83xhw1xqRh1VaigEjbtruMNUfwfODGvN7cGDPdGBNtjImuodOZKmXRibWUG7gzSNYBTUSkoYiUxepM/yrHNn8CXQBEpDlWkBwBlgERIlLO1sHeEdgK7AdCRSQrGboB29x4DkpdnbIm1vrll+wTa338sU6spQrNbUFijEnHuqNqGdaH/XxjzBYReUFEbrNtNgYYISIbgU+BYcZyApiIFUYJwG/GmK+NMQeA54EfRGQTVg3lFXedg1JXvRtuuDSxVrVqcPfdOrGWKjQxpeA/S3R0tImPj/d0MZTybpmZVi1l3DhISrKGX4mNtR54VKWSiKw3xkQXtJ0+2a6UsujEWqqINEiUUtnpxFqqkDRIlFJ5yzmx1pdf6sRaKk8aJEqp/GVNrLVrl06spfKkQaKUco5OrKUuQ4NEKVU4l5tY6/vvPV0y5SEaJEqponGcWOv4cViwwNMlUh6iQaKUck2HDlC+vKdLoTxIg0QppZRLNEiUUupqdPEipKeXyFuVKZF3UUqp0uziRTh79tLXuXPZl92xPiMDQkJgzx5r5kw30iBRSpUuJfmhnrXOlRGVAwKsh0OzvhyXK1aEWrVyrw8MhF9/tWbGvHhRg0QpdRVz5kO9uD/oi+NDPeeHdtaHes2auddfbvuCXgsIsL4krzkCnRAbawVJCdAgUUoVj++/t8boKqkPdX//y38ABwXl/lDP7wPbmQ95f39rYEuViwaJUsp10dFWU8rXX+f+YHb8UC/sh/nl1uuHulfRIFFKue6bbzxdApVTpUrQsGHRm8YKQSNdKaWuRg8+aI3c7O/v9rfSIFFKKeUSDRKllFIu0SBRSinlEg0SpZRSLtEgUUop5RINEqWUUi7RIFFKKeUSDRKllFIuueqfbBeR3sBREdmb46VKwCkn1lUHjrqpePnJqywldRxn9ylou/xev9xrzlwXT12TvMpSUsfx9msC+rviynaFvS7OXitXr0l9p7YyxlzVX8B0Z9dfZl28N5W7JI7j7D4FbZff665cF09dE09eF2+/Jp68LqXxd8XZa1VS16Q0NG39pxDrL7etJxRXWYpyHGf3KWi7/F7X6+Ke7fWalOxxPHVdCnOt3E5sqaUuQ0TijTHRni6HukSviXfS6+J9SuqalIYaiaume7oAKhe9Jt5Jr4v3KZFrojUSpZRSLtEaiVJKKZdokCillHKJBolSSimXaJC4QET6isiHIrJYRLp7ujwKRORaEZkhIp97uiylmYiUF5HZtt+PGE+XR1nc9ftRaoNERGaKyGER2ZxjfU8R2S4iO0VkbH7HMMZ8aYwZAQwDBrixuKVCMV2T3caY+9xb0tKpkNenH/C57ffjthIvbClSmOvirt+PUhskwCygp+MKEfEFpgC3AqHAIBEJFZFwEflvjq+aDruOt+2nXDOL4rsmqvjNwsnrA4QA+2ybZZRgGUujWTh/Xdziqh9r63KMMT+ISIMcq9sAO40xuwFEZB7QxxjzKvD3nMcQEQFigaXGmN/cW+KrX3FcE+U+hbk+QDJWmCRQuv9gdbtCXpet7iiDXuDs6nLpryiwfhnq5rP9w0BX4A4RecCdBSvFCnVNRKSaiEwDWonIM+4unLrs9fkC6C8iU/Gu4VRKizyvi7t+P0ptjeQyJI91l31i0xjzDvCO+4qjKPw1OQZoqJecPK+PMeYMcE9JF0bZXe66uOX3Q2sk2SUD1zgshwAHPFQWZdFr4t30+ninEr0uGiTZrQOaiEhDESkLDAS+8nCZSju9Jt5Nr493KtHrUmqDREQ+BX4GmolIsojcZ4xJB0YDy4BtwHxjzBZPlrM00Wvi3fT6eCdvuC46aKNSSimXlNoaiVJKqeKhQaKUUsolGiRKKaVcokGilFLKJRokSimlXKJBopRSyiUaJEoVgojUFpF5IrJLRLaKyBIRaerweicR+TnHPmVE5JCIBOdz3OdE5Al3ll0pd9EgUcpJttGeFwGrjTGNjDGhwL+AWg6b/QCE5BiNtSuw2RhzsKTKqlRJ0iBRynmdgYvGmGlZK4wxCcaYHx2WM4EFZJ/obCDwKYCIjBCRdSKyUUQWiki5nG8iIqtFJNr2fXUR2WP73ldE3rDtv0lE7retDxaRH0QkQUQ2i8jNxX/qSl2eBolSzgsD1jux3adY4YGI+AO9gIW2174wxrQ2xrTEGrqiMLPV3QecMsa0BloDI0SkITAYWGaMiQRaYs0BolSJ0WHklSpmxph1IlJBRJoBzYFfjDEnbC+HichLQGWgAtZYSM7qDkSIyB225UpAE6wB+maKiB/wpTFGg0SVKA0SpZy3Bbgj50oReRn4G4CtVgAwD6tW0hxbs5bNLKCvMWajiAwDOuXxPulcai0IcHwr4GFjTK7wEZEOtjLMEZE3jDEfO31WSrlIm7aUct5KwF9ERmStEJHWwHJjTKRDiIAVHkOAW8g+fHcQcNBWe4i5zPvsAa63fe8YXMuAB237IiJNRaS8iNQHDhtjPgRmAFFFPUGlikJrJEo5yRhjROR24G0RGQucw/rQfyyPbbeKSBqw3jZbYJYJwK/AXiARK1hyehOYLyJDscIry7+BBsBvtjvIjgB9sWo1T4rIRSAVuMuF01Sq0HQYeaWUUi7Rpi2llFIu0SBRSinlEg0SpZRSLtEgUUop5RINEqWUUi7RIFFKKeUSDRKllFIu0SBRSinlkv8HjQMnH56Tl/0AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2af6ee95198>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Confusion Matrix for Train Data :-\n",
      "[[ 3925  3737]\n",
      " [  827 47511]]\n",
      "\n",
      "TPR: 92.70800811738995 %\n",
      "TNR: 82.59680134680136 %\n",
      "FPR: 17.403198653198654 %\n",
      "FNR: 7.291991882610054 %\n",
      "\n",
      "\n",
      "Precision_Score of the Optimal LR classifier with parameters-{'C': 0.01, 'penalty': 'l1', 'solver': 'liblinear'} is 87.16601695921628 %\n",
      "\n",
      "Confusion Matrix for Test Data :-\n",
      "[[ 2119  1980]\n",
      " [  417 19484]]\n",
      "\n",
      "TPR: 90.77525158404771 %\n",
      "TNR: 83.55678233438486 %\n",
      "FPR: 16.443217665615144 %\n",
      "FNR: 9.224748415952293 %\n",
      "\n",
      "\n",
      "Classification Report :-\n",
      "\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.84      0.52      0.64      4099\n",
      "          1       0.91      0.98      0.94     19901\n",
      "\n",
      "avg / total       0.90      0.90      0.89     24000\n",
      "\n",
      "Wall time: 39.9 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2af6eeefeb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "info = run_LR(data_train, sent_vectors_train, data_test, sent_vectors_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+----------+-----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "|  Model   |                  Optimal Parameters                 |  Scoring Metric | Score |  TPR  |  TNR  |  FPR  | FNR  |\n",
      "+----------+-----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "|   BOW    |  {'C': 0.1, 'penalty': 'l2', 'solver': 'liblinear'} | precision_macro | 90.02 | 94.48 | 85.57 | 14.43 | 5.52 |\n",
      "|  TFIDF   |  {'C': 1.0, 'penalty': 'l2', 'solver': 'liblinear'} | precision_macro | 91.31 | 93.82 | 88.79 | 11.21 | 6.18 |\n",
      "| Avg. W2V | {'C': 0.01, 'penalty': 'l1', 'solver': 'liblinear'} | precision_macro | 87.17 | 90.78 | 83.56 | 16.44 | 9.22 |\n",
      "+----------+-----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "Wall time: 2 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pt.add_row(['Avg. W2V'] + info[:-2])\n",
    "print(pt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## TFIDF-weighted W2V Vectorizer based model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wall time: 2.02 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sent_vectors_train = pd.read_csv('./Matrices/tfidf_w2v_train.csv')\n",
    "sent_vectors_test = pd.read_csv('./Matrices/tfidf_w2v_test.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(56000, 4) (56000, 50)\n",
      "X_Train: (56000, 54)\n",
      "y_Train: (56000,)\n",
      "X_Test: (24000, 54)\n",
      "y_Test: (24000,)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2af6efb5be0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Confusion Matrix for Train Data :-\n",
      "[[ 3892  3770]\n",
      " [ 1081 47257]]\n",
      "\n",
      "TPR: 92.61175456131068 %\n",
      "TNR: 78.26261813794491 %\n",
      "FPR: 21.7373818620551 %\n",
      "FNR: 7.388245438689321 %\n",
      "\n",
      "\n",
      "Precision_Score of the Optimal LR classifier with parameters-{'C': 0.1, 'penalty': 'l2', 'solver': 'liblinear'} is 85.16403942772041 %\n",
      "\n",
      "Confusion Matrix for Test Data :-\n",
      "[[ 2068  2031]\n",
      " [  523 19378]]\n",
      "\n",
      "TPR: 90.51333551310196 %\n",
      "TNR: 79.81474334233887 %\n",
      "FPR: 20.185256657661135 %\n",
      "FNR: 9.486664486898032 %\n",
      "\n",
      "\n",
      "Classification Report :-\n",
      "\n",
      "             precision    recall  f1-score   support\n",
      "\n",
      "          0       0.80      0.50      0.62      4099\n",
      "          1       0.91      0.97      0.94     19901\n",
      "\n",
      "avg / total       0.89      0.89      0.88     24000\n",
      "\n",
      "Wall time: 35.8 s\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x2af6f151860>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%time\n",
    "info = run_LR(data_train, sent_vectors_train, data_test, sent_vectors_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "+-----------+-----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "|   Model   |                  Optimal Parameters                 |  Scoring Metric | Score |  TPR  |  TNR  |  FPR  | FNR  |\n",
      "+-----------+-----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "|    BOW    |  {'C': 0.1, 'penalty': 'l2', 'solver': 'liblinear'} | precision_macro | 90.02 | 94.48 | 85.57 | 14.43 | 5.52 |\n",
      "|   TFIDF   |  {'C': 1.0, 'penalty': 'l2', 'solver': 'liblinear'} | precision_macro | 91.31 | 93.82 | 88.79 | 11.21 | 6.18 |\n",
      "|  Avg. W2V | {'C': 0.01, 'penalty': 'l1', 'solver': 'liblinear'} | precision_macro | 87.17 | 90.78 | 83.56 | 16.44 | 9.22 |\n",
      "| TFIDF W2V |  {'C': 0.1, 'penalty': 'l2', 'solver': 'liblinear'} | precision_macro | 85.16 | 90.51 | 79.81 | 20.19 | 9.49 |\n",
      "+-----------+-----------------------------------------------------+-----------------+-------+-------+-------+-------+------+\n",
      "Wall time: 2 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "pt.add_row(['TFIDF W2V'] + info[:-2])\n",
    "print(pt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusions :-\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). 'precision_macro' metric has been used here to evaluate the models. \n",
    "-  From the Performances obtained on the four Vectorizer models, it has been observed that TFIDF Vectorizer is giving the best performance - high TPR with the highest 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."
   ]
  }
 ],
 "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
}