Sentiment Analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sentiment Analysis with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extracted from [Real Python](https://realpython.com/python-keras-text-classification/). First, we will study the background and then dive into defining the base model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                                            sentence  label source\n",
      "0                           Wow... Loved this place.      1   yelp\n",
      "1                                 Crust is not good.      0   yelp\n",
      "2          Not tasty and the texture was just nasty.      0   yelp\n",
      "3  Stopped by during the late May bank holiday of...      1   yelp\n",
      "4  The selection on the menu was great and so wer...      1   yelp\n"
     ]
    }
   ],
   "source": [
    "filepath_dict = {'yelp':   'data/yelp_labelled.txt',\n",
    "                 'amazon': 'data/amazon_cells_labelled.txt',\n",
    "                 'imdb':   'data/imdb_labelled.txt'}\n",
    "\n",
    "df_list = []\n",
    "for source, filepath in filepath_dict.items():\n",
    "    df = pd.read_csv(filepath, names=['sentence', 'label'], sep='\\t')\n",
    "    df['source'] = source  # Add another column filled with the source name\n",
    "    df_list.append(df)\n",
    "\n",
    "df = pd.concat(df_list)\n",
    "print(df.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentences = ['John likes ice cream', 'John hates chocolate.']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "                dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "                lowercase=False, max_df=1.0, max_features=None, min_df=0,\n",
       "                ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
       "                strip_accents=None, token_pattern='(?u)\\\\b\\\\w\\\\w+\\\\b',\n",
       "                tokenizer=None, vocabulary=None)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stopwords_list = [\"i\", \"me\", \"my\", \"myself\", \"we\", \"our\", \"ours\", \"ourselves\", \"you\", \"your\", \"yours\", \"yourself\", \"yourselves\", \"he\", \"him\", \"his\", \"himself\", \"she\", \"her\", \"hers\", \"herself\", \"it\", \"its\", \"itself\", \"they\", \"them\", \"their\", \"theirs\", \"themselves\", \"what\", \"which\", \"who\", \"whom\", \"that\", \"these\", \"those\", \"am\", \"is\", \"are\", \"was\", \"were\", \"be\", \"been\", \"being\", \"have\", \"has\", \"had\", \"having\", \"do\", \"does\", \"did\", \"doing\", \"a\", \"an\", \"the\", \"and\", \"but\", \"if\", \"or\", \"because\", \"as\", \"until\", \"while\", \"of\", \"at\", \"by\", \"for\", \"with\", \"against\", \"into\", \"through\", \"during\", \"before\", \"after\", \"above\", \"below\", \"to\", \"from\", \"up\", \"down\", \"in\", \"out\", \"on\", \"off\", \"over\", \"under\", \"again\", \"further\", \"then\", \"once\", \"here\", \"there\", \"when\", \"why\", \"how\", \"all\", \"any\", \"both\", \"each\", \"few\", \"more\", \"most\", \"other\", \"some\", \"such\", \"no\", \"nor\", \"not\", \"only\", \"own\", \"same\", \"so\", \"than\", \"too\", \"very\", \"s\", \"t\", \"don\", \"should\", \"now\"]from sklearn.feature_extraction.text import CountVectorizer\n",
    "vectorizer = CountVectorizer(min_df=0, lowercase=False)\n",
    "vectorizer.fit(sentences)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'John': 0, 'likes': 5, 'ice': 4, 'cream': 2, 'hates': 3, 'chocolate': 1}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vectorizer.vocabulary_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 1, 0, 1, 1],\n",
       "       [1, 1, 0, 1, 0, 0]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vectorizer.transform(sentences).toarray()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining Base Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_yelp = df[df['source'] == 'yelp']\n",
    "sentences = df_yelp['sentence'].values\n",
    "y = df_yelp['label'].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentences_train, sentences_test, y_train, y_test = train_test_split(sentences, y, test_size=0.25, random_state=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we will use again on the previous BOW model to vectorize the sentences. You can use again the CountVectorizer for this task. Since you might not have the testing data available during training, you can create the vocabulary using only the training data. Using this vocabulary, you can create the feature vectors for each sentence of the training and testing set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CountVectorizer(analyzer='word', binary=False, decode_error='strict',\n",
       "                dtype=<class 'numpy.int64'>, encoding='utf-8', input='content',\n",
       "                lowercase=True, max_df=1.0, max_features=None, min_df=1,\n",
       "                ngram_range=(1, 1), preprocessor=None, stop_words=None,\n",
       "                strip_accents=None, token_pattern='(?u)\\\\b\\\\w\\\\w+\\\\b',\n",
       "                tokenizer=None, vocabulary=None)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vectorizer = CountVectorizer()\n",
    "vectorizer.fit(sentences_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = vectorizer.transform(sentences_train)\n",
    "X_test  = vectorizer.transform(sentences_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(750, 1714)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train\n",
    "X_train.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that the resulting feature vectors have 750 samples which are the number of training samples we have after the train-test split. Each sample has 1714 dimensions which is the size of the vocabulary. Also, you can see that we get a sparse matrix. This is a data type that is optimized for matrices with only a few non-zero elements, which only keeps track of the non-zero elements reducing the memory load."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`CountVectorizer` performs tokenization which separates the sentences into a set of **tokens** as you saw previously in the vocabulary. It additionally removes punctuation and special characters and can apply other preprocessing to each word. If you want, you can use a custom tokenizer from the `NLTK` library with the CountVectorizer or use any number of the customizations which you can explore to improve the performance of your model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LogisticRegression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages/sklearn/linear_model/logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "classifier = LogisticRegression()\n",
    "classifier.fit(X_train, y_train)\n",
    "score = classifier.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.796\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy:\", score)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can see that the logistic regression reached an impressive 79.6%, but let’s have a look how this model performs on the other data sets that we have. In this script, we perform and evaluate the whole process for each data set that we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for yelp data: 0.7960\n",
      "Accuracy for amazon data: 0.7960\n",
      "Accuracy for imdb data: 0.7487\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages/sklearn/linear_model/logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "/home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages/sklearn/linear_model/logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n",
      "/home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages/sklearn/linear_model/logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n",
      "  FutureWarning)\n"
     ]
    }
   ],
   "source": [
    "for source in df['source'].unique():\n",
    "    df_source = df[df['source'] == source]\n",
    "    sentences = df_source['sentence'].values\n",
    "    y = df_source['label'].values\n",
    "\n",
    "    sentences_train, sentences_test, y_train, y_test = train_test_split(\n",
    "        sentences, y, test_size=0.25, random_state=1000)\n",
    "\n",
    "    vectorizer = CountVectorizer()\n",
    "    vectorizer.fit(sentences_train)\n",
    "    X_train = vectorizer.transform(sentences_train)\n",
    "    X_test  = vectorizer.transform(sentences_test)\n",
    "\n",
    "    classifier = LogisticRegression()\n",
    "    classifier.fit(X_train, y_train)\n",
    "    score = classifier.score(X_test, y_test)\n",
    "    print('Accuracy for {} data: {:.4f}'.format(source, score))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: keras in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (2.3.0)\n",
      "Requirement already satisfied: six>=1.9.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from keras) (1.12.0)\n",
      "Requirement already satisfied: pyyaml in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from keras) (5.1.1)\n",
      "Requirement already satisfied: keras-applications>=1.0.6 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from keras) (1.0.8)\n",
      "Requirement already satisfied: numpy>=1.9.1 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from keras) (1.16.4)\n",
      "Requirement already satisfied: keras-preprocessing>=1.0.5 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from keras) (1.1.0)\n",
      "Requirement already satisfied: scipy>=0.14 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from keras) (1.3.0)\n",
      "Requirement already satisfied: h5py in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from keras) (2.9.0)\n",
      "Requirement already satisfied: tensorflow in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (2.0.0)\n",
      "Requirement already satisfied: tensorboard<2.1.0,>=2.0.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (2.0.0)\n",
      "Requirement already satisfied: keras-preprocessing>=1.0.5 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (1.1.0)\n",
      "Requirement already satisfied: absl-py>=0.7.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (0.8.0)\n",
      "Requirement already satisfied: google-pasta>=0.1.6 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (0.1.7)\n",
      "Requirement already satisfied: gast==0.2.2 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (0.2.2)\n",
      "Requirement already satisfied: numpy<2.0,>=1.16.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (1.16.4)\n",
      "Requirement already satisfied: keras-applications>=1.0.8 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (1.0.8)\n",
      "Requirement already satisfied: six>=1.10.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (1.12.0)\n",
      "Requirement already satisfied: opt-einsum>=2.3.2 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (3.1.0)\n",
      "Requirement already satisfied: termcolor>=1.1.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (1.1.0)\n",
      "Requirement already satisfied: grpcio>=1.8.6 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (1.24.0)\n",
      "Requirement already satisfied: wrapt>=1.11.1 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (1.11.2)\n",
      "Requirement already satisfied: tensorflow-estimator<2.1.0,>=2.0.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (2.0.0)\n",
      "Requirement already satisfied: protobuf>=3.6.1 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (3.9.2)\n",
      "Requirement already satisfied: astor>=0.6.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (0.8.0)\n",
      "Requirement already satisfied: wheel>=0.26 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorflow) (0.33.4)\n",
      "Requirement already satisfied: werkzeug>=0.11.15 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (0.15.4)\n",
      "Requirement already satisfied: setuptools>=41.0.0 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (41.0.1)\n",
      "Requirement already satisfied: markdown>=2.6.8 in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from tensorboard<2.1.0,>=2.0.0->tensorflow) (3.1.1)\n",
      "Requirement already satisfied: h5py in /home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages (from keras-applications>=1.0.8->tensorflow) (2.9.0)\n"
     ]
    }
   ],
   "source": [
    "!pip install keras\n",
    "!pip install tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Sequential\n",
    "from keras import layers\n",
    "\n",
    "input_dim = X_train.shape[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = Sequential()\n",
    "model.add(layers.Dense(10, input_dim=input_dim, activation='relu'))\n",
    "model.add(layers.Dense(1, activation='sigmoid'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_1\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "dense_1 (Dense)              (None, 10)                25060     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 1)                 11        \n",
      "=================================================================\n",
      "Total params: 25,071\n",
      "Trainable params: 25,071\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "history = model.fit(X_train, y_train, epochs=100,\n",
    "                   verbose=False, validation_data=(X_test,y_test),\n",
    "                   batch_size=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 1.0000\n",
      "Testing Accuracy:  0.7701\n"
     ]
    }
   ],
   "source": [
    "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
    "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
    "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
    "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "def plot_history(history):\n",
    "    acc = history.history['accuracy']\n",
    "    val_acc = history.history['val_accuracy']\n",
    "    loss = history.history['loss']\n",
    "    val_loss = history.history['val_loss']\n",
    "    x = range(1, len(acc) + 1)\n",
    "\n",
    "    plt.figure(figsize=(12, 5))\n",
    "    plt.subplot(1, 2, 1)\n",
    "    plt.plot(x, acc, 'b', label='Training acc')\n",
    "    plt.plot(x, val_acc, 'r', label='Validation acc')\n",
    "    plt.title('Training and validation accuracy')\n",
    "    plt.legend()\n",
    "    plt.subplot(1, 2, 2)\n",
    "    plt.plot(x, loss, 'b', label='Training loss')\n",
    "    plt.plot(x, val_loss, 'r', label='Validation loss')\n",
    "    plt.title('Training and validation loss')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Word Embeddings\n",
    "\n",
    "This method represents words as dense word vectors (also called word embeddings) which are trained unlike the one-hot encoding which are hardcoded. This means that the word embeddings collect more information into fewer dimensions.\n",
    "\n",
    "Note that the word embeddings do not understand the text as a human would, but they rather map the statistical structure of the language used in the corpus. Their aim is to map semantic meaning into a geometric space. This geometric space is then called the embedding space.\n",
    "\n",
    "This would map semantically similar words close on the embedding space like numbers or colors. If the embedding captures the relationship between words well, things like vector arithmetic should become possible. A famous example in this field of study is the ability to map King - Man + Woman = Queen."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.text import Tokenizer\n",
    "tokenizer = Tokenizer(num_words=5000)\n",
    "tokenizer.fit_on_texts(sentences_train)\n",
    "\n",
    "X_train = tokenizer.texts_to_sequences(sentences_train)\n",
    "X_test = tokenizer.texts_to_sequences(sentences_test)\n",
    "vocab_size = len(tokenizer.word_index) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am a fan of his ... This movie sucked really bad.  \n",
      "[7, 150, 2, 932, 4, 49, 6, 11, 563, 45, 30]\n"
     ]
    }
   ],
   "source": [
    "print(sentences_train[2])\n",
    "print(X_train[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note**: Pay close attention to the difference between this technique and the `X_train` that was produced by scikit-learn’s CountVectorizer.\n",
    "\n",
    "With `CountVectorizer`, we had stacked vectors of word counts, and each vector was the same length (the size of the total corpus vocabulary). With Tokenizer, the resulting vectors equal the length of each text, and the numbers don’t denote counts, but rather correspond to the word values from the dictionary `tokenizer.word_index`.\n",
    "\n",
    "One problem that we have is that each text sequence has in most cases different length of words. To counter this, you can use `pad_sequence()` which simply pads the sequence of words with zeros. By default, it prepends zeros but we want to append them. Typically it does not matter whether you prepend or append zeros.\n",
    "\n",
    "Additionally you would want to add a `maxlen` parameter to specify how long the sequences should be. This cuts sequences that exceed that number. In the following code, you can see how to pad sequences with Keras:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.preprocessing.sequence import pad_sequences\n",
    "maxlen = 100\n",
    "X_train = pad_sequences(X_train, padding='post', maxlen=maxlen)\n",
    "X_test = pad_sequences(X_test, padding='post', maxlen=maxlen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Keras Embedding\n",
    "\n",
    " Now you can use the Embedding Layer of Keras which takes the previously calculated integers and maps them to a dense vector of the embedding. You will need the following parameters:\n",
    "\n",
    "`input_dim`: the size of the vocabulary\n",
    "`output_dim`: the size of the dense vector\n",
    "`input_length`: the length of the sequence\n",
    "\n",
    "\n",
    "With the Embedding layer we have now a couple of options. One way would be to take the output of the embedding layer and plug it into a Dense layer. In order to do this you have to add a Flatten layer in between that prepares the sequential input for the Dense layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_2\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_1 (Embedding)      (None, 100, 50)           128750    \n",
      "_________________________________________________________________\n",
      "flatten_1 (Flatten)          (None, 5000)              0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 10)                50010     \n",
      "_________________________________________________________________\n",
      "dense_4 (Dense)              (None, 1)                 11        \n",
      "=================================================================\n",
      "Total params: 178,771\n",
      "Trainable params: 178,771\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras import layers\n",
    "\n",
    "embedding_dim = 50\n",
    "\n",
    "model = Sequential()\n",
    "model.add(layers.Embedding(input_dim=vocab_size, \n",
    "                           output_dim=embedding_dim, \n",
    "                           input_length=maxlen))\n",
    "model.add(layers.Flatten())\n",
    "model.add(layers.Dense(10, activation='relu'))\n",
    "model.add(layers.Dense(1, activation='sigmoid'))\n",
    "model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check the accuracy and the history of the model (for the graph):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages/tensorflow_core/python/framework/indexed_slices.py:424: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
      "  \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 1.0000\n",
      "Testing Accuracy:  0.6898\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsIAAAFACAYAAAC2ghqXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd3xUVfr48c+Zkh4SQhCktwAhARGWtqBCpKpU9SoqigXLAq5td21rXxW7+1sblvXr6speCyCKYkHXtYCorFQxoQcWpCVAkplMub8/7iRMQsokTDI3mef9euWV3Jkz9z4zk9w8c+45z1GGYSCEEEIIIUS0sUU6ACGEEEIIISJBEmEhhBBCCBGVJBEWQgghhBBRSRJhIYQQQggRlSQRFkIIIYQQUUkSYSGEEEIIEZUkEW5gSqneSilDKfWbOj5uj1LqloaKq7E0xvNQSsUFXuPz6nJcpdQCpdT7YTj++MDx0090X0KI5kPO/3L+D6dwxSwqckQ6gEhTStVWSHm7YRhdTuAQucDJwP46Pq4vUHQCx412YX/9lFIOwANMNwxjQdBdyzHf4wPhPJ4QomHJ+b/ZkvO/CFnUJ8KYv8BlBgOLA993Bm7zVfUgpVSMYRilte3cMAwfsKeuQRmGsa+ujxHHNObrF/g9qPN73JyE+vcghMXI+b8ZkvO/qIuoHxphGMaesi/gYODmfUG374PySy13K6XmK6UOAp8Fbr9FKbVGKVWklNqtlHpdKXVS2f4rXxoL2p6mlPpQKVWslMpTSl0QHFflSzuB7TuUUs8opQoC2w8ppWxBbRKVUq8opQ4rpQ4qpf6qlHpcKbWuptcghOdQdulnlFLqa6VUiVJqrVJqVKX9DFRKrVRKuZVSPyulptRy3FaBttMq3d5FKeVXSo0MbF+mlFoVeF77lFLvKaW617Lvyq9fa6XUO4HXe49S6q4qHnOWUurLwGtXoJRarpQaENQkP/D9zcDr4ar0+qQH7WuEUuorpZQrsL/XlFKtgu5/WCm1Til1vlLqF6XUUaXUp0qpzrU8r9piRCnVQin1N6XUrsDru6XSa3FyIJ5fA/H9rJS6pIbn4gjcdmFgu+x3+AKl1MdKqWLgLqWUUyn1cuB4JUqpzUqpe5VSzkrxjQ/8HhUHnsPnSqlOSqkJSqlSpVSbSu2vUUodUkrF1/TaCFFXcv6X839QG8uf/6uIWSmlblNKbQucO/OUUrMrtTlPKfVT4LkfUkp9q5TKDtwXG/g9KftfsVsp9X91iaE5iPpEuI5uBrYDQ4CrA7f5gRuAbOB8oCfwjxD2NQ94EegHLAFeC+GP4GZgCzAI+APwRyD4BPokMA64EPgt5mWcq0KIJdTn8BhwD3AKsB54SymVBKCUSgY+BP4XiO8q4M9AanUHNQzjALAUuKzSXZcAO4B/B7ZjgLuBU4HxgBN4T5mXqkL1GpAFTABGB57rWZXaJAJPYb6/IzBPfB8ppVIC958a+H4tZk9Sle+XUqojsAzIA34DTMV8TRZUatoZmIn5Hp4OtAXm1/I8aowx8I/xI2AscA2QCVxJ4J984P36D9Ab8/ekD3Aj4K7luFV5BHgF83V9CbAH4rkgcNxbgN8FvhM4/lnAB8A3wFDM39M3Md/TZcAuzNck2FXA64ZhlNQjRiHCRc7/cv6HyJ7/K7sJuBO4N/D8ngKeVEpdHIilU+C4Zefp4cCzHLvScTMwEZgOZABTgO/rGEPTZxiGfAW+MH/5DaBLFfftAT4IYR/DAvtoFdjuHdj+TaXt3wU9JgYzEbms0vFuqbStVzrWF8DfAz+3xDzxXVypzWpgXR1fh8rPYXxg+6ygNl0Ct50R2J4DFADJQW1+E2hzSw3HmgKUAulBt20C7q/hMScH9jswsB0X2D6vqtcP86RnAKcF3R8P/Aq8X8NxHJjjzM4N2jaACyu1K3t90gPbj2L+w3IEtRkSaDM4sP1w4D1vGdRmZuA9tNfhvaoc49mB4/Stpv1s4CjQppr7KzyXqp530O/wH0KI7zZgbdD2KuDtGtrfjjmuUgW2T6np+ciXfIXrCzn/V/cc5Px/bDui53/MpPb9oO19wH2V2jwHbAh6L/3AydXs7wXMDzCqsf/erPQlPcJ1813lG5RSo5VSnyildiqljgCfBu6q7dP9f8t+MMwxRvuBNtU3r/iYgF1Bj+mJ+Ye6olKbytvHqcNzCD7+rsD3suP3wUx4jpQ1MAzje6C2XrwPgMOYn0hRSg0JPJfXguIbqJRaHLj8cwQzUaoqvur0wTwZlL8Whtm7+GNwI6VUhlLqn8q8pH8Y88QeX4fjlMkCvjEMwxt023eAK3Bfme2GYRwK2t6F+R62ohohxDgQ+J9hGGur2cVAYI1hGHvr9IyqVtXfw+8ClzF/VUodxezJ6Ry4T2H2qnxcwz5fCbQfGdieBays4fkI0Vjk/F/x2CDn/6o02Pm/UrwnAenAl5Xu+jeQocwhaasC25sCQ0PmKqXaB7V9CXNM/C9KqWeVUlNVpaFs0UAS4bqpMAtVKdUDeB/zE+wFmJ+Azw/cHVPLvipPtDCo/f0I5TFGLfuooI7PIfj4ZccpO76q5tiqpuMbhuHBvDR+aeCmS4FvDcPIDcSXAnyCeRK5DPMS02+ria86NcYQ5EPME/u1mJft+wOFdThOsOreh+Dbq3o/oebfg1BirO13oKb7/YHvwa9ZdSfGyn8PM4AnMC+rTsBMeudx/OtX7fENc6zmYmCWMscEX0zdLxcK0RDk/H/8ceT8X7WGOv+Hcqzy5xtIxnMwh8qtxhw2k6uUGhO4fxVm7/6tmOf+Z4DvlVKJdYyhSZNE+MQMwUwSbjAM4xvDMDZhjvOJhF8AL+alkGBDa3lcuJ7DeqBf2ZgxMD/JY162qs1rwG+UUv0wT8bBg/WzMS/73WoYxr8Nw/gZ81NwXWOzEfRaKKXigAFB2+2B7sADhmF8YhjGBswTQ/AYN1/gyx7C8YZXGsM2GPO1WF/H2MuFGOMPQDulVN9qdvMDcIqqNCEtyK+B7+2CbhtQVcMqnI7Ze/tXwzB+CPwz61p2p2Fei1uNOY6xJi8A0zDHONuAf4V4fCEak5z/j5Hzf8Xjhf38X5lhGL9iDo04o9JdpwO/BD5kYJhWGIbxgGEYwzF7p2cG7eeIYRjvGIYxB/NDRj+OfdiICpIIn5hfMF/DG5VSXZVS52KOiWx0gUssfwfmKXP2fS+l1KOYiUhNvQTheg7/hzm+6TWlVF+l1HDgeUKYhBX4VLohsI8kKiY+WwP7vV4p1U0pNRZzDFbIDMNYh3k5/gWl1OlKqSzgVSqepH/FvBR2TeAS2XDMnk1X0H4MzMkyOcqsvFDdJaynMXsWXlJKZSmlzsB8bz4NPNf6qjVGzIly3wHvKKXOCbynpymlLg/c/1pgP0uUUjmB+8eoY8XoNwK7gfsCv0NnYE6KC8UmYIBS6mylVA9lzto+p1Kb+4BpSqlHA78nvZVSV6qKs8A/wyxfNQ/4p2EYUk9VWJGc/4+R8/8xDXX+r8rDwM1KqcsDcc/BnBz9IIBSaqRS6nal1GBlVuYZizlUZEPg/tuUUtOVUn2UUt2AyzFf77wwx2lpkgifgMAv9U3A7zF/seZizsCPlBsxLyPpmOOhYoF/UjFRqiBczyEwNuwsoAPmrNNXgYcwTy6heA3zUtQSwzDKH2MYxm7MS2KTAvE9WJ/4gBnAz5iJ4nLMpG1p0HE8mJcEs4G1mDO653F8kfQbMCfVbOfYOLkKDMPIx+z1zMDsgV2I+ZpcWI+4g/dba4yGWbd0HGYy+RLmc34Vs1el7H06DfNE9xZm4vtXzN8VDMNwY/bKdMYcE/gU8KcQQ/x/gX2+jvm8+wEPVHoOSzDfyzMwx6+tAC7CPPmWtTECsccgwyKERcn5v8J+5Px/bF8Ncv6vxpPAXzDnYqwPxHejYRhvBO4/hNlDvARzbPV84GXM5wbmxOk/AiuBnzAn/k0xDGNrA8RqWWUzs0UzpZT6BthqGMbFkY5FiFAppf4KDDMMY1CkYxGiqZLzvxC1k5XlmhGl1KmYs1JXYl72uQJzzNgdkYxLiFAFJsecinmJblaEwxGiyZDzvxD1I4lw83M9Zq1KMC97n20YxucRjEeIuliGOaTidWSSnBB1Jed/IepIhkYIIYQQQoioJJPlhBBCCCFEVJJEWAghhBBCRKVIjhGWMRlCiKYs1BWrGp2maeMx65nagZd0XX+40v2dMOu2pgba3Krr+tLjdlSRnLOFEE3dceftiE6W2717dyQPX0F6ejr79++PdBjlrBYPWC8miad2VovJavFA/WJq165d7Y0iRNM0O+ZSqWOAfGCVpmnv6bq+IajZnYCu6/pzmqb1wayp2qW2fcs5u3pWiwesF5PV4gHrxSTx1K6+MVV33pahEUII0bwMBvJ0Xd+i63opsACYXKmNAbQI/JyCuZqgEEJEHSmfJoQQzUt7zCWqy+QDQyq1uQf4WNO0uUAiMLpxQhNCCGuRRFgIIZqXqsYuVx7fOx14Vdf1xzVNGwb8Q9O0bF3X/cGNNE27GrgaQNd10tPTGyTg+nA4HBJPLawWk9XiAevFJPHULtwxSSIshBDNSz7QMWi7A8cPfbgSGA+g6/q3mqbFAenAr8GNdF2fD8wPbBpWGitotbGLVosHrBeT1eIB68Uk8dQu3GOEJREWQojmZRWQoWlaV2AXcCFwUaU2O4AzgVc1TcvEXJJ3X6NGKYQQFiCT5YQQohnRdd0LzMFcrnqjeZO+XtO0+zRNmxRodjMwS9O0n4A3gZm6rkt5NCFE1JEeYSGEaGYCNYGXVrrtrqCfNwDDGzsuIYSwmloTYU3TXgHOAX7VdT27ivsVZuH2s4BizJ6FH8MdqBBCCCGEEOEUytCIVwlMqqjGBCAj8HU18NyJhyWEEEIIIUTDqrVHWNf1LzVN61JDk8nAa4HxZSs0TUvVNO1kXdf/F64ghfV4PLBnj51du8wvl6vxV5tNSrJx9GhCox+3OlaLB6wXk9XiATj7bEhNjXQUQgghquXz4di6Fee6dajevaF377DtOhxjhKsq3t4eOC4RlpqUoYt0PEeOwI4dih07zO87dyp27rSxY0dbduxQ7N4Nfn/jJ7/Hs1oGY7V4wHoxWSuetm39XHCBdf72hRAiqrlcODdtwrluXfmXY+NGbCUlAPhmzICHHw7b4cKRCIdSvB2QmpR1UZ94Dh5UPPVUMr/+aq/XMUtKFLt3mz28hYUVR804nQYdOkDbth6GDfPRvr351aGDj3btfCQm+qvZa8NJS0vj4MGDjX7c6lgtHrBeTFaLB6B797Q6/61VV49SCCFE6FRBAc4NG44lvevX48jNRfl8APiTk/FkZVF80UV4srPxZGeTOmwYFBaGLYZwJMKhFG8XDeyrr2L4/e9bcuCAjc6dvfXaR0wMtG/vY/Dg0kCi6y1Pdlu39tOmTTr79x8Ic+T1l54OsbGNn4BXx2rxgPVislo8AAkJUFwc6SiEEKL5UoWFODZvxrFli/k9N9fs6d15bECBr00bPFlZuMaOLU96fR07gq3SdDanM6yxhSMRfg+Yo2naAsz17AtlfHDjKS2FRx9N5rnnkuja1cerr+6nb19PpMMSQgghRDRxu3Fs316e7NrLkt4tW7AfONaJZtjt+Dp1wtO/P8WXXIInKwtPdjb+1q0jEnYo5dPeBEYC6Zqm5QN3A04AXdefx6xVeRaQh1k+7fKGClZUlJdnZ+7clqxZE8PFFxdxzz2HSUiQmvhCCCGEaACGge3XX3Hk5ZlfZb28W7Zg37kT5T92xc/XujXe7t1xjRuHt1s3vN274+vWDW+nTuYlaIsIpWrE9FruN4DZYYtI1Mow4M03E7jrrhbExsJLLx1kwgRXpMMSQgghRHNQWopj+3bU11+T9OOPx5LevDxsR46UN/MnJODt1g3PKadQMnUq3u7dzaS3WzeMFi0i+ARCJyvLNTGHDin++MdUli6NZ8QIN089dYiTT7bWmEshhBBCWJ8qKChPcMu/5+WZSbDXnG/kBHxt2+Lt0YOSc8/F06OHmfB2746/XTtQVqggVX+SCDchX38dw/XXmxPi7ryzkGuuKTpuDLkQQgghRDmPB8f27cfG7AZ9VRi763Ti7doVb69euM46C29GBkm/+Q3709IwkpMj+AQaliTCTUBpKTz2WDLPPisT4oQQQghRiWFg27//uETXsXkz9h07ysuRAfjS082xu2PHlvfsenv0wNepEzgqpoWJ6ekYFiot2xAkEba4zZvtzJkjE+KEEEIIEeDx4Fy7lpiVK4ldsYKY77/HVlBQfrcRG4u3a1c8mZmUnHPOsYS3WzcMWUqzAkmELcow4J//lAlxQgghRNRzuYhZvZqYFSuIXbkS5/ffl6+05unenZIJE/BmZpYnvL727Y+vvyuqJImwBRUUKObMcbBwYapMiBNCCCGijDp6lJgffiBmxQpiVq4kZvVqVGkphlJ4MzMpnj6d0iFDKB0yJGL1d5sLSYQt6J57Unj/fSUT4oQQQojmzjCw796N86efsK9fT/oXX+Bcuxbl82HY7Xj69aPoiitwDx1K6aBBMrQhzCQRtpiSEsUHH8QxY4af664rinQ4QgghhAgXw8C2Zw8xa9bg/OknnGvW4Fyzprx6gxEbi/fUUzk6Zw6lQ4dSOnAgRmJihINu3iQRtpiPP46luNjGhRdKVQghhBCiKbP9+ivOn34yE9+ypPfXXwFzqWFvz564R4+mtF8/PKecQsppp3Hg6NEIRx1dJBG2mMWL42nb1seIEQaHDkU6GiGEEELUKlCr15Gbi+Pnn82KDj/9hH3PHgBzbG9GBu7TT8dzyimU9uuHNysLIz6+4n7i4kAS4UYlibCFFBQoli+P4/LLi7DbrbMOtxBCCCEAlwvHli04cnNx5ubi+OUXM/nduhXlOXYl19O9O+7f/hZPoKfXk5UlQxwsShJhC/nww3g8HsXUqSWAJMJCCCFEJKiSEhybNplJbuDL+csv5uIUfrOKk2Gz4evUCU/PnrjGjMGbkYG3Z0+8PXpI0tuESCJsIQsXxtO1q1dWjRNCCCEiwLlmDQmvv078okXYiswJ64bTibdbNzxZWZRMnYonI8NMert1M4cyiCZNEmGL2LPHxjffxHDjjUdRKtLRCCGEENFBHT1K/KJFJLzxBjFr1uCPi8M1aZLZy9uzJ97OncHpjHSYooFIImwRS5bEYxiKyZOLIx2KEKKJ0zRtPPA0YAde0nX94Ur3PwmMCmwmACfpui7FSUVUca5Zg/3tt2mzYAG2oiI8vXtT8MADlEybhpGSEunwRCORRNgiFi2Kp2/fUnr08EU6FCFEE6Zpmh14BhgD5AOrNE17T9f1DWVtdF2/Maj9XODURg9UiAgo7/19/XVi1q7FiI+nZOJEii65BM+AAcgl2egjibAFbN1q57//jeHPfy6MdChCiKZvMJCn6/oWAE3TFgCTgQ3VtJ8O3N0QgRiG5BXCGiqP/fVkZlLwl7+QcNVVFHi9kQ5PRJAkwhawaFE8ShlMmlQS6VCEEE1fe2Bn0HY+MKSqhpqmdQa6AssbIpBnn03iu+9imDGjiFGj3NjtDXEUIarg82Hfto3Yb74xx/6uXWuO/Z08maKLLy7v/U1ITYX9+yMdrYggSYQjzDDMRHjo0FLatfNHOhwhRNNXVR+sUU3bC4G3dV2vckyWpmlXA1cD6LpOenp6nQJp1crG2rV2Lrssjk6dDK64wsfMmX5OPrlOu6mSw+GoczwNyWrxgPViapB4fD7YuhW1YQNq40bz+4YNqE2bUG43AP7sbLxPPYV/+nQcqakEj/6NitfoBFgtHgh/TJIIR9j69Q7y8pxcdVVBpEMRQjQP+UDHoO0OwO5q2l4IzK5uR7quzwfmBzaN/XXsObvc+Q6zRq9iR76Tn3+JJf8eJwvvtdGpi0Fmlo/2nQyU3QY288uw2cyxFHY7OBzmggSnnFLl+Ir09HTqGk9Dslo8YL2YTigevx/7zp04Nm3C+csvZo3fX37BmZeHcrnKm3nbt8fTqxfe3/4WT8+eeLKz8fbpY/4Oeb3H9f42q9eoAVgtHqh/TO3atavydkmEI2zRogQcDoOzz5ZhEUKIsFgFZGia1hXYhZnsXlS5kaZpvYCWwLcNFYhz3Tril31Ib7+fTL8ff5Ifj9vAt9WPfasPG34cNj82/OWLFFTmycqi6OKLKZk6FaNFi4YKVVhRSQnxS5aQsGABzjVrsJUc+z/pO/lkPL16UfTb35qJb8+eeHv2xEhKimDAoimSRDiC/H5YvDiOM85wk5ZW3ZVLIYQIna7rXk3T5gDLMMunvaLr+npN0+4Dvtd1/b1A0+nAAl3XG+zkc/juuzl89/Hz8FwuWLo0ntdfT2DlylhiYgzOmlDMjEuKGDLIhTL85uz+998n8fXXSb39dlrcfz8lkydTfPHFeE6VIhfNmT0vj8TXXyfhrbewFRTg6dGD4osvxturF56yhFc+FIkwkUQ4glatimH3bge3334k0qEIIZoRXdeXAksr3XZXpe17GjOmYHFxMG1aCdOmlbBpk4PXX0/g7bcTWLQ4kYwMDzNmFHPuubEYl15K8YwZ5oz/N94gfuFCEhcswJOZibr6atS4cVLvtbkoLSVu2TIS//EPYr/+GsPpxDVhAkWXXkrp0KFSfkQ0GFukA4hmixbFExfnZ+xYV+2NhRCiGerVy8v99x/mhx/28vjjh0hKMrjrrhQGDmzD22/Hg1J4TjmFwkceYe/q1RTMm4fhdOK48UbaDBhA6g034Fy1ypx5LJoce34+yfPm0WbwYNKuvRb79u0cvvVW9q5axaHnnqN02DBJgkWDkh7hCPF4YMmSOMaNc5GYKCdwIUR0S0gwuPDCEi68sIS1a53cc08Lbr45lbZtfYwYUQqAkZRE8SWXUHzJJbTesYPSZ54hfuFCEt56C0+vXhRffDHF06ZhtGwZ4WcjauTzEfv552bv73Kzcp/7zDMpuPRS3GecgdTZE41JeoQj5MsvYzl0yM6UKTJJTgghgvXt6+Hvfz9It25eZs1KIzf3+D4bY8AACufNM3uJH3sMIyGBlLvuou3AgaTcfDPq0KEIRC5qtGcPSX/9Kyf99re0uuwynGvWcHTuXH5dsYKDr76KOydHkmDR6KRHOEIWLYonNdXPyJHuSIcihBCW06KFwWuvHWTixHRmzEhjyZL9tG59fGUJIzGR4unTKZ4+Hce6dSS+8QYJb75J7JdfUvDMM5QOHhyB6KOYYWDbtw/Htm3Yt27FsW2b+fO2bTg3biTG48E9YgSH//xnXOPGgdMZ6YhFlJNEOAJKShQffRTH1KklxMREOhohhLCmjh19/P3vBznvvFZcfnkab721n/j46tt7s7MpfOghii+4gJazZ9Pq3HM5ctNNHL3+eulpDCe/H9uePRWSXEcg6bVv24atuLi8qWG34+vYEW/Xrvh//3v2T5yIr0ePCAYvREWSCEfAJ5/EUlxsY/JkGRYhhBA1OfVUD3/7WwGzZrXk979vyfPPH8JWy6A+T//+7PvoI1Juu40Wjz1G7Ndfc+ivf8VfTUF9UTNVVETMt98S+5//EPvNNzi2bKmwiIXhdOLt1Alfly64hw3D260bvi5d8Hbpgq99+/Je3/T0dHwWW5xBCEmEI2DRonjatvUxdGhppEMRQgjLmzDBxZ13Hub++1OYN8/LbbfVXnLSSE6m4P/9P9ynn07KHXdw0pgxHHrySdxjxzZCxE2c14vzp5+I/fJLYv/zH2J++AHl9WLExVE6aBBFp52GtyzR7doVX7t20uMumixJhBtZQYFi+fI4Zs4skvOGEEKE6Jpriti2zcHf/pZM584+rr8+hAcpRYmmUTpgAGm/+x2tLr+co1dcweE77jCLGQuTYWDfssXs8Q30+toOH8ZQCk92NkevuQb3iBGUDhpEjWNThGiCJBFuZB9+GI/Ho5g6VYZFCCFEqJSCBx4oJD/fzq23ptCnj5f+/UN7rK9HD/YtWUKLv/yFpJdfJnblSg4++2xUj1W1HThAzFdflff6OnbtAsDboQMl55yD+7TTKB0xAn9aWoQjFaJhSSLcyBYujKdrVy/9+nkiHYoQQjQpDgc899whpk5NZ/p0B4sWOejVyxvag2NjOXzffbhHjCD1pptoPX48hX/5CyWa1vwXbPD7ceTmEvPjjzh//JGYH37AuWmTeVeLFriHD+fo7Nm4Tz8dX5cuzf/1ECKIJMKNaO9eG998E8MNNxyV84wQQtRDcrLB//3fASZPbsOll5pl1U466fiyatVxjx3Lvk8+oeXcubS86SZiv/ySwocfxkhObsCoG5c6dIiY1auxb9xI2ldfEbN6NbYj5rhqf2oqpaeeSsmkSbhPPx1Pv37mJwwhopT89jei996LxzCULKIhhBAnoH17P+++6yUnx87ll6fx9tsHiI8PfYVO/8knc+Bf/yLpr38l+YkniFm9mkPPPosn1LEWVuL14vj5Z2ICPb0xP/6IY8sWAAybDXvv3pRMmULpgAGUDhiAr1s3ai27IUQUkUS4ES1eHE92dik9eoR4KU8IIUSVBgwwePbZQ1xxRRrXX5/KCy/UXlatArudozfeSOnw4aTOnk365MkcvvVWiq65xvKJon3LFuI+/pi4zz7D+d//ltft9aWnUzpgAMUXXEDpgAG0yMlhf1CZMyHE8SQRbiRbt9pZvTqGP/+5MNKhCCFEszB2rJt77jnM3Xen8OCDPu6883Cd91E6eDD7Pv6Y1D/8gZQHHiD5iSfwdehgfnXsiLdjx/KffR07mpPHGntsm9+Pc/VqM/ldtgxnbi4Anj59KJ4+HU9Zb2/HjhVjS0oCSYSFqJEkwo1k0SKz5MzEiTIsQgghwuXKK4vYts3Oc88l0bmzlxkzimt/UCVGy5YcevFFSpYsIeaHH7Dn52PPzyfmxx+xFRRUaOuPjz+WGJclyx06oPr2xZaSgr9ly/AkyiUlxH71lZn8fvIJ9n37MBwOSocOpfDSS3GNHYuvQ4cTP44QUU4S4UZgGGYiPHSom/btQ5/UIYQQomZKwT33HGbHDgd33JFCx44+Ro5012tHrkmTcE2aVPHmw4fLE2NHfj72nTvN7Z07j0uU2wL+5ChqHoYAACAASURBVGS8nTvj69TJXHCic2dzu0sXfCefXOPENHXwIHGffkrcxx8T+8UX2EpK8Ccl4R41Cte4cbhGjcJITa37cxNCVCukRFjTtPHA04AdeEnX9Ycr3d8ZeAVoDRwELtF1PT/MsTZZ69c7yMtzctVVBbU3FkIIUScOBzz7rFlW7ZprWrJo0X4yM8MzF8No0QJvnz54+/ShqvRaHT2KPT+flgUFFK9di337dhzbt+PYtIm4Tz9FlR5bQdRwOPB16HAsQQ4sS2zfvp24jz8m5rvvUH4/vrZtKTn/fFzjxuEeNgxiY8PyXIQQx6s1EdY0zQ48A4wB8oFVmqa9p+v6hqBmjwGv6br+f5qm5QAPATMaIuCmaPHieBwOg7PPlmERQgjREJKSzLJqEye2ZubMNL766leczoY/rpGUhLd3b4z0dIqGDq14p8+Hfc8e7Nu24dixw/y+fTv27dvNkmaFx+aMeHr35uicObjGjzdLmkmNTSEaRSg9woOBPF3XtwBomrYAmAwEJ8J9gBsDP38OLApnkE2Z328OizjjDDdpaaGX9xFCCFE37dr5uffeQq65Jo0ffohh6NDS2h/UkOx2fO3b42vfntLhw4+7Wx06hGPHDvwtW+Lr1CkCAQohQqkR0x7YGbSdH7gt2E/AuYGfpwLJmqa1OvHwmr5Vq2LYvdshtYOFEKIRnHGGG6fTYPly6w8nMFq2xHPKKZIECxFBofQIV3V9pnLX5i3A3zRNmwl8CewCjhugpWna1cDVALquk56eXqdgG5LD4WiQeD76yE58vMFFFyWSlJQY8XhOhNViknhqZ7WYrBYPWDMmUX/JyQaDB5eyfHkct99+JNLhCCEsLpREOB/oGLTdAdgd3EDX9d3ANABN05KAc3VdP65grq7r84H5gU1j//799Ym5QaSnpxPueDweeOutNowdW4LLVVCnco4NEc+JslpMEk/trBaT1eKB+sXUrl27BopGhENOjov7709h1y6bVOoRQtQolKERq4AMTdO6apoWA1wIvBfcQNO0dE3TyvZ1G2YFiaj3n//EcuiQXYZFCCFEI8rJMes7fP55XIQjEUJYXa09wrquezVNmwMswyyf9oqu6+s1TbsP+F7X9feAkcBDmqYZmEMjZjdgzE3GwoXxpKb661fTUggh6qm2kpeBNhpwD+ZQt590Xb+oUYNsQBkZXjp08LJ8eSyXXFL3BTaEENEjpDrCuq4vBZZWuu2uoJ/fBt4Ob2hNW0mJ4qOP4pgypYSYmEhHI4SIFqGUvNQ0LQPz6t1wXdcPaZp2UmSibRhKmb3C77wTj9stZXiFENULZWiEqIf16x0UF9sYM0bWeRdCNKrykpe6rpcCZSUvg80CntF1/RCAruu/NnKMDS4nx0VRkY3vvpOeCCFE9WSJ5QaSl2e+tD17hmd1IyGECFFVJS+HVGrTE0DTtK8xh0/co+v6R40TXuMYPryU2FiD5cvjOO20CNcTFkJYliTCDSQ310lsrEHHjr5IhyKEiC6hlLx0ABmY8zs6AP/RNC1b1/UK68A39ZKXp51m8O9/J5Ke3vC9wlYsw2e1mKwWD1gvJomnduGOSRLhBpKX56BbNy92e6QjEUJEmVpLXgbarNB13QNs1TRtE2ZivCq4UVMveXnaaYncfXcKP/54iE6dGrZTormUBmxIVosHrBeTxFO7+sZUXdlLGSPcQPLyHPToIcMihBCNrtaSl8AiYBSY5S8xh0psadQoG0FOjjlHoymsMieEiAxJhBuAywU7dtglERZCNDpd171AWcnLjeZNZslLTdMmBZotAw5omrYB+Bz4g67rByITccPp1s1Hly5eli+XesJCiKrJ0IgGsHWrA79fkZHhiXQoQogoFELJSwO4KfDVrJ15pos33kigpATi4yMdjRDCaqRHuAGUVYyQHmEhhIisUaPcuFw2VqyQ4RFCiONJItwA8vIcKGXQrZskwkIIEUlDh7qJi/PLOGEhRJUkEW4AubkOOnb0yWU4IYSIsPh4s6awjBMWQlRFEuEGkJfnlGERQghhETk5LrZtc7Bli9SzFEJUJIlwmPn9sHmzVIwQQgiryMlxA0ivsBDiOJIIh9muXXZcLpskwkIIYRGdOvnIyPDIOGEhxHEkEQ6z3FyzYkRGhiTCQghhFaNGufn221iKi6tagVoIEa0kEQ6zY6XTpIawEEJYRU6Oi9JSxddfx0Q6FCGEhUgiHGZ5eQ7S0nykpRmRDkUIIUTA4MGlJCb6ZZywEKICSYTDLDfXIcMihBDCYmJj4bTT3CxfHosh/RRCiABJhMMsL88hE+WEEMKCcnLc5Oc7yudyCCGEJMJhdPCgjYMHpXSaEEJY0ahRLgCpHiGEKCeJcBgdmygnibAQQlhNu3Z+MjM9fPaZjBMWQpgkEQ4jKZ0mhBDWlpPjYtWqGI4ckTJqQghJhMMqN9dBXJyf9u19kQ5FCCFEFXJy3Hg8iq++kuERQghJhMNq82YH3bv7sMmrKoQQljRwYCktWvhlnLAQApBEOKzM0mmykIYQQliV01lWRi1OyqgJISQRDpeSEkV+vlSMEEIIqzvzTBd79tjZsEHKqAkR7SQRDpPNm+0YhpJEWAghLG7kSDcAn38u1SOEiHaSCIfJ5s1SOk0IIZqCNm389O1bKuOEhRCSCIdLbq4Tm82ga1dJhIUQwupyctx8/30MBQVSRk2IaCaJcJjk5jro1MlHnFxpE0IIyxs1yoXPp/jyS+kVFiKaSSIcJps3O2RYhBBCNBEDBnhITfWzfLn0XggRzWTKbBj4fLBli6N8AoYQQkSSpmnjgacBO/CSrusPV7p/JvAosCtw0990XX+pUYOMMLsdRo508cUXsfj9SP13IaKUJMJhsHOnHbdb0aOH1BAWQkSWpml24BlgDJAPrNI07T1d1zdUavovXdfnNHqAFpKT42bRogTWrXPSr5+cv4WIRvIZOAxyc6VihBDCMgYDebqub9F1vRRYAEyOcEyWNHKkG6UMPvtMxgkLEa0kEQ4DKZ0mhLCQ9sDOoO38wG2Vnatp2hpN097WNK1j44RmLa1a+enf3yPjhIWIYjI0Igxycx20bu0jNVXW6xRCRFxV9cAqn5yWAG/quu7WNO1a4P+AnMoP0jTtauBqAF3XSU9PD3es9eZwOMISzznn2HjgATuQzonsLlzxhJPVYrJaPGC9mCSe2oU7JkmEwyA31ym9wUIIq8gHgnt4OwC7gxvoun4gaPNFYF5VO9J1fT4wP7Bp7N+/P4xhnpj09HTCEc/QoU4MozXvvlvEtGklEY8nnKwWk9XiAevFJPHUrr4xtWvXrsrbZWjECTIMKZ0mhLCUVUCGpmldNU2LAS4E3gtuoGnayUGbk4CNjRifpfTr56FVKx+ffy7jhIWIRtIjfIL277dRUGCTRFgIYQm6rns1TZsDLMMsn/aKruvrNU27D/he1/X3gOs1TZsEeIGDwMyIBRxhNhuMGuXms89i8fnMsmpCiOghifAJysszX8KMDEmEhRDWoOv6UmBppdvuCvr5NuC2xo7LqnJyXLz9dgL//a+TgQOljJoQ0USGRpygY6XT5OQphBBN0emnu7HZDKkeIUQUCqlHOIRVijphzjpODbS5NdAj0ezl5TlISPDTrp0/0qEIIYSoh5YtDQYOLGX58lj+8IcjkQ5HCNGIau0RDlqlaALQB5iuaVqfSs3uBHRd10/FnJjxbLgDtaq8PHOinKqqYJEQQogmISfHzZo1MezbJxdKhYgmofzFh7JKkQG0CPycQqVSPc1Zbq5UjBBCiKYuJ8cFINUjhIgyoSTCoaxSdA9wiaZp+ZgTNOaGJTqLKypS7N4tibAQQjR1WVle0tN9fP21JMJCRJNQxgiHskrRdOBVXdcf1zRtGPAPTdOydV2vMHC2ua1StGOH+dIMGBBPenp4J1lEw2ouJ0riqZ3VYrJaPGDNmETjU8qsKbx+vTPSoQghGlEoiXCtqxQBVwLjAXRd/1bTtDggHfg1uFFzW6Xo++/jgZa0aXOI/fvD2yvcnFZzaSgST+2sFpPV4oH6xVTdCkWiacvK8vDll7G43RArHcNCRIVQEuHyVYqAXZiT4S6q1GYHcCbwqqZpmUAcsC+cgVpRbq4Du92gSxcZGiGEEE1ddrYHr1exaZOTfv2kJKYQ0aDWMcK6rnuBslWKNpo3masUBVYmArgZmKVp2k/Am8BMXdcrD59odvLyHHTu7CMmJtKRCCGEOFFZWWbyK8MjhIgeIdURDmGVog3A8PCGZn15eQ4yMqTXQAghmoPOnX0kJflZt04SYSGihRRMrCevF7ZulYoRQgjRXNhs0KePh/XrQ+ojEkI0A5II19P27XY8HiWJsBBCNCPZ2R42bHDil8VChYgKkgjXU16eeelMEmEhhGg+srM9FBXZ2LrVHulQhBCNQBLhesrLMy+dSSIshBDNh0yYEyK6yECoesrNddCmjY8WLZp9cQwhhIgaPXt6cToN1q93MmmSK9LhCAswDAOXy4Xf70epqtYYC5+9e/fidrsb9Bh1YbV4oOaYDMPAZrMRFxcX8nsliXA95eXJRDkhhGhuYmLMZFgqR4gyLpcLp9OJw9HwKZPD4cBut86wHKvFA7XH5PV6cblcxMfHh7Q/GRpRD4ZRVjpNEmEhhGhusrJkqWVxjN/vb5QkWISHw+HAX4fZrpII18PevTaOHLHRo4fUEBZCiOYmO9vDvn129u6Vf5GCBh8OIcKvLu+Z/JXXg0yUE0KI5qtswpwMjxCi+ZNEuB4kERZCiOZLKkcIKzl48CBjxoxhzJgx9O/fn4EDB5Zvl5aWhrSPG2+8kby8vBrbvPrqq7z77rvhCJkpU6awbt26sOyrocmgl3rIy3OQlOSnbVupuC6EEM1NcrJBly4yYU5YQ1paGp988gkAjz/+OImJiVx77bUV2hiGUV4xoSpPPvlkrceZOXPmCcfaFEmPcD3k5jrp0cOLDBsSQojmyVxqWRJhYV1bt24lJyeHP/3pT4wbN469e/fyxz/+kQkTJjBq1KgKyW9ZD63X6yUzM5MHH3yQ0aNHM3HiRPbv3w/AvHnzePHFF8vbP/jgg4wbN47TTjuNVatWAVBcXMysWbMYPXo0v/vd75gwYUKtPb/vvPMOZ555Jjk5OTz00EOAWdlh7ty55be//PLLAMyfP5+RI0cyevRo5s6dG/bXrCrSI1wPeXkORoywVl09IYQQ4ZOd7WHp0niOHFEkJ0u9eGG6664WbNgQ3g9Iffp4uO++w/V67C+//MITTzzBvHnzALjtttto2bIlXq+X888/n7PPPpuePXtWeMzhw4cZOnQot99+O/fccw8LFixgzpw5x+3bMAyWLVvG0qVLeeqpp3jjjTd45ZVXaN26NS+++CLr169n/PjxNca3e/duHnnkET788EOSk5O58MIL+eSTT2jVqhWHDh3is88+A6CwsBCA5557jpUrVxITE1N+W0OTHuE6OnJEsWePXUqnCSEsS9O08ZqmbdI0LU/TtFtraHeepmmGpmm/acz4moLsbHOccLiTHiHCqXPnzvTv3798e/HixYwbN47x48eTm5vLL7/8ctxj4uLiyMnJAaBfv37s3Lmzyn1PmDABgL59+5a3+e6775g8eTIAWVlZ9OrVq8b4Vq9ezfDhw0lLS8PpdDJlyhRWrlxJly5d2Lx5M3fddRdffPEFLVq0AKBnz57MnTuXd999F6ezcf72pEe4jmSinBDCyjRNswPPAGOAfGCVpmnv6bq+oVK7ZOB6YGXjR2l9wRPmhgwJbUKSaP7q23PbUBISEsp/3rJlCy+99BIffPABKSkpzJ07t8oV2GJiYsp/ttvt+Hy+Kvdd1i64jWHU7epIde3T0tL49NNPWb58OS+//DJLly7lkUce4Z///CfffvstH3/8MU8//TTLly9v8AU9pEe4jo4lwlJDWAhhSYOBPF3Xt+i6XgosACZX0e5+4BFA1hGuQps2ftLTfTJhTjQZR48eJSkpieTkZPbu3csXX3wR9mMMHjyYJUuWALBx48Yqe5yDDRgwgG+++YaDBw/i9XpZvHgxQ4cO5cCBAxiGwcSJE7nllltYu3YtPp+P//3vf4wYMYI777yTAwcOUFJSEvbnUJn0CNdRXp4Dh8Ogc+eqP0EJIUSEtQeCr3XmA0OCG2iadirQUdf19zVNu6Uxg2sqlDJ7hSURFk1F3759ycjIICcnh06dOjFo0KCwH+OKK67g97//PaNHjyY7O5tevXqVD2uoSrt27bjllls4//zzMQyDMWPGMHr0aNauXcvNN9+MYRgopbjjjjvwer3Mnj2boqIi/H4/s2fPJikpKezPoTJV127uMDJ2794dqWMfJz09vXzmZE2uvLIlmzc7+OKLfZaIpzFZLSaJp3ZWi8lq8UD9YmrXrh2AJevGaJp2PjBO1/WrAtszgMG6rs8NbNuA5cBMXde3aZr2BXCLruvfV7Gvq4GrAXRdHxhqzdLG4HA48HobdojaHXfYefppGwcPegi6mhyxeOrKajFZLR4ILaa9e/cSGxvbSBFZm9frxev1EhcXx5YtW9A0jRUrVlhuCWq3202bNm0q3BYY6nHcedtakTcBubkOeva01h+yEEIEyQc6Bm13AIJ7HZKBbOALTdMA2gLvaZo2qXIyrOv6fGB+YNOw0oeYxvhQ1a1bHB5PGt98U0B2ds3n/ebyIa8hWS0eCC0mt9vd4ONUy1jtw0LleAoLC7ngggvKbyurVtGYMYfyGrnd7uPe10AHxvH7C1tkUaC0FLZtc3DWWTKkTghhWauADE3TugK7gAuBi8ru1HW9EEgv266pRzjaBU+Yqy0RFiIapKSk8NFHH0U6jLCSyXJ1sH27A59PSek0IYRl6bruBeYAy4CN5k36ek3T7tM0bVJko2taunXzkZDgl4U1hGjGpEe4DnJzpXSaEML6dF1fCiytdNtd1bQd2RgxNUU2G/TpI0stC9GcSY9wHUgNYSGEiC5ZWeZSy35/pCMRQjQESYTrIDfXwckn+0hMlOU2hRAiGmRnezh61MaOHY0zWUoI0bgkEa6DvDwHGRmykIYQQkSLsglzMjxCRMp555133OIYL774IrfddluNj8vIyABgz549zJo1q9p9//TTTzXu58UXX6ywsMWMGTMoLCwMIfKaPf744zz//PMnvJ8TJYlwiAzDTIRlWIQQQkSPXr082O2GTJgTETN58mQWL15c4bbFixczZcqUkB7ftm1bXnzxxXof/6WXXqqQCP/jH/8gJSWl3vuzGkmEQ7R7t43iYpskwkIIEUXi4qBnT5kwJyLn7LPP5tNPP8XtdgOwc+dO9u7dy+DBgykqKkLTNMaNG8eZZ57JsmXLjnv8zp07ycnJAaCkpITrrruO0aNHc+211+JyHSsHe+uttzJhwgRGjRrFY489Bpi9wXv37uX888/nvPPOA2DIkCEcPHgQgBdeeIGcnBxycnLKk+2dO3dyxhln8Ic//IFRo0Yxffr0WpdKXrduHeeccw6jR4/myiuvpKCgAICXX36ZkSNHMnr0aK677joAvvnmG8aMGcOYMWMYO3YsR48erfdrC1I1ImSbN5snQUmEhRAiuvTp4+Grr2RlMQEt7roL54YNYd2np08fDt93X7X3p6Wl0b9/f7744gvGjRvH4sWLmTRpEkopYmNjefnll0lOTubgwYNMnDiRsWPHolTVC1++9tprxMfH8+mnn7JhwwbGjx9fft+f/vQnWrZsic/n44ILLmDDhg3MmjWL559/nrfeeou0tLQK+1qzZg26rvP+++9jGAbnnHMOw4YNIyUlha1bt/LMM8/w6KOPcs0117B06VLOPffcap/jDTfcwP3338+wYcN49NFHeeKJJ7jvvvt45pln+Pbbb4mNjS0fjvHss8/y4IMPMmjQIIqKik541T/pEQ5RWek0qSEshBDRJTvbw969dvbtk3+ZIjKmTJlSPjwieFiEYRg8/PDDjB49mgsuuIA9e/awb9++avezcuVKpk2bBkCfPn3IzMwsv2/JkiWMGzeOcePGsWnTJnJzc2uM6bvvvmP8+PEkJCSQmJjIhAkTWLlyJQAdO3YkOzsbgH79+rFz585q93P48GEKCwsZNmwYAOeff375fjIzM5kzZw7vvPNO+TLOgwcP5t577+Xll1+msLDwhJd3lh7hEOXlOUhJ8dO6tdTQEUKIaJKdfWyFuZEj3RGORkRSTT23DWn8+PHce++9rF27FpfLRd++fQF49913OXDgAB9++CFOp5MhQ4aUD6GoTlW9xTt27OCFF17ggw8+IDU1lRtuuKHCsImqGEb1FbSCe2ntdnut+6rOa6+9xooVK/j444956qmn+Pzzz7n++usZNWoUy5cvZ+LEifzrX/+iR48e9do/SI9wyHJzHXTv7qWaqw1CCCGaqT59jiXCQkRCYmIiw4YN46abbqowSe7IkSOkp6fjdDr5+uuvyc/Pr3E/Q4YMYeHChQD8/PPPbNy4sXw/8fHxtGjRgn379vH555+XPyYpKanKcbhDhw5l2bJllJSUUFxczEcffcSQIUPq/NxatGhBSkpKeS/wO++8w9ChQ/H7/ezevZvhw4dz5513cvjwYYqKiti2bRuZmZnMnj2bU045hby8vDofM5j0CIcoL89BTo70BAghRLRJTTXo2FEmzInImjJlCldddRXPPfdc+W3Tpk3jsssuY8KECWRlZdXaM3rppZdy0003MXr0aPr06UP//v0ByMrKIjs7m1GjRtGpUycGDRpU/piLL76YSy65hJNOOom33367/Pa+ffty/vnnc/bZZwMwffp0srOzaxwGUZ2nnnqKW2+9FZfLRadOnXjiiSfw+XzMnTuXI0eOYBgGs2bNIiUlhccee4yvv/4am81Gz549GTVqVJ2PF0zV1LXdwIzdu3dH6tjHSU9PZ//+/VXeV1CgyMo6mTvuOMzvfndisxPDEU+kWC0miad2VovJavFA/WJq164dQLRdH2oy5+yGcNVVLdm0ycl//vOrJeIJhdVislo8EFpMxcXFJCQkNEo8DocDr9c6c5GsFg+EFlNV71l1520ZGhGCY0sry2IaQggRjbKyPGzdaqeoKNo+/wjRvEkiHILNm8sSYWt9KhJCCNE4srI8GIZiwwYZUShEcyKJcAhyc53ExBh06uSLdChCCCEioGypZZkwF30iOIRU1FNd3jNJhEOQl+egWzcvJ1iqTgghRBPVrp2fli19kghHIZvNZrlxsqJ6Xq8Xmy309FZSuxDk5jrKewOEEEJEH6UgO1sqR0SjuLg4XC4Xbre72hXbwiU2NrbWOsCNyWrxQM0xGYaBzWYjLi4u5P1JIlwLlwt27LAzZUrN62QLIYRo3rKyPLzySiIeDzglH44aSini4+Mb5VhWq6xhtXgg/DGFlAhrmjYeeBqwAy/puv5wpfufBMoKuSUAJ+m6nhq2KCNo2zYHfr+SiXJCCBHlsrM9lJYq8vIcZGbK/wQhmoNaE2FN0+zAM8AYIB9YpWnae7qubyhro+v6jUHt5wKnNkCsEZGba75EGRkyNEIIIaJZ2VLL69Y5JREWopkIZTTxYCBP1/Utuq6XAguAyTW0nw68GY7grKCshnC3blIxQggholm3bl7i4vwyYU6IZiSURLg9ELxeXn7gtuNomtYZ6AosP/HQrCEvz0GHDl4SEqR8ihBCRDO7HTIzZcKcEM1JKGOEq5oiWV1WeCHwtq7rVXafapp2NXA1gK7rpKenhxRkY3A4HFXGs369k1NOMRo91uriiSSrxSTx1M5qMVktHrBmTMK6srI8LFkSj2GYlSSEEE1bKIlwPtAxaLsDUN2C8xcCs6vbka7r84H5gU3DSjMRq5qFePCgIjf3ZM499wj79x+NeDyRZrWY6huPKizESEmxTDwNyWoxNUQ86vBh8PkwWrZstJgCa9aLKJSd7eH11xPJz7fTsaMMmROiqQslEV4FZGia1hXYhZnsXlS5kaZpvYCWwLdhjTCCVq+OAWDAgNIIRyJOlG3XLhIWLSJ+4UKcGzfiOv10jtx+O56+fSMdmgiV14tjyxYcGzfi3LAB588/49i4EceuXQD42rbFk5mJJzMTb+/e5vcePSAmJsKBN74QKv1ci9lp4QOOAlcHT4AW1QueMCeJsBBNX62JsK7rXk3T5gDLME+qr+i6vl7TtPuA73Vdfy/QdDqwQNf1ZjOY9scfY7DZDPr3l4oRTZEqLCT+gw+If/ddYlasQBkGpQMHcvS664hfsIDW48dTMmkSh//4R3xdu0Y6XFHGMLDt24dz40Yz6Q18OXJzUaXmh1LD4cDbowelgwdTnJmJYbeXt4v9+uuK7TIy8PTujTeQJHsyM/G3bdtsr2uHUukH+Keu688H2k8CngDGN3qwTVDv3l5sNoN165xMmOCKdDhCiBMUUh1hXdeXAksr3XZXpe17wheWNfzwQwy9e3tJTGw2uX3z53YT99lnxC9cSNynn6JKS/F268aRm2+mZOpUfF26AHDk+utJev55EufP56SlSym++GKO3HAD/pNOimz80cjvJ2bVKuI++gjnhg04Nm7EfuBA+d1lPb3u008/1uNbU0+vx2P2HP/8s9lzvHEjMStXkrBw4bFDpqaW70tdfTV07Fj1vpqm8ko/AJqmlVX6CS55eTiofSLVz/sQlcTHG/To4ZXKEUI0E7KyXDV8Pli92snUqbKinOX5/cSsXEn8u+8S/8EH2AoL8bVuTdGll1IybRqefv2O6/0zWrTgyB//SNHMmSQ/9RQJb7xBvK5TdPXVHL3uOozk5Ag9mejh2LTJfM8WLsSxaxdGXBye3r1xjR17rPe2d2+MtLS67djpxNurF95evXBNPlbpURUU4Ny0qcLQioR//Qvf+PHNLRGuqtLPkMqNNE2bDdwExAA5jRNa85Cd7eHbb2MjHYYQIgwkEa5Gbq6Do0dtDBwo44OtSq1bR/Irr5iJ1O7dKN4sVQAAIABJREFU+BMScE2YQMm55+IePhwctf96+086icIHH+TorFm0eOQRkp9+moTXXuPo9ddTdNllECv/7MJq1y4S//53Et55B+eGDRh2O+4zzuDIrbfiGjcOIzGxwQ5tpKZSOmQIpUOCckK/n/S0NCgoaLDjRkBIlX50XX8GeEbTtIuAO4HLKrdpipV+GsOgQTbefdcOpFMWghWrj1gtJqvFA9aLSeKpXbhjkkS4Gj/8IBPlrEoVFtLyuutw/vvfOOx23CNHcuSOO3CNHYuRkFCvffq6duXQc89x9LrrSH7oIVLuvZfEl17iyC23UHLuuWYB0VDjKynBsWnTsTGuGzbgyMtDud31iu2EdOxIakZGxfGxJ5/cqONj1eHDxC1daia/335LjGFQeuqpFN5/PyWTJuGP5EnWZgvpA1MTU5dKP2AukvRcVXc0tUo/jaVr1xggnS+/PMzpp5dGPJ7qWC0mq8UD1otJ4qldfWOqrtpPs/sPEC4//ugkNdUvK8pZjO1//6PVjBk48vLwPvgg+885B3+rVmHbv6dfPw6++SYxX35Ji4ceouWNN5L0wgscvvVW3KNHV0wg/X7sO3aUJ7yOLVs46b//xb5tG8owO+D88fF4e/fGdeaZDdrbWSXDIGHPHmJWrSJh0aJjYaekHF9doXfv8MbndhP3+efEv/uuOVbb7cbbpQu+O+/kwNix+Lp1C9+xRGW1VvrRNC1D1/XcwObZQC4iZFlZ5gTq9eud5YmwEKJpkkS4Gj/8EMOAAaXNdWL5cWwHD+LYtInSgQMtW27KsWkTaZdcgu3wYQ689hotpk3D30CfVEtPP539I0YQ9/77tJg3j1YzZ+IePBjXhAk48vLMXt5Nm7AVFwNgKAXdu+PJzKR42rTyHlhfp05mr2OExAQ+OavCQnN8bGDymPPnn0nQdWxFReVtvZ07lyfF3m7dMOrRU6r8fmK+/dYcq11QgK9VK4ouuYSSqVPx9O9PeuvW+CzWu9DchFjpZ46maaMBD3CIKoZFiOqlpRm0aycT5oRoDiQRrkJhoSI318mUKc1/opwqKiJx/nySnn8e29Gj+FNTKTn7bErOPZfSQYMimsQFi/nuO9JmzsSIjWX/O+/gzc5u+IPabLgmTcI1YQIJb75J8pNPknLvvfhatsSbmUnx9OnlCa/3/7d35+FRlWcfx7+zZg9JCAiiqFUECSiLAlKtigSSUEVRHsQFFEVttQq4otYiihVLtbVaF5S6ofSRF9yIiHW3IJVEERBFwYVNhCwsyUxmO+8fMwkhTFZmMieZ+3NduTJz5szML2cyT+6ceZbjj6dj9+6UmbTIMzp0wDNoEJ5Bg/ZvDASwbdlywOwK9q+/JnHZMiyBQIufK5CUFOyrPWYMVaef3h67HpheYzP9aK1vbPVQ7UyfPl5ZalmIdkD+QoVRvZBGux4o5/WSPH8+aX/7G7adO3GF5tRN/M9/SFq0iJT58/F164br/PNxjRmDr2fPmEVNLCwk8/rr8XfrRsn8+cGzrK3J4aBywgQqlcK6Zw+BTp3axxy0Viv+7t3xd+9O1YgR+7e7XMFFKoyWzajl79atxX21hWgrcnJ8/Oc/ibhcFpKSZPY5IdoqKYTDKC52YLG004U0AgES33iD9AcfxP7DD1QNGULp00/jPflkANyjR2OpqCDx7bdJWrSI1McfJ+3RR/H27o3lssuw5uYGB1u1kuRnn6XDXXfh7d+f0ueeI9DcqbQiKTGRQGJi7J6/tSQlBefpFULUq08fL4GAhfXr7QwY0A7/VggRJ8zxubfJVC+kkZbWvv7LT/joI7ILCsj6/e8xkpIoef55ShYurCmCqxkpKbjGjKH0xRfZUVTE7pkzMRISsE+fzmGnnEJHpUhasADLnj31PFMEGAZpf/4zGXfeiTs3lxKtY1sECyFELbWXWhZCtF1SCNcRCASXVm5P06Y5Vq+m47hxdBw/HmtZGWV//zs7336bqrPPbvQj/kCnTlRceSW73nwTz9q17Js6FdvWrWTedBNd+vUj8+qrSVy6FCI5NZjXS8aUKaQ9+igVl1xC2dy5GElJkXt8IYQ4RN26+cnICEghLEQbJ10j6ti40c6ePe1jIQ3bxo2kP/ggSW++iT8ri9333EPFZZe1fJGIHj3Ye9NN7J02Dcfnn5O0eDFJr71G0pIlERtkZ6moCBbXH3zAnptvZt+UKe2jP64Qol2xWKB3by9ffSWFsBBtmRTCdRQVBRu1gQPbbp8v644dpD30EMkvv4yRkMDeqVPZd801kVs22GLBO2AA3gED2HP33SR8/HGwKD7EQXbWnTvJmjABx7p1lM+ZQ+X48ZHJK4QQUZCT4+WFF1Lw+WKdRAjRUlII11Fc7KRDhwC/+lWMWjbDIOHDD7EVF5Pmav70bdY9e0j6v//D4vVSMWEC+268MTjLQbQ4HFQNG0bVsGHBQXZLl5K0ePH+QXY5OVSOGYNr9OgGB9nZvv+ejpdcgvWXXyidNy+4eIUQQphYnz5e3G4LmzbZ6dIl1mmEEC0hhXAd1QtpxGL6XEdxMen330/CihUYDgepzVjWt5phseAeOZK9t9yC/+ijIx+yoedOScF1wQW4LrgA686dJL3+OkmLF9Ph3ntJv+8+PEOHUnnBBbjz8zHS02vu5/j8c7ImTgTDoOSVV/D279+quYUQoiVqD5gbOjTGYYQQLSKFcC1791r45hs7o0a17kIa9u++I232bJIKC/FnZ1M+axbJN9zArmjOyhBl1YPsKq68EtvGjSS/+ipJixaROW0axvTpuHNzcY0ZA0DGddcR6NSJkhdfxH/ssTFOLoQQTXPssT4SEgwZMCdEGyaFcC2ff+7AMCyt1j/Yun17sC/vggUYycnsuflmKq6+GiMlhWSTLnPcEv5jjz1wkN2iRcGzxW++CYCnb19KX3ghul04hBAiwhwO6NXLK0stC9GGSSFcS1FRsPjs1y+6M0ZYystJfewxUufNA7+fiiuuCPbl7dgxqs8bc7UH2f3pTyR89BH2b7+l8tJLMVJTY51OCCGarU8fL0uWJGEYMmJOiLZICuFaioudHH+8lw4dorOQhsXlImXePFIfewzLnj24xowJ9uU98sioPJ+pORxUnX12cC5jIYRoo3r39jJ/fgqbN4OsLC5E2yOFcIhhBAvh/Pwo9A/2+Uj+979Je+ghbD//jPvss9lz++34eveO/HMJIYRoNdUD5lavtnDqqTEOI4RoNimEQ779FsrLrZFdM94wSCwsJG32bBwbN+IZMICyxx7DM2RI5J5DCCFEzPTu7cNiMaQQFqKNkkI4ZOXK4HxpkVpRzr5hAxk33YSzuBhvjx6UPvMM7pEjZZU0IYRoR5KTDX71Kx9ffNH86S6FELEnhXDIypUW0tIC9OhxiAMeDIPk55+nw8yZBJKTgyukjR0LdjnUQgjRHvXp4+WLL6SNF6ItisGyEea0cqWF/v0PbSENa0kJmZMmkXHHHVQNGcLOd98NLhMsRbAQQrRbOTk+fvzRQlmZfOInRFsjhTCwb5+FtWsPbf7ghI8+otPw4SR+8AG7Z8wIzovbuXMEUwohhDCjQYOqAPjww8QYJxFCNJcUwsDq1Q4CAQsDBrSgf3BVFen33EPH8eMJZGSw8803qZg8mZis0SyEEKLVDRzopWtXgyVLpBAWoq2Rao39C2n079+8Qti+YQOdfvtbUp96iorLL2dnYSG+nJxoRBRCCGFSViuce26A999PoLJSukcI0ZZIIUz1QhoGmZlNXEjDMEh+7jk65edj/flnSp59lt2zZkFSUnSDCiGEMKXzzw/gcll5//2EWEcRQjRD3BfChgFFRQ6GDAk0af9wA+KqcnOjnFIIIYSZnX66QWamn8JC6R4hRFsS99MZ/PijjdJSG4MHNz5tWsJHH5Fx441Yy8vZPWMGFVdeKX2BhRBCYLdDXp6bN95IoqoKEuTEsBBtQtwXwtX9gwcPbqBbRFUV6Q88QOpTT+E9/nhK5s+X5ZGFEKallMoD/g7YgKe11g/UuX0acBXgA3YCk7TWP7Z60HamoMDNyy+n8NFHCeTmVsU6jhCiCeL+dGZRkZOUlAC9e4cvhG0bN9LpnHMOHBAnRbAQwqSUUjbgMSAf6A2MV0rVbbQ+B07WWp8ILAQebN2U7dNpp1WRnh6gsFDGiwjRVsT9GeHiYgf9+nmx2cKP9M2YPh3b1q2UPPus9AUWQrQFg4DvtNabAJRSC4DRwFfVO2it36+1/6fApa2asJ1yOmH4cDfLliXi9YLDEetEQojGxPUZ4cpKC1995WDgwHqmTfN6cRQVUXnhhVIECyHaim7A5lrXt4S21edK4K2oJoojo0a5KS+3smKFdBIWoi2I6zPCX37pwO+vXkjj4EbLsX49Vrcbz8CBrR9OCCFaJtzHW2H7fimlLgVOBs6o5/argasBtNZkZ2dHKuMhs9vtpsxzwQVwww0G776bwZgxflNkMguz5QHzZZI8jYt0prguhKsHytW3tLJz1SoAKYSFEG3JFuDIWtePALbV3UkpNRy4EzhDax12ZJfW+ingqdBVY9euXRGO2nLZ2dmYNc9ZZ2Xy6qtO7r57FzabOTKZgdnygPkySZ7GtTTT4YcfHnZ7XHeNKC52cMwxPrKyws8h7Cgqwt+1K4FuDX2qKIQQpvIZ0EMpdYxSyglcBLxeewelVH/gSeBcrfUvMcjYrhUUuNi1y8ZnnzljHUUI0Yi4LYSDC2k4Q90iwnMWFcnZYCFEm6K19gHXA28D64Ob9Dql1Eyl1Lmh3f4CpAKvKKW+UEq9Xs/DiRY4++wqEhIMWVxDiDYgbrtGbN5sY+dOW70D5aw7dmDfvJmKSZNaOZkQQhwarXUhUFhn2921Lg9v9VBxJDXV4Iwz3BQWJjFjxh5Zd0kIE4vbt2dxcXX/4PCFsLOoCADPySe3WiYhhBDtQ0GBm+3bbXzxhcyhJoSZxW0hXFTkIDk5QK9e4ZdWdhYVYSQk4O3Tp5WTCSGEaOtyc93Y7YYsriGEyTWpa0Rjy3WG9lHADILT9KzWWl8cwZwRV1zs5KSTvNjrOQLOVavw9u0bnCFdCCGEaIaMDIPTTquisDCRO+/cgyX8mk1CiBhr9IxwU5brVEr1AKYDv9Za5wBTopA1YlwuWLu2gYU0PB4ca9ZItwghhBAtVlDg5scf7axbF7fDcYQwvaZ0jahZrlNr7QGql+usbTLwmNa6DMDs0/GsWePE57PUWwg71q7FUlUlM0YIIYRosbw8N1ardI8QwsyaUgg3ZbnO44HjlVL/VUp9GupKYVrFxcHBCwMGyEIaQgghoqNjxwCDB3tkGjUhTKwpn9c0ZblOO9ADOJPgKkYfK6X6aK3La+9kluU616yxc8wxBr16ZdVsq71kn23tWoyjjiIrJycm+ermMQuzZZI8jTNbJrPlAXNmEu3HqFEu7rorg2+/tdOjR/jB2UKI2GlKIdyU5Tq3AJ9qrb3A90qpbwgWxp/V3skMy3UaBqxYcRi//rWbXbv21+m1l+w7bPlyXIMHUx7DZQXb07KG0SJ5Gme2TGbLAy3LVN9SnULUlZfn5q67YMmSRKZM2RfrOEKIOprSNaLR5TqBV4GzAJRS2QS7SmyKZNBI2bbNxo4dtnpXlLNu3Ypt+3a80i1CCCHEIeraNcDAgR7pJyyESTVaCDdxuc63gRKl1FfA+8AtWuuSaIU+FEVFwf7BAwfW0z9YFtIQQggRQQUFLtatc/Djj7ZYRxFC1NGkOV2asFynAUwLfZlaUZGTxMQAJ5xQ/0C5QGIi3hNOaOVkQggh2qNRo9zce28HCgsT+d3vKmIdRwhRS9ytLFdUFFxIw1HPqpfO4mK8/fpR7w5CCCFEMxx5pJ8TT/SwZIl0jxDCbOKqEK6qgnXrHPVOm4bLhWPtWukWIYQQIqIKCtx8/rmTbdvi6s+uEKYXV+/INWsceDz1L6ThXLMGi9cr8wcLIYSIqIICFwBvvSVnhYUwk7gqhIuLnQD1zhjhCA2U8w4Y0GqZhBBCtH/HHuunVy+vLK4hhMnEVSFcVOTkiCN8HHZYIOztzqIifEcfTUAm1xdCCBFhBQVuVq50snNnXP3pFcLU4urdWFzsqLdbBIaBc9Uq6RYhhBAiKgoKXBiGhaVL5aywEGYRN4Xw9u1Wtm2z1z9Q7ocfsO3cKYWwEEKIqOjVy8cxx/hk9gghTCRuCuGiomD/4PrOCFtXrgRkIQ0hhBDRYbHAqFEuli93UlpqiXUcIQRxVAgXFztJSDDIyQl/RtiyYgWBlBR8vXq1cjIhhBDxoqDAjd9v4Z13pHuEEGYQN4VwUZGTvn29OJ3hb7esXBlcSMMmS2AKIYSIjhNP9HLEEdI9QgiziItC2OMJziFcX7cIS2Ulli+/lG4RQgghospigfx8Nx9/nMDevdI9QohYi4tCuLjYSVWVpf75g7/4AovfLwPlhBBCRN2oUW48Hgv/+Y90jxAi1uyxDhBtPh/MmJFOdraf3/ymKuw+ztBCGh5ZSEMI0Q4opfKAvwM24Gmt9QN1bv8N8DfgROAirfXC1k8ZvwYO9HDYYX4KCxM5/3xXrOMIEdfa/RnhuXNTWLPGyaxZu0lPN8Lu4ywqwujZEyMzs5XTCSFEZCmlbMBjQD7QGxivlOpdZ7efgMuBl1o3nQCwWiEvz8177yVQWSndI4SIpXZdCG/aZGPOnHTy8lyMGuUOv5Nh4CgqIjBkSOuGE0KI6BgEfKe13qS19gALgNG1d9Ba/6C1/hIIv8ymiLqCAhdut5X330+IdRQh4lq7LYQNA269NQOn02DWrN1Y6vmn2/b999hKSzEGD27dgEIIER3dgM21rm8JbRMmMmSIh8zMYPcIIUTstNs+wi+9lMyKFQn85S/ldOlS/0mP6v7BxqmntlY0IYSIpnD/9ofvF9YIpdTVwNUAWmuys7MPJVdE2e32Np/nvPNg4cIk0tLsJEThxHB7OEbRZrZMkqdxkc7ULgvh7dut3HtvOkOHVjF+fGWD+zpXrSKQno7RqxeUlrZSQiGEiJotwJG1rh8BbGvJA2mtnwKeCl01du3adYjRIic7O5u2nmfYsAT+9a+OLFq0l9zc8IO5WztTNJktD5gvk+RpXEszHX744WG3t7tC2DDgjjs64PXCgw+W19slopqzqAhP//5Yre22l4gQIr58BvRQSh0DbAUuAi6ObSQRzmmnVZGeHuCFF1IYNqxK1nMSIgbaXfX3xhuJLFuWxC237OWYY/wN7mvZuxf7N9/IQhpCiHZDa+0DrgfeBtYHN+l1SqmZSqlzAZRSpyiltgBjgSeVUutilzh+OZ1www17effdRKZOzcDf8J8sIUQUtKszwqWlFv74xw6ceKKHq66qaHR/x+efYwkE8A4ciAxXEEK0F1rrQqCwzra7a13+jGCXCRFjv/tdBVVVFv7yl3QMAx5+uBx7u/rLLIS5tau328yZHSgvt/LSSyVNakicRUUYFgue/v2jH04IIYQIY8qUfdhs8MAD6fj98MgjUgwL0VrazVvtgw8SeOWVZG64YS85Ob4m3cdZXIyvZ0+M9PQopxPiYIZh4Ha7CQQCWBrrzN5CO3bsoKoq8oNwWspseaD+TIZhYLVaSUxMjNrrI0S1P/whWAzPmpVOIGDhH/8ow+GIdSoh2r92UQhXVFi47bYOHHeclxtv3Nu0OwUCOIuKcP32t9ENJ0Q93G43DocDexRP/djtdmwmGoFjtjzQcCafz4fb7SYpKamVU4l49Pvf78NqNbj33g74/fDPf0oxLES0tYvBcrNnp7F1q405c3aT2MTOvvaNG7Hu3o1n4MDohhOiHoFAIKpFsDh0drudQEAWXxOt59prK/jTn3ZTWJjE736XiccT60RCtG9tvhBetcrBvHkpTJxYySmnNL3FcIQW0pBCWMSKfNzeNsjrJFrb1VdXMHPmbt56K4lrr5ViWIhoatOno6qq4JZbMuja1c/06XuadV/nqlUEMjLwH3tslNIJYW6lpaWMGzcOgJ07d2Kz2cjKygJgyZIlOJ3ORh9j6tSpXHfddRx33HH17vPss8+Snp7OmDFjIhNciDhw5ZUV2GwGd96ZweTJFp56qjQqq88JEe/adCH8j3+ksWGDgxdeKCE1tXkriDqLivAMGECjK24I0U5lZWXxzjvvAPDXv/6VlJQUrr322gP2MQyjZtBYOA8//HCjz3P55ZcfclYh4tHll1ditcL06RlcdVUWc+eWNrn7nxCiadps14j16+08+mgqY8ZUMmxY80ahW3bvxrFhgyykIUQY33//PcOGDeO2225j5MiR7Nixg1tvvZX8/HzOOuusA4rf8847j7Vr1+Lz+TjhhBO4//77GT58OOecc07NEpizZ89m7ty5AJxzzjncf//9jBo1itNPP53PPvsMgMrKSiZPnszw4cP5/e9/T35+PmvXrj0o25w5cygoKKjJZxjBf4A3btzI2LFjGT58OCNHjmTz5s0APPLII5x99tkMHz6cBx54IKrHTYhomDChktmzy3nvvUSuuioLtzvWiYRoX9rkGWG/P9glIi0twD33NK9LBASnTQPpHyzM4+670/nqq8gOD+/d28v991e26L4bNmzgoYceYvbs2QBMnz6dzMxMfD4fY8eOZdSoURx//PEH3GfPnj0MGTKEO+64gxkzZrBgwQKuv/76gx7bMAyWLFnCsmXL+Nvf/sb8+fOZN28enTp1Yu7cuaxbt468vLywua688kpuvvlmDMPguuuu4/3332fYsGFcd911TJs2jREjRuB2uzEMg2XLlvH+++/z5ptvkpSURFlZWYuOhRCxdumlldhscMstHbjiiizmzStFJjIRIjLa1Blhi8sFPh/PPJPC5587uffePWRlNX9Et7OoCMNqxSsLaQgR1lFHHUW/fv1qrr/22muMHDmSvLw8vv32WzZs2HDQfRITExk2bBgAJ554Ys1Z2bry8/MB6Nu3b80+//vf/xg9ejQAOTk59OzZM+x9P/nkE0aNGkVubi6ffvopGzZsoLy8nNLSUkaMGFGTIykpiU8++YSLLrqoZuqzzMzMlhwKIUxh/PhK/vrXcj7+OIHLL++IyyXd+oSIhLZzRtjjIWv8eHYfdhwP/ucFhg93M3q0q0UP5SgqwnfCCRgpKREOKUTLzJzZ/E82mqZlb/Hk5OSay5s2beLpp59myZIldOjQgT/84Q9hF6CoPbjOZrPh9/vDPnb1frX3qe7i0BCXy8Vdd93F0qVL6dq1K7Nnz8Yd+pw43MwOTXlMIdqSceNcWK0wdWoGEyZk8dxzpSQny++5EIei7ZwRdjqp+vVpdH7zZWb7b+HP95e1bJyb34+zuFi6RQjRRPv27SM1NZW0tDR27NjBBx98EPHnGDRoEG+88QYA69evD3vG2eVyYbVaycrKYt++fRQWFgKQkZFBVlYWy5YtA4ILlbhcLn7zm9+wYMECXK7gP8zSNUK0B2PHunjkkXI+/dTJZZdlsXmzuRaoEaKtaTtnhIFnjrwLGz5u8D7Mnlfs7JsypdmPYd+wAeu+fVIIC9FEffv2pUePHgwbNozu3btzyimnRPw5Jk2axI033sjw4cPp06cPPXv2JL3O0udZWVmMHTuWYcOGccQRR9C/Vtemf/zjH9x+++08+OCDOBwO5s6dS25uLl999RUFBQXY7XZyc3O59dZbI55diNY2ZkzwzPCUKRkMHdqZESPcTJpUwdChHpkISYhmssTw40Nj27ZtTd7Z64WhQzvT/Qgv/+k+gZSFCymfNYvKZk7NlPzii2Tcdhs7/vtf/EcfXbM9Ozu7ZpS7GZgtD5gvU1vPU1lZeUAXhGiw2+34fL6oPkdz1JfH5/Ph8/lITExk06ZNXHzxxXzyySetsvJeY8co3Ot0+OGHA8RbydGsNjva2vr7PxK2bbPy/PMpvPhiMmVlNnr18jJpUgVjxrhISjLkGDWB2TJJnsa1NFN97XabOSPscMDixSX4/bC721+x7t1Lxp13YqSn42rGRP3OVavwd+yI/6ijophWCNEcFRUVjBs3rqYgnT17tiw/LUQjDj88wO237+XGG/fy+utJPP10KrfemsH996dz8cUVTJkCMhRGiIa1qb80RxxRPfjGTtk//4l1wgQypkwhkJpKVWjEeGOcRUXBbhHy+ZEQptGhQweWLl0a6xhCtElJScGBdEq5+N//nDzzTApPPpnKE09AXl4mkyZVMGSIdJsQIpy2M1iursRESufNw3viiWRdey3O5csbvYu1tBT7pk14ZSENIYQQ7YzFAoMHe3jqqTJWrPiFm24KsHx5AhdemE1ubidefjkZV8smWxKi3Wq7hTBgpKZS8vzz+I4+mqzLL8exenWD+zuKigBZSEMIIUT71q2bn/vu87Nq1c/MmVMOwM03Z3DyyV24//40vvvOjswwKEQbL4QBjKwsSl56iUBWFlmXXII9zLRL1ZxFRRh2O96TTmrFhEIIIURsJCUFF+N4552dLFy4i6FDq3j88VTOOKMzOTldGDeuI3/+cxqFhYls3WqT4ljEnSb1EVZK5QF/B2zA01rrB+rcfjnwF2BraNOjWuunI5izQYEuXShZsIDs88+n4/jx7Hr1VfxHHnnQfs5Vq/Dm5GDI2pRCCCHiiMUCp57q4dRTPWzdauPDDxNYvdrB6tUOnngiFZ8v2IE4O9vPSSd5Q18e+vXzkp3d/BVchWgrGj0jrJSyAY8B+UBvYLxSqneYXf+tte4X+mq1Iria/+ijKXnpJSxuNx0vugjrL78cuIPPh+OLL6RbhBAhF1544UGLY8ydO5fp06c3eL8ePXoA8PPPPzN58uR6H3t1I12V5s6dW7PYBcBll13G7t27m5BcCHEounXzc/HFlcyevZulS3fxzTfbefPNncyaVc5ZZ1WxZYuNhx9OZeLEjpx0UhdOOaUzkydn8uijqXz0kZOffrLh8cT6pxAiMppyRngQ8J3WehOAUmoBMBqSaaUGAAARYElEQVT4KprBWsJ3wgmUPP88HS+6iI4XX8yuhQsxMjIAsH/9NVaXC68UwkIAMHr0aF577TXOPPPMmm2vvfYaf/zjH5t0/y5dujB37twWP//TTz/NBRdcQFLoE5oXXnihxY8lhGi5xETo399L//5eoBKAigoLa9Y4as4ar17tpLBw/6epFotB584BDj/cT9eufg4//OCvzp0D2GThO2FyTSmEuwGba13fAgwOs98FSqnfABuAqVrrzWH2iTrvwIGUPvMMHSdOpOOECZQsWICRnIxz1SoAPDJjhBAAjBo1igcffJCqqioSEhLYvHkzO3bsYNCgQVRUVHDFFVewe/dufD4ft956KyNHjjzg/ps3b2bixIm89957uFwupk2bxrfffstxxx2H2+2u2e/2229n9erVuN1uzjnnHKZNm8YzzzzDjh07GDt2LJmZmSxcuJDBgwfz1ltvkZWVxZNPPsm///1vAMaPH8/kyZPZvHkzl156KYMGDWLVqlV06dKFefPm1RTS1ZYtW8YjjzyCx+MhMzOTRx99lE6dOlFRUcFdd93Fl19+icViYerUqYwaNYr33nuPWbNm4ff7ycrKQmsd/YMvhMmlpBgMGeJhyJD9p37LyiysXetgyxY727bZ2LbNytatdr75xs777yfgch34IbPdbnDYYfsL42OOsZGUlEpmZoCsrACZmYGayxkZARyO1v4phWhaIRxu5sG63enfAF7WWlcppa4FngOG1b2TUupq4GoArTXZ2dnNjNtEY8bgs1pxjB/PYddei2/xYmxr12J07UrmSSeFnUPYbrdHL08LmC0PmC9TW8+zY8eOmkUjUu+6C/u6dRHN48vJYd9999W7MEXnzp0ZMGAAH330Efn5+bzxxhucd955OBwOUlJSeO6550hLS6OkpISCggIKCgqwhN47drsdW+hUj91uZ/78+SQnJ/PBBx+wbt06cnNzsdls2O127rzzTjIzM/H7/Vx44YV88803XHPNNcydO5dFixbRsWNHACwWCzabjXXr1qG15q233gIgPz+f0047jQ4dOvD999/z5JNP8vDDDzN58mTefvttLrzwwgN+rqFDh5Kfn4/FYuHFF1/kiSee4J577uGRRx6hQ4cOfPjhhwCUl5dTXl7OTTfdxKuvvspRRx1FWVnZQccrISHBVL9nTdGEcR0JwPPAQKAEGKe1/qG1c4q2JTPT4PTTPcDB/SIMA8rLLaEC+cCv7dttfPGFk7fftuJ2px/8wCHp6QcXx9UFc1qaQXKyQXJygKSk6ssGKSn7LycnGyQmGjJfsmiWphTCW4DaI8+OAA5YZ1NrXVLr6lxgdrgH0lo/BTwVumpEddm+004jac4cMqdNw3/RRVjXrsXdvz9lJSVhdzfbMoJmywPmy9TW81RVVdUUk4FAgEgvdx4IBAe4NLR88LnnnsvixYvJzc1l8eLFPPTQQ/h8PrxeL/fddx8rV67EYrHw888/s337djp37lzzmH6/v+by8uXLmTRpEj6fj549e3LCCSfg9/vx+XwsXryY+fPn4/f7+eWXX/j666/p2bMnhmHU7APUXF+xYgV5eXkkJCQAkJeXx/LlyxkxYgRHHnkkvXr1wufz0adPH3744YeDfr7NmzczefJkfvnlFzweD927d8fn8/Hhhx/yz3/+s2b/1NRUli1bxpAhQ+jWrRs+n4+0tLSDHq+qquqg1zW0VKcp1RrXkUuw/f5MKfW61rp2d7YrgTKt9XFKqYsIttnjWj+taC8slmChnJnpIycnfJuTnZ3N5s0llJZaKSuzhL4Hv+pe3rXLyoYNdsrKrFRUNH2CK4vFOKBQTk42SEgwcDoNnE5ISNh/PSEB0tNtGEZ6aBuh7UbNdYdj//fal8NvC1622w3sdrDZDGw2sNvB2ubn6Gq/mlIIfwb0UEodQ3BWiIuAi2vvoJTqqrXeHrp6LrA+oilbyDVuHNY9e+gwYwYAFRMnxjaQEPXYM3NmVB63sTd4Xl4e99xzD2vWrMHtdtO3b18AFi1aRElJCW+99RYOh4PBgwdTVVXV4GNZwpyG+emnn3jyySdZsmQJGRkZTJs27YBuE+E09A9BdXEMYLPZwj7WH//4R66++mpGjBjB8uXLeeihh2oeN1zGcNvauKaM6xgNzAhdXgg8qpSyaK1l8iwRVUlJBt26+enWren3qaoK9lmurLRSWWk56Mvlqr588O0ul4WqKgsejwWPB/bts+LxBLdVVYHPZ8XtTq65bhjRaQ8slv1FcXWBXLtQrr7scNiATqHbgwV09W2NXbZag5ctFkKXjTrXg9uqr4fbXv141fdNSbHhdqcdsK32l8USvN/BjxlsSmpvC37ff8a+etvBX0bY7dX7n3iiha5dI/faNFoIa619SqnrgbcJfsw2T2u9Tik1E1iltX4duEEpdS7gA0qByyMX8dBUTJ6Mdfdu0h5+GM/QobGOI4SppKSkcOqppzJt2jTOO++8mu179+4lOzsbh8PBf//7X7Zs2dLg4wwePJjFixfz61//mq+//pr169fXPE5SUhLp6ens3LmTd999l8GDg0MMUlNT2bdvH1lZWQc81pAhQ5g6dSrXX389hmGwdOlSHnnkkSb/THv27KFLly4AvPLKKzXbzzjjDP71r38xM/RPR3l5OQMHDuTOO+/kp59+onv37pSVlZGZmdnk5zKppozrqNkn1MbvBjoC5vmIRYiQhITgmdysLH/EH7v2J3mGAT4fBxTOXm+wQPZ6LXi9+7fVvuzxgMdz4Da/H/x+Cz4fBALg8x14ufbttS87HAlUVvrw+4P7+v2WsJc9HvD7raHtwdsMI/gzBALVXxYCgYO31d3P7w9WptWPHbyPpdZ9UgkEzHPCYPJkP6HzmxHRpHmEtdaFQGGdbXfXujwdaHjOpRjae/PNVFx6KYHQH0chxH7nnXceV111FY8//njNtjFjxjBx4kTy8/PJycnhuOOOa/AxJkyYwLRp0xg+fDi9e/emX79+AOTk5NCnTx/OOussunfvzqBBg2ruc8kll3DppZfSuXNnFi5cWLO9b9++jB07llGjRgHBwXJ9+vRh8+amjb+96aabuOaaa+jSpQsDBgyoud+NN97IHXfcwbBhw7BarUybNo2CggLmzJnDVVddRSAQIDs7mwULFjTtwJlXU8Z1NGWf1hvX0QJtfYxAazBbJrPlAfNlstst+HwtmWoj3Ic5h/4Bj91ur+kutr8wpqYAr11U1/0eblvt73UvH/hlCbs9EIDDDrNF9DWzRLpfYjMY27Zta3yvVtLW+5u2BrNlaut5KisrSU5OjmKiAxsxMzBbHmg8U7jXKdRH2DynSGpRSp0KzNBajwxdnw6gtf5zrX3eDu2zQillB34GOjXSNULa7AaYLQ+YL5PZ8oD5MkmexrU0U33tdpPOCAshhGgzGh3XAbwOTARWABcC70n/YCFEPJJxjEII0Y5orX1A9biO9cFNwXEdobEcAM8AHZVS3wHTgNtjk1YIIWJLzggLIUQ704RxHW5gbGvnEkIIs5EzwkLESAz754tmkNdJCCHaLymEhYgRq9VquoFj4kA+nw+rzIQvhBDtlnSNECJGEhMTcbvdVFVVRW1Rh4SEhEYXwmhNZssD9WcyDAOr1UpiYmIMUgkhhGgNUggLESMWi4WkpKSoPofZpr4xWx4wZyYhhBCtQz7zE0IIIYQQcUkKYSGEEEIIEZekEBZCCCGEEHEppkssx+qJhRAiAky5xHIUSZsthGjrDmq3Y3lG2GKmL6VUUawzmDmPGTNJnraXyWx5DjFTvIn5a1X7y2y/S2bLY8ZMZstjxkySJ+qZDiJdI4QQQgghRFySQlgIIYQQQsQlKYT3eyrWAeowWx4wXybJ0zizZTJbHjBnJtE4s71uZssD5stktjxgvkySp3ERzRTLwXJCCCGEEELEjJwRFkIIIYQQcSmullhWSh0JPA90AQLAU1rrv9fZ50zgNeD70KZFWuuZUcz0A7AX8AM+rfXJdW63AH8HCoBK4HKtdXGUsvQE/l1r06+Au7XWf6u1z5lE+fgopeYBvwV+0Vr3CW3LCmU7GvgBUFrrsjD3nQjcFbp6n9b6uSjl+QtwDuABNgJXaK3Lw9z3Bxp4fSOcaQYwGdgZ2u0OrXVhmPvmEfydsgFPa60fiFKefwM9Q7tkAOVa635h7vsDET5G9b3XY/l7JJpP2uwm5Yl5u222NruBTDFrt6XNblKmmLTbcVUIAz7gJq11sVIqDShSSr2jtf6qzn4fa61/24q5ztJa76rntnygR+hrMPB46HvEaa2/AfoBKKVswFZgcZhdo318ngUeJfiGqHY78K7W+gGl1O2h67fVvlPozfIn4GSCc54WKaVeD/eGiUCed4DpWmufUmo2ML1unloaen0jmQngYa31nPruFHpdHwNygS3AZ6FjVPc9cMh5tNbjaj3vX4HdDdw/0sco7HsduJzY/R6J5pM2uxEmabefxVxtdn2ZYtluh8sD0mbXFpN2O666Rmitt1f/Z6613gusB7rFNlWjRgPPa60NrfWnQIZSqmsrPO/ZwEat9Y+t8FwH0Fp/BJTW2TwaqP7v7jngvDB3HQm8o7UuDf3yvwPkRSOP1nqZ1toXuvopcMShPs+hZmqiQcB3WutNWmsPsIDgsY1antAZMgW8fKjP04w89b3XY/Z7JJpP2uxmi0m7bbY2u75MsWy3pc1uUqaYtNtxVQjXppQ6GugPrAxz86lKqdVKqbeUUjlRjmIAy5RSRUqpq8Pc3g3YXOv6FlrnD8FF1P8maM3jU+0wrfV2CL5ZgM5h9onVsZoEvFXPbY29vpF2vVLqS6XUPKVUZpjbY3GMTgd2aK2/ref2qB6jOu91M/8eiQZIm90kZmq3zf5eM0u7LW12GK3ZbsdlIayUSgX+D5iitd5T5+Zi4Cit9UnAP4BXoxzn11rrAQQ/TrtOKfWbOreHWwklqlN9KKWcwLnAK2Fubu3j0xyxOFZ3Evw4Z349uzT2+kbS48CxBD8m3Q78Ncw+rX6MgPE0fGYhaseokfd6fWJxjEQDpM1uXBttt2N1rMzSbkubHUZrt9txVwgrpRwED/B8rfWiurdrrfdorfeFLhcCDqVUdrTyaK23hb7/QrBf16A6u2wBjqx1/QhgW7TyhOQDxVrrHXVvaO3jU8uO6o8XQ99/CbNPqx6rUMf83wKXaK3DvuGa8PpGjNZ6h9bar7UOAHPrea7WPkZ2YAwHDuY5QLSOUT3vddP9HomGSZvdZGZrt035XjNTuy1tdtjnb/V2O64K4VC/l2eA9Vrrh+rZp0toP5RSgwgeo5Io5UkJdQhHKZUCjADW1tntdWCCUsqilBoC7K7+iCCK6v1vsDWPTx2vAxNDlycSHAFd19vACKVUZugjphGhbREXGsV7G3Cu1rqynn2a8vpGMlPtfojn1/NcnwE9lFLHhM4gXUTw2EbLcOBrrfWWcDdG6xg18F431e+RaJi02c1itnbbdO81s7Xb0mYf9NgxabfjakENpdRpwMfAGoJTcwDcAXQH0Fo/oZS6HvgdwY9NXMA0rfXyKOX5FftH99qBl7TWs5RS19bKYyE4sjOP4FQ8V2itV0UjTyhTMsF+Nr/SWu8ObaudJ+rHRyn1MnAmkA3sIDgS9FVAE3ytfgLGaq1LlVInA9dqra8K3XcSwdcUYJbW+l9RyjMdSGD/H5NPtdbXKqUOJzi9TUF9r++h5mkg05kEP2IzCE4xc43WenvtTKH7FgB/IzgVz7xIZAqXR2v9jFLqWYLH5ola+0b9GDXwXl9JjH6PRPNJm93kXDFtt83WZjeQKWbttrTZTcoUk3Y7rgphIYQQQgghqsVV1wghhBBCCCGqSSEshBBCCCHikhTCQgghhBAiLkkhLIQQQggh4pIUwkIIIYQQIi5JISyEEEIIIeKSFMJCCCGEECIuSSEshBBCCCHi0v8DQ634qTMx2EYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history = model.fit(X_train, y_train,\n",
    "                    epochs=20,\n",
    "                    verbose=False,\n",
    "                    validation_data=(X_test, y_test),\n",
    "                    batch_size=10)\n",
    "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
    "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
    "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
    "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))\n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to work with embeddings is by using a `MaxPooling1D`/`AveragePooling1D` or a `GlobalMaxPooling1D`/`GlobalAveragePooling1D` layer after the embedding. You can think of the pooling layers as a way to downsample (a way to reduce the size of) the incoming feature vectors.\n",
    "\n",
    "In the case of max pooling you take the maximum value of all features in the pool for each feature dimension. In the case of average pooling you take the average, but max pooling seems to be more commonly used as it highlights large values.\n",
    "\n",
    "Global max/average pooling takes the maximum/average of all features whereas in the other case you have to define the pool size. Keras has again its own layer that you can add in the sequential model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_3\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_2 (Embedding)      (None, 100, 50)           128750    \n",
      "_________________________________________________________________\n",
      "global_max_pooling1d_1 (Glob (None, 50)                0         \n",
      "_________________________________________________________________\n",
      "dense_5 (Dense)              (None, 10)                510       \n",
      "_________________________________________________________________\n",
      "dense_6 (Dense)              (None, 1)                 11        \n",
      "=================================================================\n",
      "Total params: 129,271\n",
      "Trainable params: 129,271\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "from keras.models import Sequential\n",
    "from keras import layers\n",
    "\n",
    "embedding_dim = 50\n",
    "\n",
    "model = Sequential()\n",
    "model.add(layers.Embedding(input_dim=vocab_size, \n",
    "                           output_dim=embedding_dim, \n",
    "                           input_length=maxlen))\n",
    "model.add(layers.GlobalMaxPool1D())\n",
    "model.add(layers.Dense(10, activation='relu'))\n",
    "model.add(layers.Dense(1, activation='sigmoid'))\n",
    "model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 1.0000\n",
      "Testing Accuracy:  0.7701\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history = model.fit(X_train, y_train,\n",
    "                    epochs=50,\n",
    "                    verbose=False,\n",
    "                    validation_data=(X_test, y_test),\n",
    "                    batch_size=10)\n",
    "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
    "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
    "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
    "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))\n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Use of Convolutional Neural Networks (CNN)\n",
    "\n",
    "Now let’s have a look how you can use this network in Keras. Keras offers again various Convolutional layers which you can use for this task. The layer you’ll need is the Conv1D layer. This layer has again various parameters to choose from. The ones you are interested in for now are the number of filters, the kernel size, and the activation function. You can add this layer in between the Embedding layer and the GlobalMaxPool1D layer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential_4\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_3 (Embedding)      (None, 100, 100)          257500    \n",
      "_________________________________________________________________\n",
      "conv1d_1 (Conv1D)            (None, 96, 128)           64128     \n",
      "_________________________________________________________________\n",
      "global_max_pooling1d_2 (Glob (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_7 (Dense)              (None, 10)                1290      \n",
      "_________________________________________________________________\n",
      "dense_8 (Dense)              (None, 1)                 11        \n",
      "=================================================================\n",
      "Total params: 322,929\n",
      "Trainable params: 322,929\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "embedding_dim = 100\n",
    "\n",
    "model = Sequential()\n",
    "model.add(layers.Embedding(vocab_size, embedding_dim, input_length=maxlen))\n",
    "model.add(layers.Conv1D(128, 5, activation='relu'))\n",
    "model.add(layers.GlobalMaxPooling1D())\n",
    "model.add(layers.Dense(10, activation='relu'))\n",
    "model.add(layers.Dense(1, activation='sigmoid'))\n",
    "model.compile(optimizer='adam',\n",
    "              loss='binary_crossentropy',\n",
    "              metrics=['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/dasun/anaconda3/envs/dm/lib/python3.6/site-packages/tensorflow_core/python/framework/indexed_slices.py:424: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n",
      "  \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training Accuracy: 1.0000\n",
      "Testing Accuracy:  0.7701\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "history = model.fit(X_train, y_train,\n",
    "                    epochs=10,\n",
    "                    verbose=False,\n",
    "                    validation_data=(X_test, y_test),\n",
    "                    batch_size=10)\n",
    "loss, accuracy = model.evaluate(X_train, y_train, verbose=False)\n",
    "print(\"Training Accuracy: {:.4f}\".format(accuracy))\n",
    "loss, accuracy = model.evaluate(X_test, y_test, verbose=False)\n",
    "print(\"Testing Accuracy:  {:.4f}\".format(accuracy))\n",
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hyperparameters Optimization\n",
    "\n",
    "One popular method for hyperparameter optimization is grid search. What this method does is it takes lists of parameters and it runs the model with each parameter combination that it can find. It is the most thorough way but also the most computationally heavy way to do this. Another common way, random search, which you’ll see in action here, simply takes random combinations of parameters.\n",
    "\n",
    "In order to apply random search with Keras, you will need to use the KerasClassifier which serves as a wrapper for the scikit-learn API. With this wrapper you are able to use the various tools available with scikit-learn like cross-validation. The class that you need is RandomizedSearchCV which implements random search with cross-validation. Cross-validation is a way to validate the model and take the whole data set and separate it into multiple testing and training data sets.\n",
    "\n",
    "There are various types of cross-validation. One type is the k-fold cross-validation which you’ll see in this example. In this type the data set is partitioned into k equal sized sets where one set is used for testing and the rest of the partitions are used for training. This enables you to run k different runs, where each partition is once used as a testing set. So, the higher k is the more accurate the model evaluation is, but the smaller each testing set is.\n",
    "\n",
    "First step for KerasClassifier is to have a function that creates a Keras model. We will use the previous model, but we will allow various parameters to be set for the hyperparameter optimization:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_model(num_filters, kernel_size, vocab_size, embedding_dim, maxlen):\n",
    "    model = Sequential()\n",
    "    model.add(layers.Embedding(vocab_size, embedding_dim, input_length=maxlen))\n",
    "    model.add(layers.Conv1D(num_filters, kernel_size, activation='relu'))\n",
    "    model.add(layers.GlobalMaxPooling1D())\n",
    "    model.add(layers.Dense(10, activation='relu'))\n",
    "    model.add(layers.Dense(1, activation='sigmoid'))\n",
    "    model.compile(optimizer='adam',\n",
    "                  loss='binary_crossentropy',\n",
    "                  metrics=['accuracy'])\n",
    "    return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, you want to define the parameter grid that you want to use in training. This consists of a dictionary with each parameters named as in the previous function. The number of spaces on the grid is 3 * 3 * 1 * 1 * 1, where each of those numbers is the number of different choices for a given parameter.\n",
    "\n",
    "You can see how this could get computationally expensive very quickly, but luckily both grid search and random search are embarrassingly parallel, and the classes come with an n_jobs parameter that lets you test grid spaces in parallel. The parameter grid is initialized with the following dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "param_grid = dict(num_filters=[32, 64, 128],\n",
    "                  kernel_size=[3, 5, 7],\n",
    "                  vocab_size=[5000], \n",
    "                  embedding_dim=[50],\n",
    "                  maxlen=[100])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now you are already ready to start running the random search. In this example we iterate over each data set and then you want to preprocess the data in the same way as previously. Afterwards you take the previous function and add it to the KerasClassifier wrapper class including the number of epochs.\n",
    "\n",
    "The resulting instance and the parameter grid are then used as the estimator in the RandomSearchCV class. Additionally, you can choose the number of folds in the k-folds cross-validation, which is in this case 4. You have seen most of the code in this snippet before in our previous examples. Besides the `RandomSearchCV` and `KerasClassifier`, the tutorial has added a little block of code handling the evaluation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from keras.wrappers.scikit_learn import KerasClassifier\n",
    "from sklearn.model_selection import RandomizedSearchCV\n",
    "from sklearn.externals import joblib\n",
    "\n",
    "# Main settings\n",
    "epochs = 20\n",
    "embedding_dim = 50\n",
    "maxlen = 100\n",
    "output_file = 'data/output.txt'\n",
    "\n",
    "sentences = df_yelp['sentence'].values\n",
    "y = df_yelp['label'].values\n",
    "\n",
    "# Train-test split\n",
    "sentences_train, sentences_test, y_train, y_test = train_test_split(\n",
    "    sentences, y, test_size=0.25, random_state=1000)\n",
    "\n",
    "# Tokenize words\n",
    "tokenizer = Tokenizer(num_words=5000)\n",
    "tokenizer.fit_on_texts(sentences_train)\n",
    "X_train = tokenizer.texts_to_sequences(sentences_train)\n",
    "X_test = tokenizer.texts_to_sequences(sentences_test)\n",
    "\n",
    "# Adding 1 because of reserved 0 index\n",
    "vocab_size = len(tokenizer.word_index) + 1\n",
    "\n",
    "# Pad sequences with zeros\n",
    "X_train = pad_sequences(X_train, padding='post', maxlen=maxlen)\n",
    "X_test = pad_sequences(X_test, padding='post', maxlen=maxlen)\n",
    "\n",
    "# Parameter grid for grid search\n",
    "param_grid = dict(num_filters=[32, 64, 128],\n",
    "                  kernel_size=[3, 5, 7],\n",
    "                  vocab_size=[vocab_size],\n",
    "                  embedding_dim=[embedding_dim],\n",
    "                  maxlen=[maxlen])\n",
    "model = KerasClassifier(build_fn=create_model,\n",
    "                        epochs=epochs, batch_size=10,\n",
    "                        verbose=False)\n",
    "grid = RandomizedSearchCV(estimator=model, param_distributions=param_grid,\n",
    "                          cv=4, verbose=1, n_iter=5)\n",
    "grid_result = grid.fit(X_train, y_train)\n",
    "\n",
    "# Evaluate testing set\n",
    "test_accuracy = grid.score(X_test, y_test)\n",
    "s = ('Running {} data set\\nBest Accuracy : '\n",
    "         '{:.4f}\\n{}\\nTest Accuracy : {:.4f}\\n\\n')\n",
    "print(s.format(source,\n",
    "        grid_result.best_score_,\n",
    "        grid_result.best_params_,\n",
    "        test_accuracy))\n",
    "\n",
    "\n",
    "filename = 'finalized_model.sav'\n",
    "joblib.dump(grid, filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pipelining\n",
    "\n",
    "A pipeline should be added for our classification task afterwards. We can use `Pipeline` from `sklearn.pipeline` for this.\n",
    "\n",
    "```\n",
    "from sklearn.pipeline import Pipeline\n",
    "original_pipeline = Pipeline([\n",
    "    ('vectorizer', tvec),\n",
    "    ('classifier', lr)\n",
    "])\n",
    "```\n",
    "\n",
    "[Link](https://towardsdatascience.com/yet-another-twitter-sentiment-analysis-part-1-tackling-class-imbalance-4d7a7f717d44#targetText=%E2%80%9CThe%20class%20imbalance%20problem%20typically,of%20some%20classes%20than%20others.&targetText=I%20will%20try%20fitting%20a,the%20learning%20of%20a%20classifier.).\n",
    "\n",
    "## Dealing with class imbalance problem.\n",
    "\n",
    "Two methods are addressed. TODO: Check out `imbalance-learn` docs. And take a look at this [code](https://github.com/coding-maniacs/over-under-sampling) from the [video](https://youtu.be/DQC_YE3I5ig). \n",
    "\n",
    "1. Oversampling: Generating \"fake\" examples of the minority class in order to balance the majority class. One implementation is `SMOTE`.\n",
    "2. Undersampling: Reducing (or trimming) examples from the majority class. One implementation is `NearMiss`.\n",
    "\n",
    "### Undersampling\n",
    "\n",
    "1. Prototype Generation: Generate new samples (do not use the existing ones)\n",
    "2. Prototype Selection: Use existing samples and recreate new samples.\n",
    "\n",
    "\n",
    "## Class Imbalance References\n",
    "\n",
    "1. [Towards Data Science](https://towardsdatascience.com/yet-another-twitter-sentiment-analysis-part-1-tackling-class-imbalance-4d7a7f717d44#targetText=%E2%80%9CThe%20class%20imbalance%20problem%20typically,of%20some%20classes%20than%20others.&targetText=I%20will%20try%20fitting%20a,the%20learning%20of%20a%20classifier.).\n",
    "2. [imbalanced-learn](https://github.com/scikit-learn-contrib/imbalanced-learn)\n",
    "3. [Yet another twitter sentiment analysis](https://github.com/tthustla/yet_another_tiwtter_sentiment_analysis_part1/blob/master/Yet_Another_Twitter_Sentiment_Analysis_part1-Copy1.ipynb?source=post_page-----4d7a7f717d44----------------------)\n",
    "\n",
    "## Entity Extraction\n",
    "\n",
    "Can be used to extract entities in utterences.\n",
    "\n",
    "1. [Named Entity Recognition with NLTK and SpaCy](https://towardsdatascience.com/named-entity-recognition-with-nltk-and-spacy-8c4a7d88e7da)"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}