TextClassification_Keras_TF-IDF.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Text classification using Keras"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pandas as pd\n",
    "import re\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import nltk\n",
    "from nltk.corpus import wordnet\n",
    "from nltk import pos_tag, word_tokenize\n",
    "from nltk.corpus import stopwords\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "from sklearn import metrics\n",
    "\n",
    "import tensorflow as tf\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "from datetime import datetime\n",
    "from tensorflow.keras import Model, Sequential\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "\n",
    "from tensorflow.keras.layers import Activation, Dense, Embedding, GlobalAveragePooling1D, Dropout, MaxPooling1D, Conv1D, LSTM\n",
    "from tensorflow.keras.layers.experimental.preprocessing import TextVectorization\n",
    "from keras.preprocessing.text import text_to_word_sequence\n",
    "from tensorflow.keras import regularizers\n",
    "from tensorflow.keras.layers import Flatten"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Reading a subset from Yelp Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_b = pd.read_json('yelp_academic_dataset_review.json', lines=True, chunksize=300000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "data=[]\n",
    "for c in df_b:\n",
    "    data=c\n",
    "    break\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(300000, 9)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Shape of the selected data \n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>review_id</th>\n",
       "      <th>user_id</th>\n",
       "      <th>business_id</th>\n",
       "      <th>stars</th>\n",
       "      <th>useful</th>\n",
       "      <th>funny</th>\n",
       "      <th>cool</th>\n",
       "      <th>text</th>\n",
       "      <th>date</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>299995</th>\n",
       "      <td>0-nk09u6gk4oonzcW4LgMQ</td>\n",
       "      <td>zJfJC--nT-xKLTzdyvroyw</td>\n",
       "      <td>aY-lZvoTHAFl9k6dcfcAxQ</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Very delicious food and amazing service! I com...</td>\n",
       "      <td>2015-08-12 01:49:19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>299996</th>\n",
       "      <td>gJwywVNsIfFlCKiBQj93uw</td>\n",
       "      <td>8nCmV4RMwf4GpaN-A_2Tfw</td>\n",
       "      <td>Khs3iUmkHce7xpAyOo5kRg</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>Sardella's is my favorite pizza chain in the v...</td>\n",
       "      <td>2012-08-23 16:54:00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>299997</th>\n",
       "      <td>_0Q9Qg3CZJfuLTtH5KkxbA</td>\n",
       "      <td>nKdhohT1D6doq_v0ReBvzQ</td>\n",
       "      <td>m97jaBYRscg-hqDjMVIIWg</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>The Hostess was the worst. Not very inviting i...</td>\n",
       "      <td>2015-08-24 21:33:18</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>299998</th>\n",
       "      <td>uc_2Q_UvC0r0AZnERb1k4w</td>\n",
       "      <td>hHuDkGLAOTlR-lLCROotbA</td>\n",
       "      <td>Xs2iTWxbczvfEapAFH3cyw</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>Moved to a new neighborhood = hunt for a new b...</td>\n",
       "      <td>2015-10-23 02:06:21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>299999</th>\n",
       "      <td>Q_2ppaCk3go14WNSXUB1Rg</td>\n",
       "      <td>usfq6zK3yG1IA0V5k6XHyQ</td>\n",
       "      <td>mP5qGYKMpy5WWe5BVN5dig</td>\n",
       "      <td>5</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>This is the best mechanic experience I have ha...</td>\n",
       "      <td>2017-01-07 00:34:54</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     review_id                 user_id  \\\n",
       "299995  0-nk09u6gk4oonzcW4LgMQ  zJfJC--nT-xKLTzdyvroyw   \n",
       "299996  gJwywVNsIfFlCKiBQj93uw  8nCmV4RMwf4GpaN-A_2Tfw   \n",
       "299997  _0Q9Qg3CZJfuLTtH5KkxbA  nKdhohT1D6doq_v0ReBvzQ   \n",
       "299998  uc_2Q_UvC0r0AZnERb1k4w  hHuDkGLAOTlR-lLCROotbA   \n",
       "299999  Q_2ppaCk3go14WNSXUB1Rg  usfq6zK3yG1IA0V5k6XHyQ   \n",
       "\n",
       "                   business_id  stars  useful  funny  cool  \\\n",
       "299995  aY-lZvoTHAFl9k6dcfcAxQ      5       0      0     0   \n",
       "299996  Khs3iUmkHce7xpAyOo5kRg      3       1      0     0   \n",
       "299997  m97jaBYRscg-hqDjMVIIWg      2       0      0     0   \n",
       "299998  Xs2iTWxbczvfEapAFH3cyw      5       0      1     0   \n",
       "299999  mP5qGYKMpy5WWe5BVN5dig      5       1      0     0   \n",
       "\n",
       "                                                     text                date  \n",
       "299995  Very delicious food and amazing service! I com... 2015-08-12 01:49:19  \n",
       "299996  Sardella's is my favorite pizza chain in the v... 2012-08-23 16:54:00  \n",
       "299997  The Hostess was the worst. Not very inviting i... 2015-08-24 21:33:18  \n",
       "299998  Moved to a new neighborhood = hunt for a new b... 2015-10-23 02:06:21  \n",
       "299999  This is the best mechanic experience I have ha... 2017-01-07 00:34:54  "
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Last 5 rows of the data\n",
    "data.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"The food has always been good and the service just keeps getting better.  They recently remodeled the building, so it's very modern/clean looking.  They always give you a heaping mound of each dish, so you never feel you're not getting your money's worth.  There's an extra $0.50 or $1.00 for some of the more premium items (shrimp, added bacon, etc) but it's always worth it.  I wouldn't want to eat there every day, but I'm always happy when I get the chance.\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Review comment of a random record\n",
    "\n",
    "data.iloc[3456,7]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Count of different ratings:\n",
      "  stars\n",
      "1     41433\n",
      "2     24493\n",
      "3     33588\n",
      "4     68426\n",
      "5    132060\n",
      "dtype: int64\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "\n",
    "r=data.groupby('stars').size()\n",
    "print(\"Count of different ratings:\\n \",r)\n",
    "r.plot.bar(color='brown');\n",
    "\n",
    "# Data is unbalanced with less records with ratings 2 and 3 and maximum of rating 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100764, 9)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Balancing the data, considering ratings would be clubbed later on\n",
    "\n",
    "d1=data[data.stars==1].sample(16794, replace=False)\n",
    "d2=data[data.stars==2].sample(16794, replace=False)\n",
    "d3=data[data.stars==3].sample(33588, replace=False)\n",
    "d4=data[data.stars==4].sample(16794, replace=False)\n",
    "d5=data[data.stars==5].sample(16794, replace=False)\n",
    "\n",
    "data=pd.concat([d1,d2,d3,d4,d5])\n",
    "\n",
    "data.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.options.display.float_format = '{:,.2f}'.format"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>stars</th>\n",
       "      <th>useful</th>\n",
       "      <th>funny</th>\n",
       "      <th>cool</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>100,764.00</td>\n",
       "      <td>100,764.00</td>\n",
       "      <td>100,764.00</td>\n",
       "      <td>100,764.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>3.00</td>\n",
       "      <td>1.18</td>\n",
       "      <td>0.43</td>\n",
       "      <td>0.42</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>1.29</td>\n",
       "      <td>2.34</td>\n",
       "      <td>1.38</td>\n",
       "      <td>1.30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>2.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>3.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>4.00</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.00</td>\n",
       "      <td>0.00</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>5.00</td>\n",
       "      <td>73.00</td>\n",
       "      <td>66.00</td>\n",
       "      <td>54.00</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "           stars     useful      funny       cool\n",
       "count 100,764.00 100,764.00 100,764.00 100,764.00\n",
       "mean        3.00       1.18       0.43       0.42\n",
       "std         1.29       2.34       1.38       1.30\n",
       "min         1.00       0.00       0.00       0.00\n",
       "25%         2.00       0.00       0.00       0.00\n",
       "50%         3.00       0.00       0.00       0.00\n",
       "75%         4.00       1.00       0.00       0.00\n",
       "max         5.00      73.00      66.00      54.00"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.describe()\n",
    "\n",
    "# Data is categorical, so not much useful info gained apart from the range"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Pre-processing the Text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to remove the word contractions, like convert isn't to is not\n",
    "def decontracted(phrase):\n",
    "    # specific\n",
    "    phrase = re.sub(r\"won\\'t\", \"will not\", phrase)\n",
    "    phrase = re.sub(r\"can\\'t\", \"can not\", phrase)\n",
    "    phrase = re.sub(r\"ain\\'t\", \"am not\", phrase) \n",
    "    \n",
    "    # general\n",
    "    phrase = re.sub(r\"n\\'t\", \" not\", phrase)\n",
    "    phrase = re.sub(r\"\\'re\", \" are\", phrase)\n",
    "    phrase = re.sub(r\"\\'s\", \" is\", phrase)\n",
    "    phrase = re.sub(r\"\\'d\", \" would\", phrase)\n",
    "    phrase = re.sub(r\"\\'ll\", \" will\", phrase)\n",
    "    phrase = re.sub(r\"\\'t\", \" not\", phrase)\n",
    "    phrase = re.sub(r\"\\'ve\", \" have\", phrase)\n",
    "    phrase = re.sub(r\"\\'m\", \" am\", phrase)\n",
    "    return phrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_wordnet_pos(treebank_tag):\n",
    "    if treebank_tag.startswith('J'):\n",
    "        return wordnet.ADJ\n",
    "    elif treebank_tag.startswith('V'):\n",
    "        return wordnet.VERB\n",
    "    elif treebank_tag.startswith('N'):\n",
    "        return wordnet.NOUN\n",
    "    elif treebank_tag.startswith('R'):\n",
    "        return wordnet.ADV\n",
    "    else:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to lemmatize - converting a word to its root\n",
    "def lemmatise(phrase):\n",
    "    arr=[]\n",
    "    t=pos_tag(word_tokenize(phrase))\n",
    "    for a in t:\n",
    "        postag=get_wordnet_pos(a[1])\n",
    "        if not postag:\n",
    "            continue\n",
    "        p=nltk.stem.WordNetLemmatizer().lemmatize(a[0],pos=postag)\n",
    "        arr.append(p)\n",
    "    return arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to remove stopwords excluding the negations like not, no \n",
    "\n",
    "def rem_stopwords(phrase):\n",
    "    sw=stopwords.words('english')\n",
    "    sw.remove('no')\n",
    "    sw.remove('not')\n",
    "    sw.remove('nor')\n",
    "    phrase = [word for word in phrase if word not in sw]\n",
    "    return phrase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "def text_cleanup(text):\n",
    "    \n",
    "    text= decontracted(text)\n",
    "    text = re.sub(r'[^\\w\\s]', '', str(text).lower()) # Regex to remove punctuations and convert to lowercase\n",
    "    text=lemmatise(text)\n",
    "    text=rem_stopwords(text)\n",
    "    text = \" \".join(text)\n",
    "    return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Cleaning the text to whole of the dataset\n",
    "data['text_clean']=data['text'].apply(lambda x: text_cleanup(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Removing all columns except processed text and ratings\n",
    "\n",
    "data.drop(['review_id','user_id','date','business_id','text','useful','funny','cool'],axis=1,inplace=True);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>stars</th>\n",
       "      <th>text_clean</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>148616</th>\n",
       "      <td>1</td>\n",
       "      <td>work medical office currently pa school good i...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>101477</th>\n",
       "      <td>1</td>\n",
       "      <td>eat group town idea restaurant close minute se...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>295165</th>\n",
       "      <td>1</td>\n",
       "      <td>wait minute get help meanwhile associate stand...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>276523</th>\n",
       "      <td>1</td>\n",
       "      <td>dislike store salon customer service mediocre ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>171844</th>\n",
       "      <td>1</td>\n",
       "      <td>single horrific transportation experience life...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        stars                                         text_clean\n",
       "148616      1  work medical office currently pa school good i...\n",
       "101477      1  eat group town idea restaurant close minute se...\n",
       "295165      1  wait minute get help meanwhile associate stand...\n",
       "276523      1  dislike store salon customer service mediocre ...\n",
       "171844      1  single horrific transportation experience life..."
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Seperating feature and label\n",
    "X=data.loc[:,'text_clean']\n",
    "y=data.loc[:,'stars']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Combining classes with final 3 class of ratings - 0, 1 and 2, not used one hot encoding to maintain ordinality\n",
    "result = y.replace(to_replace = [1,2], value = 0, inplace=True) \n",
    "result = y.replace(to_replace = [4,5], value = 2, inplace=True) \n",
    "result = y.replace(to_replace = [3], value = 1, inplace=True) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2    33588\n",
       "1    33588\n",
       "0    33588\n",
       "Name: stars, dtype: int64"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Count of different ratings - data is balanced\n",
    "y.value_counts()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Splitting the data into training, testing and validation sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)\n",
    "X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train=X_train.to_numpy()\n",
    "y_train=y_train.to_numpy()\n",
    "X_val=X_val.to_numpy()\n",
    "y_val=y_val.to_numpy()\n",
    "X_test=X_test.to_numpy()\n",
    "y_test=y_test.to_numpy()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(64488,)\n"
     ]
    }
   ],
   "source": [
    "#Shape of training data\n",
    "print((X_train).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Building vocabulary from the training dataset as words\n",
    "t=Tokenizer(num_words=50000)\n",
    "t.fit_on_texts(X_train)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vocabulary length:  75806\n",
      "\n",
      "Key:  worth Value:  316\n"
     ]
    }
   ],
   "source": [
    "print(\"Vocabulary length: \", len(t.word_index))\n",
    "\n",
    "# Finding location of a word in vocabulary for demo purpose\n",
    "for key, values in t.word_index.items():\n",
    "    if key=='worth' :\n",
    "        print(\"\\nKey: \", key, \"Value: \",values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of words encoded as numbers in the first document:  14\n"
     ]
    }
   ],
   "source": [
    "# Encoding the documents based on the vocabulary\n",
    "encoded_train=t.texts_to_sequences(X_train)\n",
    "\n",
    "print(\"Total number of words encoded as numbers in the first document: \",len(encoded_train[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total number of words encoded as numbers in the first document:  510\n"
     ]
    }
   ],
   "source": [
    "# Padding the documents to make al documents of equal length by appending zeros at the end \n",
    "padded_train = pad_sequences(encoded_train, padding='post')\n",
    "print(\"Total number of words encoded as numbers in the first document: \",len(padded_train[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  69,  241, 2045, ...,    0,    0,    0],\n",
       "       [ 464,   49,  109, ...,    0,    0,    0],\n",
       "       [  43,   98,  454, ...,    0,    0,    0],\n",
       "       ...,\n",
       "       [   1,  551, 2948, ...,    0,    0,    0],\n",
       "       [   1,  116,  159, ...,    0,    0,    0],\n",
       "       [  39, 5401, 1013, ...,    0,    0,    0]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training data set after text pre-processing\n",
    "padded_train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of post-processed training dataset:  (64488, 510)\n"
     ]
    }
   ],
   "source": [
    "print(\"Shape of post-processed training dataset: \",(padded_train.shape))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of post-processed validation dataset:  (16123, 510)\n",
      "Shape of post-processed testing dataset:  (20153, 510)\n"
     ]
    }
   ],
   "source": [
    "# Similarly processing validation and testing dataset\n",
    "\n",
    "encoded_val=t.texts_to_sequences(X_val) # fit is performed only for training dataset\n",
    "padded_val = pad_sequences(encoded_val, padding='post', maxlen=padded_train.shape[1])\n",
    "\n",
    "print(\"Shape of post-processed validation dataset: \",(padded_val.shape))\n",
    "\n",
    "encoded_test=t.texts_to_sequences(X_test) # fit is performed only for training dataset\n",
    "padded_test = pad_sequences(encoded_test, padding='post', maxlen=padded_train.shape[1])\n",
    "\n",
    "print(\"Shape of post-processed testing dataset: \",(padded_test.shape))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Building Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Bulding model using Keras - Embedding and Dense NN with Regularizers to prevent over-fitting\n",
    "model1 = Sequential([\n",
    "  Embedding(input_dim=50001, output_dim=16,input_length=padded_train.shape[1], embeddings_regularizer=regularizers.l2(0.001)),\n",
    "    Flatten(),\n",
    "  Dense(128, activation='relu', kernel_regularizer=regularizers.l2(0.001),bias_regularizer=regularizers.l2(0.001)),\n",
    "  Dense(3, activation='softmax')\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding (Embedding)        (None, 510, 16)           800016    \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 8160)              0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 128)               1044608   \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 3)                 387       \n",
      "=================================================================\n",
      "Total params: 1,845,011\n",
      "Trainable params: 1,845,011\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model1.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "model1.compile(optimizer='adam',\n",
    "              loss=\"sparse_categorical_crossentropy\",\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/8\n",
      "504/504 [==============================] - 29s 58ms/step - loss: 0.8809 - accuracy: 0.6434 - val_loss: 0.7668 - val_accuracy: 0.7068\n",
      "Epoch 2/8\n",
      "504/504 [==============================] - 32s 64ms/step - loss: 0.7543 - accuracy: 0.7188 - val_loss: 0.7604 - val_accuracy: 0.7115\n",
      "Epoch 3/8\n",
      "504/504 [==============================] - 37s 74ms/step - loss: 0.7393 - accuracy: 0.7280 - val_loss: 0.7555 - val_accuracy: 0.7164\n",
      "Epoch 4/8\n",
      "504/504 [==============================] - 37s 74ms/step - loss: 0.7300 - accuracy: 0.7357 - val_loss: 0.7599 - val_accuracy: 0.7179\n",
      "Epoch 5/8\n",
      "504/504 [==============================] - 37s 74ms/step - loss: 0.7233 - accuracy: 0.7440 - val_loss: 0.7934 - val_accuracy: 0.7056\n",
      "Epoch 6/8\n",
      "504/504 [==============================] - 32s 64ms/step - loss: 0.7153 - accuracy: 0.7602 - val_loss: 0.8063 - val_accuracy: 0.7061 0.7154 - accuracy: \n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "early_stopping = EarlyStopping(patience=3)\n",
    "\n",
    "\n",
    "history=model1.fit(padded_train, y_train, epochs=8, batch_size=128, validation_data=(padded_val, y_val), callbacks=[early_stopping])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nO3deXxV1bnw8d+TiRBIyMBMEpIwySAEiCAiCFotap2txaqttkoVvbXet7219723Wnv73t4O1vYWtEitHazUUkHaohYrCAgoQQYZREJISJjJRCCETM/7x94JJ+EEDpCTnZzzfD+f88nZe6+9z7ND2M9Za+29lqgqxhhjTEsRXgdgjDGmY7IEYYwxxi9LEMYYY/yyBGGMMcYvSxDGGGP8sgRhjDHGL0sQxgAi8rKI/FeAZQtE5DPBjskYr1mCMMYY45clCGNCiIhEeR2DCR2WIEyn4TbtfEtEtojICRH5tYj0EZE3RaRSRN4RkSSf8jeLyDYRKReRFSIy3GfbWBH5yN3vT0Bsi8/6nIhscvddIyKjA4zxRhHZKCLHRKRIRJ5usf1K93jl7vb73fVdReSnIlIoIhUistpdN01Eiv38Hj7jvn9aRBaKyB9E5Bhwv4hMEJG17mccEJFfikiMz/4jRWSZiJSKyCER+XcR6SsiVSKS4lNuvIgcEZHoQM7dhB5LEKazuQO4FhgK3AS8Cfw70BPn7/nrACIyFHgV+AbQC1gK/FVEYtyL5WLg90Ay8Gf3uLj7jgNeAr4GpAC/ApaISJcA4jsBfAlIBG4EHhGRW93jprvx/q8bUzawyd3vJ8B44Ao3pn8DGgL8ndwCLHQ/8xWgHnjC/Z1MAq4BZrsxxAPvAG8B/YHBwD9V9SCwArjL57j3AgtUtTbAOEyIsQRhOpv/VdVDqroPWAV8oKobVfUUsAgY65b7AvB3VV3mXuB+AnTFuQBfDkQDz6lqraouBNb7fMZDwK9U9QNVrVfV3wKn3P3OSlVXqOrHqtqgqltwktRV7uZ7gHdU9VX3c0tUdZOIRABfAR5X1X3uZ65xzykQa1V1sfuZJ1V1g6quU9U6VS3ASXCNMXwOOKiqP1XValWtVNUP3G2/xUkKiEgkcDdOEjVhyhKE6WwO+bw/6We5u/u+P1DYuEFVG4AiYIC7bZ82H6my0Of9QOD/uE005SJSDqS5+52ViEwUkeVu00wF8DDON3ncY+z2s1tPnCYuf9sCUdQihqEi8jcROeg2O/2/AGIAeAMYISJZOLW0ClX98AJjMiHAEoQJVftxLvQAiIjgXBz3AQeAAe66Ruk+74uAH6hqos8rTlVfDeBz/wgsAdJUtQfwAtD4OUXAID/7HAWqW9l2AojzOY9InOYpXy2HZH4e+AQYoqoJOE1w54oBVa0GXsOp6dyH1R7CniUIE6peA24UkWvcTtb/g9NMtAZYC9QBXxeRKBG5HZjgs++LwMNubUBEpJvb+RwfwOfGA6WqWi0iE4Av+mx7BfiMiNzlfm6KiGS7tZuXgGdFpL+IRIrIJLfP41Mg1v38aOA/gHP1hcQDx4DjInIJ8IjPtr8BfUXkGyLSRUTiRWSiz/bfAfcDNwN/COB8TQizBGFCkqruxGlP/1+cb+g3ATepao2q1gC341wIy3D6K1732TcXpx/il+72PLdsIGYDz4hIJfBdnETVeNy9wA04yaoUp4N6jLv5m8DHOH0hpcD/ABGqWuEecz5O7ecE0OyuJj++iZOYKnGS3Z98YqjEaT66CTgI7AKm+2x/H6dz/CO3/8KEMbEJg4wxvkTkXeCPqjrf61iMtyxBGGOaiMhlwDKcPpRKr+Mx3rImJmMMACLyW5xnJL5hycGA1SCMMca0wmoQxhhj/AqZgb169uypGRkZXodhjDGdyoYNG46qastna4AQShAZGRnk5uZ6HYYxxnQqIlLY2jZrYjLGGOOXJQhjjDF+WYIwxhjjV8j0QfhTW1tLcXEx1dXVXocSMmJjY0lNTSU62uaQMSbUhXSCKC4uJj4+noyMDJoP3GkuhKpSUlJCcXExmZmZXodjjAmyoDYxicgMEdkpInki8qSf7T9zp3XcJCKfuuPuN25LF5F/iMgOEdkuIhnn+/nV1dWkpKRYcmgjIkJKSorVyIwJE0GrQbjj1s/BGTmyGFgvIktUdXtjGVV9wqf8v3B6NjBwhh3+gaouE5HuBD79Yss4LmQ30wr7fRoTPoJZg5gA5Klqvju88gKcuXNbczfO9IyIyAggSlWXAajqcVWtCmKsxhjT6dTWN/DGpn28+uHeoBw/mAliAM2nQix2151BRAYCmcC77qqhQLmIvC4iG0Xkx26NpNMpLy9n7ty5573fDTfcQHl5+bkLGmPCTmV1LfNX5TPtxyt4fMEmXsstIhjj6gWzk9pfW0RrZzATWKiq9e5yFDAFp8lpL86EJ/cDv272ASKzgFkA6em+M0Z2HI0JYvbs2c3W19fXExnZes5bunRpsEMzxnQy+8tP8vKaAl79YC+Vp+qYkJHM0zeP5JpLegel+TeYCaIYZw7gRqk48wT7MxN4tMW+G1U1H0BEFgOX0yJBqOo8YB5ATk5OhxyW9sknn2T37t1kZ2cTHR1N9+7d6devH5s2bWL79u3ceuutFBUVUV1dzeOPP86sWbOA00OHHD9+nOuvv54rr7ySNWvWMGDAAN544w26du3q8ZkZY9rL1n0VzF+Vz9+2HECB60f15aEpWYxJSwzq5wYzQawHhohIJs5UiTNpPj8vACIyDEjCmSfYd98kEemlqkeAq4GLGmjpe3/dxvb9xy7mEGcY0T+Bp24aedYyP/zhD9m6dSubNm1ixYoV3HjjjWzdurXpNtGXXnqJ5ORkTp48yWWXXcYdd9xBSkpKs2Ps2rWLV199lRdffJG77rqLv/zlL9x7771tei7GmI6loUF579MjzFuZz9r8ErrFRPKlSRk8MDmDtOS4dokhaAlCVetE5DHgbSASeElVt4nIM0Cuqi5xi94NLFCfBjRVrReRbwL/FKfetAFnbt1Ob8KECc2eIfjFL37BokWLACgqKmLXrl1nJIjMzEyys7MBGD9+PAUFBe0WrzGmfVXX1rN44z7mr95D3uHj9E2I5TvXX8LMCen06Nq+D6gG9UE5VV0KLG2x7rstlp9uZd9lwOi2iuVc3/TbS7du3Zrer1ixgnfeeYe1a9cSFxfHtGnT/D5j0KVLl6b3kZGRnDx5sl1iNca0n9ITNfxhXSG/W1vA0eM1jOiXwM++MIYbL+1PTJQ3oyKF9JPUHUF8fDyVlf5nb6yoqCApKYm4uDg++eQT1q1b187RGWO8tufoCX69Op+FG4qprm1g2rBePDQliysGef+QryWIIEtJSWHy5MmMGjWKrl270qdPn6ZtM2bM4IUXXmD06NEMGzaMyy+/3MNIjTHtRVXJLSxj3sp83tlxiOiICG4d258Hp2QxtE+81+E1CZk5qXNycrTlhEE7duxg+PDhHkUUuuz3asyFqatv4K1tB3lx1R42F5WTGBfNfZcP5L5JA+kdH+tJTCKyQVVz/G2zGoQxxgTZ8VN1vLa+iJfe30Nx2UkyUuL4/i0juWN8KnExHfcy3HEjM8aYTu5gRTUvrynglQ8KqayuI2dgEv/5uRF8ZngfIiM6/rhmliCMMaaNbd9/jPmr8lmyeT8Nqlw/qh8PTslkbHqS16GdF0sQxhjTBlSdB9vmr9rD6ryjxMVEcu/lA/nqlZnt9mBbW7MEYYwxF+FUXT1vbNrPr1ftYeehSnrHd+HfZgzjngkD6RHXuWdetARhjDEXoLyqhlc+2MvLawo4UnmKS/rG89PPj+GmMd492NbWQuMsQkj37t0B2L9/P3feeaffMtOmTaPlLb0tPffcc1RVnZ5Cw4YPN6ZtFJac4LtvbGXSf7/Lj9/eyfB+Cfz+qxN48/Ep3DE+NWSSA1gNosPq378/CxcuvOD9n3vuOe69917i4py2Txs+3JiLs6GwlBdX7uHt7QeJihBuyR7Ag1MyuaRvgtehBU3opLoO6tvf/nazCYOefvppvve973HNNdcwbtw4Lr30Ut54440z9isoKGDUqFEAnDx5kpkzZzJ69Gi+8IUvNBuL6ZFHHiEnJ4eRI0fy1FNPAc4AgPv372f69OlMnz4dcIYPP3r0KADPPvsso0aNYtSoUTz33HNNnzd8+HAeeughRo4cyXXXXWdjPpmwV9+gvPnxAW6f+z53PL+WtfklPHLVIFZ/+2p+8vkxIZ0cIJxqEG8+CQc/bttj9r0Urv/hWYvMnDmTb3zjG00TBr322mu89dZbPPHEEyQkJHD06FEuv/xybr755lbHXXn++eeJi4tjy5YtbNmyhXHjxjVt+8EPfkBycjL19fVcc801bNmyha9//es8++yzLF++nJ49ezY71oYNG/jNb37DBx98gKoyceJErrrqKpKSkmxYcWNcVTV1/Dm3mF+v3sPe0irSk+P43s0j+XxOx36wra2Fz5l6ZOzYsRw+fJj9+/dz5MgRkpKS6NevH0888QQrV64kIiKCffv2cejQIfr27ev3GCtXruTrX/86AKNHj2b06NOD3L722mvMmzePuro6Dhw4wPbt25ttb2n16tXcdtttTaPK3n777axatYqbb77ZhhU3Ye/wscYH2/ZScbKWcemJfOf6S7huZN9O8WBbWwufBHGOb/rBdOedd7Jw4UIOHjzIzJkzeeWVVzhy5AgbNmwgOjqajIwMv8N8+/JXu9izZw8/+clPWL9+PUlJSdx///3nPM7Zxt6yYcVNuNp5sJIXV+XzxqZ91DUonx3Rl4emZjJ+YLLXoXnK+iDawcyZM1mwYAELFy7kzjvvpKKigt69exMdHc3y5cspLCw86/5Tp07llVdeAWDr1q1s2bIFgGPHjtGtWzd69OjBoUOHePPNN5v2aW2Y8alTp7J48WKqqqo4ceIEixYtYsqUKW14tsZ0DqrKql1H+NJLH/LZ51by9y0H+OKEdFZ8cxov3Dc+7JMDhFMNwkMjR46ksrKSAQMG0K9fP+655x5uuukmcnJyyM7O5pJLLjnr/o888ggPPPAAo0ePJjs7mwkTJgAwZswYxo4dy8iRI8nKymLy5MlN+8yaNYvrr7+efv36sXz58qb148aN4/777286xoMPPsjYsWOtOcmEjZq6Bv66eT8vrsrnk4OV9Irvwrc+O4x7JqaTGBfjdXgdig33bc6b/V5NZ1RRVcsrHxby2zUFHDp2imF94vnqlExuye5Pl6hIr8PzjA33bYwJW0WlVfx69R5eyy2iqqaeKUN68qM7xzB1SE/PZ2zr6CxBGGNC0sa9ZcxftYc3tx4gQoSbs/vz4JVZjOgf2s8utKWQTxCqat8S2lCoNEma0FTfoLyz4xDzV+WzvqCMhNgoZk0dxP1XZNC3hzcztnVmIZ0gYmNjKSkpISXF+8m/Q4GqUlJSQmys/UczHcOJU3VsKiont6CM3MJSNu0tp/JUHalJXXnqphHclZNGty4hfZkLqpD+zaWmplJcXMyRI0e8DiVkxMbGkpqa6nUYJkwdrKgmt7CU3IIyNhSWsf3AMeobFBEY1ieeW8b258rBvfjM8N5ERdpd/BcrpBNEdHQ0mZmZXodhjLkA9Q3Kp4cqyS0oJbewjNyCMvaVOw9vdo2OJDstkUenDWJ8RjJj0xNJiO3ccy90RCGdIIwxnUdVTR2b9pY7yaCwjI2FZVSeqgOgT0IXcgYm89UrM8nJSGJ4vwSirYYQdEFNECIyA/g5EAnMV9Ufttj+M2C6uxgH9FbVRJ/tCcAOYJGqPhbMWI0x7evQseqmvoPcgjObi27O7k9ORhI5A5NJTepq/YgeCFqCEJFIYA5wLVAMrBeRJaq6vbGMqj7hU/5fgLEtDvN94L1gxWiMaR9NzUWFZWxwm4yKy5zmotjoCLLTEpk9bRDjByYxNj2JHl2tuagjCGYNYgKQp6r5ACKyALgF2N5K+buBpxoXRGQ80Ad4C/D7lJ8xpmOqqnHuLtpQ4DQXfbS3jMpqp7mod3wXcjKSeGByJjkDkxjR35qLOqpgJogBQJHPcjEw0V9BERkIZALvussRwE+B+4BrWvsAEZkFzAJIT09vk6CNMefv8LHqpo7k3MJStu8/Rp3bXDS0dzw3jelPzsAkLsuw5qLOJJgJwt9fQGtPWc0EFqpqvbs8G1iqqkVn+0NS1XnAPHDGYrqIWI0xAWpoUD49XNl0q2luYSlFpc2bix6+ahDjM5IYZ81FnVowE0QxkOaznArsb6XsTOBRn+VJwBQRmQ10B2JE5LiqPhmUSI0xrTpZU+80FxU6fQcfFZZxzG0u6hXfhZyBSXx5UgY5GcmMtOaikBLMBLEeGCIimcA+nCTwxZaFRGQYkASsbVynqvf4bL8fyLHkYEz7OFxZzYaCMtYXlLGhsJRtbnMRwNA+3blx9OnmorRkay4KZUFLEKpaJyKPAW/j3Ob6kqpuE5FngFxVXeIWvRtYoDbIjzHtrqFB2XX4OLmFpU0dyntLqwDoEuU0F33tqixyBiY7zUVx1lwUTkJ6PghjTHMna+rZXFzu9B0UlLLBp7moZ3enuSgnI4nxA5MY2b8HMVHWXBTqbD4IY8LUkcpTbCgsZb1bO9i2r6KpuWhI7+7cOLofOQOTyclIIj05zpqLTDOWIIwJESdr6tm6v4LNReVscl+ND6N1iYpgTFois6ZmkePeXWTTa5pzsQRhTCdU36DsOlzpJgMnKew8VEm9WztITerKmLREvjwpg/EZSYyy5iJzASxBGNPBqSoHKqqb1Qw+3ldBVY3z2FBCbBRj0hJ5dPggxqQlMjo1kV7xXTyO2oQCSxDGdDAVJ2v5uLiCzcXlbNxbzubico5UngIgJjKCEf0TuCsnjey0RMakJZKRYn0HJjgsQRjjoZq6BnYcOMbm4tO1g/wjJ5q2Z/XqxpQhPZ1kkJrI8H4J1lRk2o0lCGPaiapSUFLVrKlo+/5j1NQ3AM5tptlpidwxLpUxqYlcmtrDhqkwnrIEYUyQHD1+is1F5WwuKmdjUTlbiiuoOFkLQFxMJJcO6MEDkzMYk5ZIdloi/XrEWlOR6VAsQRjTBk7W1PPxPvcW02InKTTeYhohMKxvAjdc2rep32Bwr+42Z7Lp8CxBGHOemt9i6txm+mkrt5iOSUtk1IAE4mLsv5rpfOyv1pizUFX2u7eYNjYVbfVzi+m1doupCUGWIIzxUXGyli1uE9Gmogq7xdSENUsQJmydqqvnkwOVzi2me52+A7vF1JjTLEGYsKCq7Dl6gs3F5WwuqmBjUTk77BZTY87KEoQJSarK3tIq1u4uYc3uEtbmlzQ1FdktpsYExhKECRn7y086yWB3CWt3H2V/RTXgTIs5KSuFy7NSGDcwkSG944mMsGRgzLlYgjCd1uHKatbuLmFdvlNLKCxxZkJLiotm0qAUHslKYdKgFAb16m61A2MugCUI02mUnahhXb7TXLRmdwl5h48DEB8bxcTMFL40KYMrBqUwrE88EVZDMOaiWYIwHdax6lo+zC9t6kPYceAY4PQhXJaRzOfHpzJpUAoj+/ewJiNjgsAShOkwqmrqWF9QxprdR1m3u4SP91XQoM5saOMHJvHN64YyaVAKo1MTibZhKowJOksQxjPVtfV8VFjW1GS0uaicugYlOlIYm5bEY1cP4YpBKWSnJRIbHel1uMaEHUsQpt3U1DWwubjcvfX0KB/tLaemroHICOHSAT14aGoWVwxKYfzAJBu7yJgOwP4XmqCpq29g6/5jTQkht6CMk7X1iMCIfgl8edJAJg1K4bKMZOJj7aE0YzoaSxCmzTQ0KDsOHnOfQyjhwz2lVJ6qA2Bon+584bI0Ls9K4fKsZBLjYjyO1hhzLpYgzAVTVfIOH296OG3dnhLKq5wJcbJ6duOm7P5cMch5QK1ndxvh1JjOJqgJQkRmAD8HIoH5qvrDFtt/Bkx3F+OA3qqaKCLZwPNAAlAP/EBV/xTMWM25NU6Z2dhktC6/lKPHneErUpO6cu3wPlwxOIVJWT3p2yPW42iNMRcraAlCRCKBOcC1QDGwXkSWqOr2xjKq+oRP+X8BxrqLVcCXVHWXiPQHNojI26paHqx4jX/FZVVNTUZr80s44A5f0SehC1OG9GSS+7RyWnKcx5EaY9paMGsQE4A8Vc0HEJEFwC3A9lbK3w08BaCqnzauVNX9InIY6AVYggiyQ8eqmyWEvaXO8BUp3WK4fFAKk7JSuGJQCpk9u9nwFcaEuGAmiAFAkc9yMTDRX0ERGQhkAu/62TYBiAF2+9k2C5gFkJ6efvERh6GS46dYl1/K2vyjrNld0jQfQo+u0UzMTOYrkzOYNKgnQ/vYeEbGhJtgJgh/VxNtpexMYKGq1jc7gEg/4PfAl1W14YyDqc4D5gHk5OS0dmzTQnVtPT//5y6Wf3KYTw5WAtAtJpIJmcncfVk6kwalMLxfgg1fYUyYC2aCKAbSfJZTgf2tlJ0JPOq7QkQSgL8D/6Gq64ISYZj64wd7eX7FbiYPTuFbnx3GpEEpXDqghw1fYYxpJpgJYj0wREQygX04SeCLLQuJyDAgCVjrsy4GWAT8TlX/HMQYw05NXQPzVuYzMTOZVx683OtwTKOGeqitgtqTzX/W+FnX9LPlOt993HXRsTDsBhh5O/S+xOuzNJ1M0BKEqtaJyGPA2zi3ub6kqttE5BkgV1WXuEXvBhaoqm8T0V3AVCBFRO53192vqpuCFW+4WLSxmIPHqvnRnaO9DqXzqK+9iIu2z8W75kTzC7nvPvU15x9XRDTExEF0HER39fnZFbomOsvHD8N7P4L3/gd6j3ASxajbIWVQ2/+eTMiR5tflzisnJ0dzc3O9DqNDq29QrvnpCuJjo1ny2OTw6HQ+WQale6BsD1QUuxdpfxftqtYv3g115/+5UbFnXrSj43xeXVtsj3Mv9l39XPC7+SnfFSIDHJ6k8hBsfwO2vQ573Yp639FOohh5GyRlnP/5mZAhIhtUNcffNnuSOows/fgABSVVvHDvuNBJDqpQedBJAI2JoDT/9PuTZWfuc8YF2L1ox/aA+L4BXrT9fXP3uXhHdKDRZ+P7wMRZzqtiH2xfDFtfh3eedl79x51OFj1SvY7WdCBWgwgTqsr1P19FbX0Dy564qnPNuFZfBxVFzoW/MRE0JoCyAudbfiOJhMQ0SMqE5CxIzjz9PjENYrpDqCTHi1VWCNsWOTWLA5uddWkTnWaokbc6ydKEvLPVICxBhIl3PznEV17O5aefH8Md4zvgt8Tak87FvnRPi0SQ7yQH32aeqFj3op95+mfj+8T0wJtezGklu51EsXURHN4GCAycDKNug+G3QPdeXkdogsQSRJhTVe54fg2Hjp1ixbemeXc7q29/QGk+lBacfl95oHnZ2B7+awHJmdC9L0TYLblBc2Sn0wS17XU4+ilIBGROdWoWw2+CuGSvIzRtyBJEmFuXX8LMeev4/i0juW9SRvA+qGV/QMuaQHWLkVK693W//WedWSOwi5D3VOHQNrdm8brzbxkRBVnTnT6LS250Ernp1C66k1pE/gK8BLzp74lm07HNWZ5Hz+5d+HxO2rkLn8uF9geMur1FIsiAmG4XH48JHhHoO8p5Xf2fcGCT02exdREsfgQiY2DwZ5yaxbAZ0CXe64hNGwv0LqbngQeAX4jIn4GXVfWT4IVl2sqW4nJW7TrKk9dfEvi8zk39Afln3hnktz8gw7n4Z023/oBQJQL9xzqvz3wP9m1wm6EWwc6lzt/BkOucLwJDPuvc/WU6vYAShKq+A7wjIj1wHmxbJiJFwIvAH1S1Nogxmoswd/luEmKjuGdii8EMG/sDmmoCBafft9Yf0D/buQA0dQxnWX9AOBKB1Bzndd1/QdEHTjPUtsWwY4nz3MawGU7NYvBnnKe5TacUcB+EiKQA9wL34Yyp9ApwJXCpqk4LVoCBsj6IFmpPUrB7B0//bin3DYNr+rq1gvJCKNsLpyqal2/sDzijY9j6A0yAGuqh8H2nZrFjCVSVQEy801cx6nanhhllU812NBfdSS0irwOX4Iys+rKqHvDZltvawdtT2CWI+jo4ts+94Bf6XPwLnZ/HDzUvHxXrNPkkDoSkgc7PpkSQYf0Bpm3V18Ge95yaxY6/QnUFxCbC8M85D+RlXmXNjx1EWySIq1X1jLkaOpKQSxCqcOKIc+EvK4TygtMX/7JCZ9gI39HRJQISUp2Lf9JAKrr05+nVJxg9ajQP3DgNuvW2piDjjboayF/u1Cw++TvUVELXZBhxs9MMlXFlx3ryPMy0xVAbw0Xko8YpP0UkCbhbVee2VZBhqbqi+UXf92f53uZ3BIFzkU8aCKmXwaV3Nq8N9Eht9o3sx4s/5m9axLevvxrirQ3YeCgqBoZ+1nnVVkPeO07NYsufYcPLzt/1iFucZqi0y+2LTAcSaA1ik6pmt1i3UVXHtrZPe+uQNYjaaueuH381gPLCM8cJ6pLQ/KLf9DPDaR4K8M6Qw8equfJHy7lj3AD++3YbtdV0UDVVsOttp2ax6x9QVw3x/Z1hPkbe7nSC27AoQdcWNYgIEZHGIblFJBJnGtDw1lAPx/b7rwGUFZx5N1BkjHOhT8qAAePPTARdk9rkP8SvV++hrr6Br021IZ1NBxYT5/RHjLwNTlXCzrecmsX6+bBuLvRId5LFqNuhX7YlCw8EmiDeBl4TkRdwpg19GHgraFF1FKrOnRhn1AAKTvcDNPjc4SsRkDDAudgPuvrM2kA73BJaXlXDH9YV8rnR/cnoaR3PppPoEg+jP++8qivgk6VOslg3F9b8wrmhYuRtTs2iz0hLFu0k0CamCOBrwDU4c03/A5jfcg5pL11wE1N9rTPeTMuLf2NtoPZE8/JxPf00AbnNQAmpnt/G9/N3dvGzdz7lzcenMLxfgqexGHPRqkrhk785zVB7Vjo3ZvQcenrio17DvI6w07OxmM7m2AF41mcqxpjuzS/6vokgMR26dG+zmNvaiVN1TP6fd8kZmMT8L1/mdTjGtK0TR92JjxZBwWpAofdIZ8TZkTZL3oVqi7GYhgD/DYwAmm6JUdWsNonQS937wJ2/cZNAhvNQWCetvr764V7Kq2qZPX2w16EY0/a69YTLvuq8KsP0nCcAABUzSURBVA86yWLr6/DufzmvfmNO3zYLTh+h1rf42eCzXOdn3bnK1kNDQxuWdcsHFMNZyvbLhi8tbvNfeaB9EL8BngJ+BkzHGZepc15FW4qIcKqqndypunrmrcxnUlYK49KTvA7HmOCK7wsTv+a8KoqdYT62vQ7vPNV+MUiEMyBlRKT7M8q5njRbF+mUa7Yc6ZSLiPJTNtp/2abjt1znLgdp2thAE0RXVf2neydTIfC0iKzCSRqmA/jLhn0crjzFs3dln7uwMaGkRypc8ZjzKiuAwzv8X0SbLrD+Lth+1kdEnb1sJ21pOB+BJohqt6N6l4g8BuwDegcvLHM+6uobeOG93YxJ7cHkwSleh2OMd5IygvZtOhwFes/lN4A44OvAeJxB+74crKDM+fn7xwfYW1rF7OmDkTD4VmOMaR/nrEG4D8XdparfAo7j9D+YDqKhQZm7fDdDenfn2uF9vA7HGBNCzlmDcJ91GC/21bRD+ucnh9l5qJLZ0wcREWH/RMaYthNoH8RG4A13NrmmJ8dU9fWgRGUCoqr8cnkeqUlduWl0f6/DMcaEmED7IJKBEuBq4Cb39blz7SQiM0Rkp4jkiciTfrb/TEQ2ua9PRaTcZ9uXRWSX+7L+Dj/W7i5hc1E5D181iKhIGwHTGNO2Ap1y9Lz7Hdy+iznAtUAxsF5Elqjqdp/jPuFT/l+Ase77ZJxbaHNwxn7a4O7bYvjT8DZnRR694rtw5/hUr0MxxoSgQJ+k/g3OhboZVf3KWXabAOSpar57jAXALcD2VsrfzennKj4LLFPVUnffZcAM4NVA4g0HG/eW8X5eCf9+wyXERttkK8aYthdoH8TffN7HArfhzEt9NgOAIp/lYmCiv4IiMhDIBBpnrfO37wA/+80CZgGkp6efI5zQMnfFbnp0jeaLEwd6HYoxJkQF2sT0F99lEXkVeOccu/m7paa1kQFnAgt9RocNaF9VnQfMA2ewvnPEEzJ2Hqxk2fZDPH7NELp3CTTHG2PM+bnQns0hwLm+shcDaT7LqbRe65hJ8+aj89k37Dy/Io+4mEjuvyLD61CMMSEsoAQhIpUicqzxBfwV+PY5dlsPDBGRTBGJwUkCS/wcexiQBKz1Wf02cJ2IJLnzX1/nrgt7e0uqWLJ5P/dMTCepm03qZ4wJnkCbmOLP98CqWueO2/Q2EAm8pKrbROQZIFdVG5PF3cAC9ZmYQlVLReT7OEkG4JnGDutw98LK3URFRPDglM4/0roxpmML9C6m24B3VbXCXU4EpqnqWQcgV9WlwNIW677bYvnpVvZ9CXgpkPjCxaFj1SzMLebOnFT6JMSeewdjjLkIgfZBPNWYHABUtRwb6rvdzV+VT11DAw9PtZmzjDHBF2iC8FfObp9pR2Unanjlg73cPKY/6SlxXodjjAkDgSaIXBF5VkQGiUiWiPwM2BDMwExzL68poKqmnkem2XSixpj2EWiC+BegBvgT8BpwEng0WEGZ5o6fquPlNQVcO6IPw/qe9/0CxhhzQQK9i+kEcMZge6Z9/PGDQipO1vLodKs9GGPaT6DPQSxz71xqXE4SEXsuoR1U19bz4qo9XDm4J9lpiefewRhj2kigTUw93TuXAHBHVbU5qdvBwg3FHKk8xezpdueSMaZ9BZogGkSkaWgNEcmg9XGVTBupq2/ghfd2MzY9kUlZKV6HY4wJM4Heqvp/gdUi8p67PBV3FFUTPH/dsp/ispM8fdNIbMZXY0x7C7ST+i0RycFJCpuAN3DuZDJB0tCgzF2+m0v6xnP1JdaaZ4xpf4EOtfEg8DjOqKqbgMtxBte7OnihhbdlOw6x6/Bxfj4zm4gIqz0YY9pfoH0QjwOXAYWqOh1natAjQYsqzKkqc5fnMTAljhsv7ed1OMaYMBVogqhW1WoAEemiqp8Aw4IXVnh7P6+EzcUVPHzVIKIiL3TKDmOMuTiBdlIXu89BLAaWiUgZNoFP0MxZnkefhC7cPu6MWVaNMabdBNpJfZv79mkRWQ70AN4KWlRhbENhGWvzS/iPG4fTJSrS63CMMWHsvEdkVdX3zl3KXKjnV+SRFBfN3RPONaOrMcYElzVwdyA7DhzjnR2HeWByJt262GjqxhhvWYLoQJ5fsZtuMZF8eVKG16EYY4wliI6i4OgJ/rZlP/dOGkiPuGivwzHGGEsQHcWvVu4mKjKCr16Z6XUoxhgDWILoEA5WVLNwQzFfyEmjd3ys1+EYYwxgCaJDeHFVPg0Ks6ZmeR2KMcY0sQThsdITNfzxg73ckt2ftOQ4r8MxxpgmliA89vL7e6iuq2f2NJsQyBjTsViC8FBldS0vryngsyP6Mrh3vNfhGGNMM0FNECIyQ0R2ikieiDzZSpm7RGS7iGwTkT/6rP+Ru26HiPxCQnDGnFc+2Mux6jqbTtQY0yEF7XFdEYkE5gDXAsXAehFZoqrbfcoMAb4DTFbVMhHp7a6/ApgMjHaLrgauAlYEK972Vl1bz/xVe5gypCejUxO9DscYY84QzBrEBCBPVfNVtQZYANzSosxDwBxVLQNQ1cPuegVigRigCxANHApirO3uz7lFHD1+ikenD/Y6FGOM8SuYCWIAUOSzXOyu8zUUGCoi74vIOhGZAaCqa4HlwAH39baq7mj5ASIyS0RyRST3yJHOM39RbX0DL7yXz/iBSUzMTPY6HGOM8SuYCcJfn4G2WI4ChgDTgLuB+SKSKCKDgeE4U5wOAK4WkalnHEx1nqrmqGpOr1692jT4YHpj0372lZ/k0emDCMGuFWNMiAhmgigG0nyWUzlzkqFi4A1VrVXVPcBOnIRxG7BOVY+r6nHgTZx5sDu9+gZl7oo8Lukbz/Rhvb0OxxhjWhXMBLEeGCIimSISA8wElrQosxiYDiAiPXGanPKBvcBVIhIlItE4HdRnNDF1Rv/YdpD8Iyd4dPpgqz0YYzq0oCUIVa0DHgPexrm4v6aq20TkGRG52S32NlAiIttx+hy+paolwEJgN/AxsBnYrKp/DVas7UVVmbMij4yUOG64tJ/X4RhjzFkFdVYaVV0KLG2x7rs+7xX4V/flW6Ye+FowY/PCyl1H2brvGP9zx6VERljtwRjTsdmT1O1ozvI8+vWI5baxqV6HYowx52QJop2sLyjlwz2lPDQli5go+7UbYzo+u1K1k7nL80juFsPMCWnnLmyMMR2AJYh2sG1/Bct3HuErkzOIiwlqt48xxrQZSxDtYO6K3XTvEsV9kzK8DsUYYwJmCSLI8o8cZ+nHB7hv0kB6dI32OhxjjAmYJYgge+G93cRERvCVyZleh2KMMefFEkQQ7Ss/yesf7WPmZWn0iu/idTjGGHNeLEEE0Ysr8wF4aGqWx5EYY8z5swQRJEePn2LB+r3cOnYAqUlxXodjjDHnzRJEkPzm/T2cqmvg4atsOlFjTOdkCSIIjlXX8rs1hVw/qi+De3f3OhxjjLkgliCC4PdrC6k8VcfsaTadqDGm87IE0cZO1tTz0uo9XDW0F6MG9PA6HGOMuWCWINrYn9bvpeREDY9Ot9qDMaZzswTRhmrqGpi3Mp/LMpKYkJnsdTjGGHNRLEG0ocWb9rG/oprZVnswxoQASxBtpL5BeWHFbkb0S2Da0F5eh2OMMRfNEkQbeWvrQfKPnuDR6YMRselEjTGdnyWINqCqzFmeR1bPbswY1dfrcIwxpk1YgmgDKz49wvYDx3h42iAiI6z2YIwJDZYg2sDc5Xn07xHLrdkDvA7FGGPajCWIi/ThnlLWF5Qxa2oWMVH26zTGhA67ol2kOcvzSOkWwxcuS/c6FGOMaVOWIC7C1n0VvPfpEb5yZSZdYyK9DscYY9pUUBOEiMwQkZ0ikiciT7ZS5i4R2S4i20Tkjz7r00XkHyKyw92eEcxYL8TcFXnEd4nivkkDvQ7FGGPaXFSwDiwikcAc4FqgGFgvIktUdbtPmSHAd4DJqlomIr19DvE74AequkxEugMNwYr1QuQdPs6bWw8ye9ogEmKjvQ7HGGPaXDBrEBOAPFXNV9UaYAFwS4syDwFzVLUMQFUPA4jICCBKVZe564+ralUQYz1vL7y3my5RETwwOdPrUIwxJiiCmSAGAEU+y8XuOl9DgaEi8r6IrBORGT7ry0XkdRHZKCI/dmskzYjILBHJFZHcI0eOBOUk/Ckuq2Lxxn3MvCydnt27tNvnGmNMewpmgvD3xJi2WI4ChgDTgLuB+SKS6K6fAnwTuAzIAu4/42Cq81Q1R1VzevVqv/GPXlyZD8CsqVnt9pnGGNPegpkgioE0n+VUYL+fMm+oaq2q7gF24iSMYmCj2zxVBywGxgUx1oAdqTzFgvVF3D5uAP0Tu3odjjHGBE0wE8R6YIiIZIpIDDATWNKizGJgOoCI9MRpWsp3900SkcZqwdXAdjqAl97fQ019Aw9fNcjrUIwxJqiCliDcb/6PAW8DO4DXVHWbiDwjIje7xd4GSkRkO7Ac+JaqlqhqPU7z0j9F5GOc5qoXgxVroCpO1vL7tYXccGk/snp19zocY4wJqqDd5gqgqkuBpS3WfdfnvQL/6r5a7rsMGB3M+M7X79cWcPxUHbOnWe3BGBP67EnqAFXV1PHS+wVMH9aLkf17eB2OMcYEnSWIAC34sIjSEzU8atOJGmPChCWIANTUNTBvZT4TMpPJyUj2OhxjjGkXliACsGhjMQePVVvtwRgTVixBnEN9g/L8it2MGpDA1CE9vQ7HGGPajSWIc1j68QEKSqp4dNpgRGw6UWNM+LAEcRaqypzleQzq1Y3PjuzrdTjGGNOuLEGcxfKdh/nkYCWPTBtMRITVHowx4cUSRCtUlV++m8eAxK7ckt3f63CMMabdWYJoxQd7SvlobzlfuyqL6Ej7NRljwo9d+VoxZ3kePbvHcFdO2rkLG2NMCLIE4ceW4nJW7TrKV6/MIjb6jHmKjDEmLFiC8GPu8t3Ex0Zx7+XpXodijDGesQTRwq5Dlby17SD3X5FBfGy01+EYY4xnLEG08Px7u+kaHckDkzO9DsUYYzxlCcJHUWkVb2zaz90T0knuFuN1OMYY4ylLED5+tXI3EQIPTbXagzHGWIJwHT5WzWu5xdwxLpV+Pbp6HY4xxnjOEoTr16v3UFffwNeusulEjTEGLEEAUF5Vwx/WFXLj6P5k9uzmdTjGGNMhWIIAfrumkBM19cyeZrUHY4xpFPYJ4sSpOn6zZg/XXNKb4f0SvA7HGGM6jCivA/Da8VN1XDEoha9emeV1KMYY06GEfYLokxDL3HvGex2GMcZ0OEFtYhKRGSKyU0TyROTJVsrcJSLbRWSbiPyxxbYEEdknIr8MZpzGGGPOFLQahIhEAnOAa4FiYL2ILFHV7T5lhgDfASarapmI9G5xmO8D7wUrRmOMMa0LZg1iApCnqvmqWgMsAG5pUeYhYI6qlgGo6uHGDSIyHugD/COIMRpjjGlFMBPEAKDIZ7nYXedrKDBURN4XkXUiMgNARCKAnwLfCmJ8xhhjziKYndTiZ536+fwhwDQgFVglIqOAe4Glqlok4u8w7geIzAJmAaSn29wNxhjTloKZIIoB3/k6U4H9fsqsU9VaYI+I7MRJGJOAKSIyG+gOxIjIcVVt1tGtqvOAeQA5OTktk48xxpiLEMwmpvXAEBHJFJEYYCawpEWZxcB0ABHpidPklK+q96hquqpmAN8EftcyORhjjAmuoCUIVa0DHgPeBnYAr6nqNhF5RkRudou9DZSIyHZgOfAtVS0JVkzGGGMCJ6qh0TIjIkeAwos4RE/gaBuF01mE2zmH2/mCnXO4uJhzHqiqvfxtCJkEcbFEJFdVc7yOoz2F2zmH2/mCnXO4CNY5h/1gfcYYY/yzBGGMMcYvSxCnzfM6AA+E2zmH2/mCnXO4CMo5Wx+EMcYYv6wGYYwxxi9LEMYYY/wK+wQRyJwVoUREXhKRwyKy1etY2ouIpInIchHZ4c478rjXMQWbiMSKyIcistk95+95HVN7EJFIEdkoIn/zOpb2IiIFIvKxiGwSkdw2PXY490G4c1Z8is+cFcDdvnNWhBoRmQocxxm+ZJTX8bQHEekH9FPVj0QkHtgA3Bri/84CdFPV4yISDawGHlfVdR6HFlQi8q9ADpCgqp/zOp72ICIFQI6qtvnDgeFegwhkzoqQoqorgVKv42hPqnpAVT9y31fiDP3Scuj5kKKO4+5itPsK6W+DIpIK3AjM9zqWUBHuCSKQOStMCBGRDGAs8IG3kQSf29yyCTgMLFPVUD/n54B/Axq8DqSdKfAPEdngToHQZsI9QQQyZ4UJESLSHfgL8A1VPeZ1PMGmqvWqmo0z1P4Ed66VkCQinwMOq+oGr2PxwGRVHQdcDzzqNiO3iXBPEIHMWWFCgNsO/xfgFVV93et42pOqlgMrgBkehxJMk4Gb3fb4BcDVIvIHb0NqH6q63/15GFiE03TeJsI9QQQyZ4Xp5NwO218DO1T1Wa/jaQ8i0ktEEt33XYHPAJ94G1XwqOp3VDXVnUNmJvCuqt7rcVhBJyLd3BsvEJFuwHVAm92hGNYJorU5K7yNKrhE5FVgLTBMRIpF5Ktex9QOJgP34Xyr3OS+bvA6qCDrBywXkS04X4SWqWrY3PoZRvoAq0VkM/Ah8HdVfautDh7Wt7kaY4xpXVjXIIwxxrTOEoQxxhi/LEEYY4zxyxKEMcYYvyxBGGOM8csShDEdgIhMC6cRSE3nYAnCGGOMX5YgjDkPInKvO8/CJhH5lTsg3nER+amIfCQi/xSRXm7ZbBFZJyJbRGSRiCS56weLyDvuXA0ficgg9/DdRWShiHwiIq+4T4Ab4xlLEMYESESGA1/AGRwtG6gH7gG6AR+5A6a9Bzzl7vI74NuqOhr42Gf9K8AcVR0DXAEccNePBb4BjACycJ4AN8YzUV4HYEwncg0wHljvfrnvijOUdgPwJ7fMH4DXRaQHkKiq77nrfwv82R03Z4CqLgJQ1WoA93gfqmqxu7wJyMCZ6McYT1iCMCZwAvxWVb/TbKXIf7Yod7bxa87WbHTK53099v/TeMyamIwJ3D+BO0WkN4CIJIvIQJz/R3e6Zb4IrFbVCqBMRKa46+8D3nPnoSgWkVvdY3QRkbh2PQtjAmTfUIwJkKpuF5H/wJm9KwKoBR4FTgAjRWQDUIHTTwHwZeAFNwHkAw+46+8DfiUiz7jH+Hw7noYxAbPRXI25SCJyXFW7ex2HMW3NmpiMMcb4ZTUIY4wxflkNwhhjjF+WIIwxxvhlCcIYY4xfliCMMcb4ZQnCGGOMX/8fgxzWmC1bFcQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(history.history.keys())\n",
    "#summarize history for accuracy\n",
    "plt.plot(history.history['accuracy'])\n",
    "plt.plot(history.history['val_accuracy'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "630/630 [==============================] - 7s 11ms/step - loss: 0.8105 - accuracy: 0.7046\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.8105441331863403, 0.704609751701355]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model1.evaluate(padded_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred=np.argmax(model1.predict(padded_test), axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.76      0.75      0.75      6717\n",
      "           1       0.61      0.55      0.58      6718\n",
      "           2       0.73      0.82      0.77      6718\n",
      "\n",
      "    accuracy                           0.70     20153\n",
      "   macro avg       0.70      0.70      0.70     20153\n",
      "weighted avg       0.70      0.70      0.70     20153\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(metrics.classification_report(y_test,y_pred))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Predicitng a single review"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Text after initial clean up:\n",
      "  product different order product know pure oil colour yellow instead orange\n"
     ]
    }
   ],
   "source": [
    "string=\"This product is different. I have ordered this product before and I know that pure oil's colour is yellow instead of orange.\"\n",
    "\n",
    "str_clean=(text_cleanup(string))\n",
    "\n",
    "print(\"Text after initial clean up:\\n \",(str_clean))\n",
    "str_clean=text_to_word_sequence(str_clean)\n",
    "encoded_test_str=t.texts_to_sequences(str_clean)\n",
    "encoded_test_str=np.array(encoded_test_str)\n",
    "encoded_test_str=encoded_test_str.reshape(1,11)\n",
    "padded_test_str=pad_sequences(encoded_test_str, padding='post', maxlen=padded_train.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of final processed data:  (1, 510)\n"
     ]
    }
   ],
   "source": [
    "print(\"Shape of final processed data: \", padded_test_str.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.27, 0.26, 0.47]], dtype=float32)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predicting probabilities of all classes from a few input images \n",
    "y_prob = model1.predict(padded_test_str)\n",
    "y_prob.round(2)\n",
    "\n",
    "# This review is classified as 1, i.e. Good"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import backend as K\n",
    "K.clear_session()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using CNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "model2 = Sequential([\n",
    "  Embedding(input_dim=50001, output_dim=16,input_length=padded_train.shape[1]),\n",
    "  Dropout(0.5),\n",
    "    Conv1D(filters=32, kernel_size=3, strides=1, padding=\"valid\", activation='relu'),\n",
    "    MaxPooling1D(pool_size=2),\n",
    "    Conv1D(filters=16, kernel_size=3, strides=1, padding=\"valid\", activation='relu'),\n",
    "    MaxPooling1D(), \n",
    "    Flatten(),\n",
    "  Dense(32, activation='relu'),\n",
    "  Dropout(0.5),\n",
    "  Dense(3, activation='softmax')\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding (Embedding)        (None, 510, 16)           800016    \n",
      "_________________________________________________________________\n",
      "dropout (Dropout)            (None, 510, 16)           0         \n",
      "_________________________________________________________________\n",
      "conv1d (Conv1D)              (None, 508, 32)           1568      \n",
      "_________________________________________________________________\n",
      "max_pooling1d (MaxPooling1D) (None, 254, 32)           0         \n",
      "_________________________________________________________________\n",
      "conv1d_1 (Conv1D)            (None, 252, 16)           1552      \n",
      "_________________________________________________________________\n",
      "max_pooling1d_1 (MaxPooling1 (None, 126, 16)           0         \n",
      "_________________________________________________________________\n",
      "flatten (Flatten)            (None, 2016)              0         \n",
      "_________________________________________________________________\n",
      "dense (Dense)                (None, 32)                64544     \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 32)                0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 3)                 99        \n",
      "=================================================================\n",
      "Total params: 867,779\n",
      "Trainable params: 867,779\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model2.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "model2.compile(optimizer='adam',\n",
    "              loss=\"sparse_categorical_crossentropy\",\n",
    "              metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/8\n",
      "504/504 [==============================] - 79s 157ms/step - loss: 0.8971 - accuracy: 0.5561 - val_loss: 0.7017 - val_accuracy: 0.6773\n",
      "Epoch 2/8\n",
      "504/504 [==============================] - 87s 172ms/step - loss: 0.7054 - accuracy: 0.6825 - val_loss: 0.6945 - val_accuracy: 0.6742\n",
      "Epoch 3/8\n",
      "504/504 [==============================] - 89s 177ms/step - loss: 0.6567 - accuracy: 0.7101 - val_loss: 0.6877 - val_accuracy: 0.6811\n",
      "Epoch 4/8\n",
      "504/504 [==============================] - 86s 171ms/step - loss: 0.6237 - accuracy: 0.7266 - val_loss: 0.6757 - val_accuracy: 0.6867\n",
      "Epoch 5/8\n",
      "504/504 [==============================] - 87s 172ms/step - loss: 0.5933 - accuracy: 0.7435 - val_loss: 0.7255 - val_accuracy: 0.6721\n",
      "Epoch 6/8\n",
      "504/504 [==============================] - 84s 167ms/step - loss: 0.5701 - accuracy: 0.7553 - val_loss: 0.7141 - val_accuracy: 0.6836\n",
      "Epoch 7/8\n",
      "504/504 [==============================] - 74s 146ms/step - loss: 0.5423 - accuracy: 0.7727 - val_loss: 0.6916 - val_accuracy: 0.6971\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "early_stopping = EarlyStopping(patience=3)\n",
    "\n",
    "\n",
    "result=model2.fit(padded_train, y_train, epochs=8, batch_size=128, validation_data=(padded_val, y_val), callbacks=[early_stopping])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['loss', 'accuracy', 'val_loss', 'val_accuracy'])\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(result.history.keys())\n",
    "#summarize history for accuracy\n",
    "plt.plot(result.history['accuracy'])\n",
    "plt.plot(result.history['val_accuracy'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "630/630 [==============================] - 6s 9ms/step - loss: 0.7028 - accuracy: 0.6962\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.7027720212936401, 0.6961742639541626]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model2.evaluate(padded_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_pred2=np.argmax(model2.predict(padded_test), axis=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.81      0.65      0.72      6717\n",
      "           1       0.56      0.63      0.59      6718\n",
      "           2       0.76      0.81      0.78      6718\n",
      "\n",
      "    accuracy                           0.70     20153\n",
      "   macro avg       0.71      0.70      0.70     20153\n",
      "weighted avg       0.71      0.70      0.70     20153\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(metrics.classification_report(y_test,y_pred2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Text Classification using Keras Embedding - with CNN and with Dense NN gives approx same accuracy, precision and recall. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}