cnn_w2v_wiki.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Emotion Classification in texts using LSTM and Word2Vec\n",
    "\n",
    "### Architecture: \n",
    "(X) Text -> Embedding (W2V pretrained on wikipedia articles) -> Deep Network (CNN 1D) -> Fully connected (Dense) -> Output Layer (Softmax) -> Emotion class (Y)\n",
    "\n",
    "#### Embedding Layer\n",
    "* Word Embedding is a representation of text where words that have the similar meaning have a similar representation. We will use 300 dimentional word vectors pre-trained on wikipedia articles. We can also train the w2v model with our data, however our dataset is quite small and trained word vectors might not be as good as using pretrained w2v.\n",
    "\n",
    "#### Deep Network\n",
    "* Though text data is one-dimensional, we can use 1D convolutional neural networks to extract features from our data. The result of each convolution will fire when a special pattern is detected. By varying the size of the kernels and concatenating their outputs, you’re allowing yourself to detect patterns of multiples sizes (2, 3, or 5 adjacent words). Patterns could be expressions like “I hate”, “very good” and therefore CNNs can identify them in the sentence regardless of their position. \n",
    "\n",
    "#### Fully Connected Layer\n",
    "* The fully connected layer takes the deep representation from the RNN/LSTM/GRU and transforms it into the final output classes or class scores. This component is comprised of fully connected layers along with batch normalization and optionally dropout layers for regularization.\n",
    "\n",
    "#### Output Layer\n",
    "* Based on the problem at hand, this layer can have either Sigmoid for binary classification or Softmax for both binary and multi classification output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Workflow: \n",
    "1. Import Data\n",
    "2. Prepare the input data\n",
    "3. Import pre-trained W2V\n",
    "4. Create Neural Network Pipeline\n",
    "5. Train The Model\n",
    "6. Evaluate results\n",
    "\n",
    "\n",
    "\n",
    "👋  **Let's start** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Import Data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# text preprocessing\n",
    "from nltk.tokenize import word_tokenize\n",
    "import re\n",
    "\n",
    "# plots and metrics\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix\n",
    "\n",
    "# preparing input to our model\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from keras.utils import to_categorical\n",
    "\n",
    "# keras layers\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Embedding, Conv1D, GlobalMaxPooling1D, Dense"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining vector space dimension and fixed input size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of labels: joy, anger, fear, sadness, neutral\n",
    "num_classes = 5\n",
    "\n",
    "# Number of dimensions for word embedding\n",
    "embed_num_dims = 300\n",
    "\n",
    "# Max input length (max number of words) \n",
    "max_seq_len = 500\n",
    "\n",
    "class_names = ['joy', 'fear', 'anger', 'sadness', 'neutral']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importing our training and testing datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train = pd.read_csv('data/data_train.csv', encoding='utf-8')\n",
    "data_test = pd.read_csv('data/data_test.csv', encoding='utf-8')\n",
    "\n",
    "X_train = data_train.Text\n",
    "X_test = data_test.Text\n",
    "\n",
    "y_train = data_train.Emotion\n",
    "y_test = data_test.Emotion\n",
    "\n",
    "data = data_train.append(data_test, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "joy        2326\n",
      "sadness    2317\n",
      "anger      2259\n",
      "neutral    2254\n",
      "fear       2171\n",
      "Name: Emotion, dtype: int64\n"
     ]
    },
    {
     "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>Emotion</th>\n",
       "      <th>Text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>neutral</td>\n",
       "      <td>There are tons of other paintings that I thin...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>sadness</td>\n",
       "      <td>Yet the dog had grown old and less capable , a...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>fear</td>\n",
       "      <td>When I get into the tube or the train without ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>fear</td>\n",
       "      <td>This last may be a source of considerable disq...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>anger</td>\n",
       "      <td>She disliked the intimacy he showed towards so...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>sadness</td>\n",
       "      <td>When my family heard that my Mother's cousin w...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Emotion                                               Text\n",
       "0  neutral   There are tons of other paintings that I thin...\n",
       "1  sadness  Yet the dog had grown old and less capable , a...\n",
       "2     fear  When I get into the tube or the train without ...\n",
       "3     fear  This last may be a source of considerable disq...\n",
       "4    anger  She disliked the intimacy he showed towards so...\n",
       "5  sadness  When my family heard that my Mother's cousin w..."
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data.Emotion.value_counts())\n",
    "data.head(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Prepare input data\n",
    "To input the data to our NN Model we'll need some preprocessing:\n",
    "1. Tokenize our texts and count unique tokens\n",
    "2. Padding: each input (sentence or text) has to be of the same lenght\n",
    "3. Labels have to be converted to integeres and categorized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic preprocessing and tokenization using nltk to double check that sentences are properly split into words.\n",
    "We could also add stopword removal but steps like stemming or lemmatization are not needed since we are using word2vec and words with the same stem can have a different meaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_text(data):\n",
    "    \n",
    "    # remove hashtags and @usernames\n",
    "    data = re.sub(r\"(#[\\d\\w\\.]+)\", '', data)\n",
    "    data = re.sub(r\"(@[\\d\\w\\.]+)\", '', data)\n",
    "    \n",
    "    # tekenization using nltk\n",
    "    data = word_tokenize(data)\n",
    "    \n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Making things easier for keras tokenizer 🙃"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "texts = [' '.join(clean_text(text)) for text in data.Text]\n",
    "\n",
    "texts_train = [' '.join(clean_text(text)) for text in X_train]\n",
    "texts_test = [' '.join(clean_text(text)) for text in X_test]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a bit ? I 'm extremely annoyed that he did n't phone me when he promised me that he would ! He 's such a liar .\n"
     ]
    }
   ],
   "source": [
    "print(texts_train[92])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tokenization + fitting using keras**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of unique words: 12087\n"
     ]
    }
   ],
   "source": [
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(texts)\n",
    "\n",
    "sequence_train = tokenizer.texts_to_sequences(texts_train)\n",
    "sequence_test = tokenizer.texts_to_sequences(texts_test)\n",
    "\n",
    "index_of_words = tokenizer.word_index\n",
    "\n",
    "# vacab size is number of unique words + reserved 0 index for padding\n",
    "vocab_size = len(index_of_words) + 1\n",
    "\n",
    "print('Number of unique words: {}'.format(len(index_of_words)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Padding** -> each input has the same length\n",
    "\n",
    "We defined maximun number of words for our texts and input size to our model has to be fixed - padding with zeros to keep the same input lenght (longest input in our dataset is ~250 words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[    0,     0,     0, ...,   119,    51,   345],\n",
       "       [    0,     0,     0, ...,    37,   277,   154],\n",
       "       [    0,     0,     0, ...,    16,     2,  1210],\n",
       "       ...,\n",
       "       [    0,     0,     0, ...,   876,     4,   909],\n",
       "       [    0,     0,     0, ...,     1,     6,   117],\n",
       "       [    0,     0,     0, ..., 10258,   173,    13]], dtype=int32)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_pad = pad_sequences(sequence_train, maxlen = max_seq_len )\n",
    "X_test_pad = pad_sequences(sequence_test, maxlen = max_seq_len )\n",
    "\n",
    "X_train_pad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Categorize** labels: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoding = {\n",
    "    'joy': 0,\n",
    "    'fear': 1,\n",
    "    'anger': 2,\n",
    "    'sadness': 3,\n",
    "    'neutral': 4\n",
    "}\n",
    "\n",
    "# Integer labels\n",
    "y_train = [encoding[x] for x in data_train.Emotion]\n",
    "y_test = [encoding[x] for x in data_test.Emotion]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 1.],\n",
       "       [0., 0., 0., 1., 0.],\n",
       "       [0., 1., 0., 0., 0.],\n",
       "       ...,\n",
       "       [0., 0., 0., 1., 0.],\n",
       "       [0., 1., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train = to_categorical(y_train)\n",
    "y_test = to_categorical(y_test)\n",
    "\n",
    "y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Import pretrained word vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Importing pretrained word2vec from file and creating embedding matrix\n",
    "* We will later map each word in our corpus to existing word vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_embedding_matrix(filepath, word_index, embedding_dim):\n",
    "    vocab_size = len(word_index) + 1  # Adding again 1 because of reserved 0 index\n",
    "    embedding_matrix = np.zeros((vocab_size, embedding_dim))\n",
    "    with open(filepath) as f:\n",
    "        for line in f:\n",
    "            word, *vector = line.split()\n",
    "            if word in word_index:\n",
    "                idx = word_index[word] \n",
    "                embedding_matrix[idx] = np.array(\n",
    "                    vector, dtype=np.float32)[:embedding_dim]\n",
    "    return embedding_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can download and import any pre-trained word embeddings. I will use 300 dimentional w2v pre-trained on wikipedia articles. Download fast text english vectors: https://fasttext.cc/docs/en/english-vectors.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "import zipfile\n",
    "import os\n",
    "\n",
    "fname = 'embeddings/wiki-news-300d-1M.vec'\n",
    "\n",
    "if not os.path.isfile(fname):\n",
    "    print('Downloading word vectors...')\n",
    "    urllib.request.urlretrieve('https://dl.fbaipublicfiles.com/fasttext/vectors-english/wiki-news-300d-1M.vec.zip',\n",
    "                              'wiki-news-300d-1M.vec.zip')\n",
    "    print('Unzipping...')\n",
    "    with zipfile.ZipFile('wiki-news-300d-1M.vec.zip', 'r') as zip_ref:\n",
    "        zip_ref.extractall('embeddings')\n",
    "    print('done.')\n",
    "    \n",
    "    os.remove('wiki-news-300d-1M.vec.zip')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12088, 300)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedd_matrix = create_embedding_matrix(fname, index_of_words, embed_num_dims)\n",
    "embedd_matrix.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the words from our corpus were not included in the pre-trained word vectors. If we inspect those words we'll see that it's mostly spelling errors. It's also good to double check the noise in our data f.e different languages or tokenizer errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words found in wiki vocab: 11442\n",
      "New words found: 645\n"
     ]
    }
   ],
   "source": [
    "# Inspect unseen words\n",
    "new_words = 0\n",
    "\n",
    "for word in index_of_words:\n",
    "    entry = embedd_matrix[index_of_words[word]]\n",
    "    if all(v == 0 for v in entry):\n",
    "        new_words = new_words + 1\n",
    "\n",
    "print('Words found in wiki vocab: ' + str(len(index_of_words) - new_words))\n",
    "print('New words found: ' + str(new_words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Create CNN Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Embedding Layer\n",
    "\n",
    "We will use pre-trained word vectors. We could also train our own embedding layer if we don't specify the pre-trained weights \n",
    "\n",
    "* **vocabulary size:** the maximum number of terms that are used to represent a text: e.g. if we set the size of the “vocabulary” to 1000 only the first thousand terms most frequent in the corpus will be considered (and the other terms will be ignored)\n",
    "* **the maximum length:** of the texts (which must all be the same length)\n",
    "* **size of embeddings:** basically, the more dimensions we have the more precise the semantics will be, but beyond a certain threshold we will lose the ability of the embedding to define a coherent and general enough semantic area\n",
    "* **trainable:** True if you want to fine-tune them while training\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Embedding layer before the actaul BLSTM \n",
    "embedd_layer = Embedding(vocab_size,\n",
    "                         embed_num_dims,\n",
    "                         input_length = max_seq_len,\n",
    "                         weights = [embedd_matrix],\n",
    "                         trainable=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Pipeline\n",
    "- the input is the first N words of each text (with proper padding)\n",
    "- the first level creates embedding of words, using vocabulary with a certain dimension, and a given size of embeddings\n",
    "- we will use 1D convolutional neural network to extract features from our data. The result of each convolution will fire when a special pattern is detected. By varying the size of the kernels and concatenating their outputs, you’re allowing yourself to detect patterns of multiples sizes (2, 3, or 5 adjacent words)\n",
    "- the output level has a number of neurons equal to the classes of the problem and a “softmax” activation function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Colocations handled automatically by placer.\n"
     ]
    }
   ],
   "source": [
    "# Convolution\n",
    "kernel_size = 3\n",
    "filters = 256\n",
    "\n",
    "model = Sequential()\n",
    "model.add(embedd_layer)\n",
    "model.add(Conv1D(filters, kernel_size, activation='relu'))\n",
    "model.add(GlobalMaxPooling1D())\n",
    "model.add(Dense(256, activation='relu'))\n",
    "model.add(Dense(num_classes, activation='softmax'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_1 (Embedding)      (None, 500, 300)          3626400   \n",
      "_________________________________________________________________\n",
      "conv1d_1 (Conv1D)            (None, 498, 256)          230656    \n",
      "_________________________________________________________________\n",
      "global_max_pooling1d_1 (Glob (None, 256)               0         \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 256)               65792     \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 5)                 1285      \n",
      "=================================================================\n",
      "Total params: 3,924,133\n",
      "Trainable params: 297,733\n",
      "Non-trainable params: 3,626,400\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "WARNING:tensorflow:From /Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/site-packages/tensorflow/python/ops/math_grad.py:102: div (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Deprecated in favor of operator or tf.math.divide.\n",
      "Train on 7934 samples, validate on 3393 samples\n",
      "Epoch 1/6\n",
      "7934/7934 [==============================] - 65s 8ms/step - loss: 1.3612 - acc: 0.4674 - val_loss: 1.0939 - val_acc: 0.6434\n",
      "Epoch 2/6\n",
      "7934/7934 [==============================] - 76s 10ms/step - loss: 0.8290 - acc: 0.7221 - val_loss: 0.7868 - val_acc: 0.7109\n",
      "Epoch 3/6\n",
      "7934/7934 [==============================] - 84s 11ms/step - loss: 0.6074 - acc: 0.7893 - val_loss: 0.7440 - val_acc: 0.7327\n",
      "Epoch 4/6\n",
      "7934/7934 [==============================] - 84s 11ms/step - loss: 0.4874 - acc: 0.8394 - val_loss: 0.7168 - val_acc: 0.7468\n",
      "Epoch 5/6\n",
      "7934/7934 [==============================] - 76s 10ms/step - loss: 0.3833 - acc: 0.8890 - val_loss: 0.7067 - val_acc: 0.7548\n",
      "Epoch 6/6\n",
      "7934/7934 [==============================] - 60s 8ms/step - loss: 0.2975 - acc: 0.9220 - val_loss: 0.7042 - val_acc: 0.7566\n"
     ]
    }
   ],
   "source": [
    "batch_size = 256\n",
    "epochs = 6\n",
    "\n",
    "hist = model.fit(X_train_pad, y_train, \n",
    "                 batch_size=batch_size,\n",
    "                 epochs=epochs,\n",
    "                 validation_data=(X_test_pad,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "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": [
    "# Accuracy plot\n",
    "plt.plot(hist.history['acc'])\n",
    "plt.plot(hist.history['val_acc'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation'], loc='upper left')\n",
    "plt.show()\n",
    "\n",
    "# Loss plot\n",
    "plt.plot(hist.history['loss'])\n",
    "plt.plot(hist.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = model.predict(X_test_pad)\n",
    "predictions = np.argmax(predictions, axis=1)\n",
    "predictions = [class_names[pred] for pred in predictions]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 75.66%\n",
      "\n",
      "F1 Score: 75.66\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy: {:.2f}%\".format(accuracy_score(data_test.Emotion, predictions) * 100))\n",
    "print(\"\\nF1 Score: {:.2f}\".format(f1_score(data_test.Emotion, predictions, average='micro') * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting confusion Matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, classes,\n",
    "                          normalize=False,\n",
    "                          title=None,\n",
    "                          cmap=plt.cm.Blues):\n",
    "    '''\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    '''\n",
    "    if not title:\n",
    "        if normalize:\n",
    "            title = 'Normalized confusion matrix'\n",
    "        else:\n",
    "            title = 'Confusion matrix, without normalization'\n",
    "\n",
    "    # Compute confusion matrix\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "    \n",
    "    # Set size\n",
    "    fig.set_size_inches(12.5, 7.5)\n",
    "    im = ax.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "    ax.grid(False)\n",
    "    \n",
    "    # We want to show all ticks...\n",
    "    ax.set(xticks=np.arange(cm.shape[1]),\n",
    "           yticks=np.arange(cm.shape[0]),\n",
    "           # ... and label them with the respective list entries\n",
    "           xticklabels=classes, yticklabels=classes,\n",
    "           title=title,\n",
    "           ylabel='True label',\n",
    "           xlabel='Predicted label')\n",
    "\n",
    "    # Rotate the tick labels and set their alignment.\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
    "             rotation_mode=\"anchor\")\n",
    "\n",
    "    # Loop over data dimensions and create text annotations.\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            ax.text(j, i, format(cm[i, j], fmt),\n",
    "                    ha=\"center\", va=\"center\",\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    fig.tight_layout()\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "F1 Score: 75.66\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAIUCAYAAAC5LUA6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd3wVVfrH8c8TAiIoEIpKEqQJUgVCE2wgoHQLFiwUsa+KfXXVtbu79u7uz10rFhCw0AQrKqh0UcFCC0KCLlItC5jL8/vjDnATEhKFm5u5fN+v17zMzJw595mTcXJ4zrkz5u6IiIiISOlLSXQAIiIiInsrdcREREREEkQdMREREZEEUUdMREREJEHUERMRERFJEHXERERERBJEHTGRJGRmt5rZC8HPB5vZz2ZWbg9/RraZdd+TdZbgMy82sx+C86mxG/X8bGYN9mRsiWJmC8ysS6LjEJE/Rh0xkT8g6IT818wqx2w7z8ymJjCsQrn7d+6+n7tHEh3L7jCz8sADwHHB+az5o3UFxy/dc9HteWb2rJndWVw5d2/u7lNLISQRiQN1xET+uHLA5btbiUXp/8XiHQhUBBYkOpCywMxSEx2DiOw+3fxF/rh7gWvMrFphO82ss5nNMrMNwX87x+ybamZ3mdl04FegQbDtTjP7OBg6G29mNczsRTPbGNRRL6aOh81sRbBvjpkdVUQc9czMzSzVzDoFdW9bNplZdlAuxcyuN7MlZrbGzF4xs+ox9Qwys+XBvht31TBmtq+Z3R+U32Bm08xs32Bf/2A4bX1wzk1jjss2s2vM7PPguFFmVtHMGgPfBMXWm9l7sedVoF3PC34+xMw+COr50cxGxZRzMzsk+LmqmT1vZquDeG/a1jE2s6FB7PeZ2TozW2ZmvXZx3tlmdm0Q/y9m9pSZHWhmb5rZT2b2jpmlxZQfbWbfBzF+aGbNg+0XAGcBf952LcTUf52ZfQ78EvxOtw8Rm9kkM7s/pv6RZvb0rn5XIpJY6oiJ/HGzganANQV3BB2YicAjQA2iQ2oTLf+8pkHABcD+wPJg28BgewbQEPgEeAaoDnwF3BJz/CygdbDvJWC0mVXcVcDu/kkwLLcfkAbMAF4Odl8GnAgcA6QD64DHg/NpBvwziC09OKfMXXzUfUBboHMQ35+BrUGH6mXgCqAWMAkYb2YVYo49DegJ1AcOA4a6+7dA82B/NXc/dlfnGbgDeCs4z0zg0SLKPQpUBRoE5z4YOCdmf0eincCawD3AU2Zmu/jcAUAPoDHQD3gTuCE43xRgeEzZN4FGwAHAXOBFAHd/Mvj5nuD31S/mmDOAPkTbIa/AZw8DBpnZsWZ2FtCBPZC1FZH4UUdMZPfcDFxmZrUKbO8DLHL3Ee6e5+4vA18T/cO8zbPuviDY/1uw7Rl3X+LuG4j+kV7i7u8Ef3BHA222HezuL7j7muD4+4F9gEN/R+yPAD8B27JbFwE3uvtKd98M3AqcEmScTgEmuPuHwb6/AlsLqzTIJg0DLnf3HHePuPvHwXGnAxPd/e3gnO8D9iXaYdsel7vnuvtaYDzRzuYf8RtQF0h3903uPq2QWMsR7fz+xd1/cvds4H6iHc5tlrv7v4M5ds8BtYkOkxblUXf/wd1zgI+AGe4+z903Aa+R/3f4dPC529q7lZlVLea8HnH3Fe7+v4I73P174OIgzoeBwe7+UzH1iUgCqSMmshvc/UtgAnB9gV3p7MhybbOcaKZrmxWFVPlDzM//K2R9v20rwRDeV8Gw1nqiWZ2aJYnbzC4EugBnuvu2DlVd4LVgyHA90QxchGinIz02Xnf/BShqsnxNonO5lhSyL1+7BJ+9gvzt8n3Mz78Sc86/058BA2YGQ6HDioi1PPl/VwV/T9vjcfdfgx93FVOJfodmVs7M/hEMBW8EsmNi2pXCrptY44nOX/ymsM6niJQt6oiJ7L5bgPPJ/8c7l2jHJtbBQE7Muv/RDwzmg/2Z6DBemrtXAzYQ7XiU5Ng7gBPcfWPMrhVAL3evFrNUDDI7q4A6MXVUIjo8WZgfgU1Eh1YLytcuwRBfHfK3S0n9Evy3Usy2g7b94O7fu/v57p4OXAg8sW1eWIFYt2XOtin4e4qXM4ETgO5EO9H1gu3bfodFXR/FXTd3Ee1E1zazM3YzRhGJM3XERHaTuy8GRpF/7s8koLGZnRlMqD4daEY0e7Yn7A/kAauBVDO7GahS3EFmVgd4heiQ1bcFdv8LuMvM6gZla5nZCcG+MUBfMzsymM91O0XcP4Is19PAA2aWHmR+OpnZPsFn9zGzbhZ9HMXVwGbg49919tHPWU20w3R28BnDiOn8mdmpZrZtHts6oh2YrQXqiAQx3WVm+wfnfhXwwu+N5w/Yn+i5ryHamfxbgf0/EJ23VmJmdjTR+W2DgSHAo2aWseujRCSR1BET2TNuB7Y/Uyx4xlVfoh2NNUSzV33d/cc99HlTgMnAt0SH0jZR/JAVQDeiQ41jbMc3J7c9DuJhYBzwlpn9BHxKdKI67r4AuITolwJWEe3YrNzF51wDfEH0CwVrgbuBFHf/Bjib6AT5H4nOmevn7ltKeN4FnQ9cS7SNm5O/Q9cemGFmPwfndXkRzw67jGh2bSkwLTjH0vim4fNEf3c5wEKi7R3rKaBZMFT8enGVmVmVoM5Lg7l5HwV1PFPMlwtEJIHM/Q+PjoiIiIjIblBGTERERCRB1BETERERSRB1xEREREQSRB0xERERkQTRS2MLkVJxf0+pXPBB6bIntaibVnwh2S0p+qJc3G3Vl51KhZo5vlZ8t5y1a34MzQ2jXJW67nk7vVhij/D/rZ7i7j3jUnkR1BErRErlWuzX8/ZEh5HU3n1yYKJDSHqVKpRLdAhJ7+dNBV/1KPGQt1U9sXjq2aVTokP4XTzvf+xz6GlxqXvTZ4+X6O0ke5KGJkVEREQSRBkxERERCREDS548kjpiIiIiEh4GJNEc2OTpUoqIiIiEjDJiIiIiEi5JNDSZPGciIiIiEjLKiImIiEi4aI6YiIiIiOwuZcREREQkRPT4ChEREZHE0dCkiIiIiOwuZcREREQkPIykGppMnjMRERERCRllxERERCRETHPERERERGT3qSMmIiIi4WIp8VmK+1iznmb2jZktNrPrC9l/sJm9b2bzzOxzM+tdXJ0amhQREZFwScDQpJmVAx4HegArgVlmNs7dF8YUuwl4xd3/aWbNgElAvV3Vq4yYiIiISPE6AIvdfam7bwFGAicUKONAleDnqkBucZUqIyYiIiIhEtcn69c0s9kx60+6+5PBzxnAiph9K4GOBY6/FXjLzC4DKgPdi/tAdcREREREon5093a7cfwZwLPufr+ZdQJGmFkLd99a1AHqiImIiEh4GIl6fEUOUCdmPTPYFutcoCeAu39iZhWBmsB/i6pUc8REREREijcLaGRm9c2sAjAQGFegzHdANwAzawpUBFbvqlJlxERERCRcEvCKI3fPM7NLgSlAOeBpd19gZrcDs919HHA18G8zu5LoxP2h7u67qlcdMREREQmRuE7W3yV3n0T0kRSx226O+XkhcMTvqVNDkyIiIiIJooyYiIiIhEuK3jUpIiIiIrtJGTEREREJDyNhc8TiQR0xERERCZfEPEcsLpKnSykiIiISMsqIiYiISIgk7vEV8ZA8ZyIiIiISMsqIiYiISLhojpiIiIiI7C5lxERERCRckmiOmDpiIiIiEh5mGpoUERERkd2njJiIiIiESxINTSbPmYiIiIiEjDpiZVy3w2oz697+zL3/BK7o13yn/X87uy0f/a03H/2tN7Pv68/yJ0/bvm/Mn49l+ZOnMfKaLqUYcfi8+/YUOrZpTvvDmvDw/ffstH/z5s2cO/hM2h/WhOO6dOa75dkA/Pbbb1xywTkc1aE1nbJa8tB9d5dy5OHx1pTJtGrehBZNG3HfPf/Yaf/mzZsZdOZAWjRtxNFHHM7y7Ox8+1d89x210vbnoQfuK6WIw+e9t6fQKas5HVo15ZEHCr+Ozx96Jh1aNaVn1yPyXceXXjiMYw5vwxHtWvLw/bqOi/L+O1M4sl0LOrdpyqMP3rvT/k+nf8RxR3ekTo1KTHjj1Xz7XnlpBEdkNeOIrGa88tKI0go5eW2bJ7anlwRIio6YmX2c6BjiIcWM+4Z24JR73qPjn8dzSqd6HJpRNV+ZG16Yw1E3TOKoGybx5FvfMH7Wd9v3PTJxIRf+c3pphx0qkUiE664azqhXxzN99ue8Onok33y1MF+ZF597mmrVqjHr86+56JLLue2vNwDwxmtj2Lx5Cx/N/Ix3p83guaf/vf2Pm+wQiUS48vJLeX38JObOX8DoUSP5amH+Nn72maeollaNL79axGXDr+CmG67Pt/+6a6/muON7lWbYoRKJRLju6st5eex4ps2az6tjRvHN1wWu4+efoWq1NGbO/4oLLxnOHbdEr+Nxr41hy+bNfPDpPN7+cAbPP/MfXceFiEQi3HDN5bw4ZhxTZ8znjTGj+Pbrr/KVycisw0NP/IeTThmYb/u6dWt54O47mfDuNCa+N50H7r6T9evXlWb4UoYlRUfM3TsnOoZ4aNuwBkt/+Inlq3/mt8hWxn6aTe+2mUWWH9CpHmM+yd6+/uGC7/l5U178Aw2xubNnUr9BQ+rVb0CFChU46ZTTeXPi+Hxl3pw4noFnDQKg/0kD+Gjqe7g7hvHrr7+Ql5fHpv/9j/IVKrD//lUScRpl2uxZM2nY8BDqN4i28Smnnc6E8W/kKzNx/DjOHjQEgJMGnMLU99/F3QEY98br1Ktfj6bNmpV26KExd/as/NfxgNOYXOA6njxxPKefEb2O+504gI+mvh+9jq3AdVy+vK7jQsybM4t6DRpSt160jU8YcBpTJuVv4zp169GsRUtSUvL/aZ367tsc3bUbaWnVqVYtjaO7duP9d94qzfCTTPCKo3gsCZAUHTEz+9mi7jWzL83sCzM7Pdj3vJmdGFP2RTM7IXHRllzt6pXIWfPr9vXctb9SO61SoWXr1KxM3Vr78eGCH0orvKSwKjeX9Mwdndv0jAxW5ebsVCYjsw4AqampVKlalbVr1tD/pAFUqlSZ5g3r0LppAy4ZfiVp1auXavxhkJuTQ0ZMG2dkZJJboI2jZfK38Zo1a/j555954L57uOGmW0o15rD5flX+Nq6dnsGq3Nwiy6SmprJ/laqsXbuGfidGr+OWjQ4mq3lD/jT8Kl3Hhfh+VS7pGXW2r9dOz2DVqpxdHBF7bE6BYzP5voTHShE0NFkmnQy0BloB3YF7zaw28BQwFMDMqgKdgYkFDzazC8xstpnN3rppY6kFvaecfHhdxs1cztYgiyDxN3f2TMqVS+HLxd8x58tFPPHoQ2QvW5rosJLKXXfcymXDr2C//fZLdChJa+6cWaSUK8fn3y5n1hff8s9HH9R1LFKKkqkjdiTwsrtH3P0H4AOgvbt/ADQys1rAGcBYd99pvM7dn3T3du7eLqVi2UjLr1r7Kxk1dmTA0qtXYtW6XwstW3BYUkqmdno6uStXbl/PzcmhdnrGTmVyVq4AIC8vj40bNlC9Rg3GvjKSbj2Op3z58tQ64AA6Ht6Jz+bOKdX4wyA9I4OcmDbOyVlJeoE2jpbJ38Y1atRg1syZ3HjDdTRpVJ/HH32Ye+/+O/984rFSjT8MDqqdv41X5eZQOz29yDJ5eXn8tHED1avX4NVXRnJs9+Oi13GtA+hweGfmz9N1XNBBtdPJzVmxfX1Vbg61a2fs4ojYYzMKHLuSg0p4rBTC0NBkCD0PnA2cAzyd4FhKbO7SNTQ8aH/q1qpM+XIpDDi8Hm/OWblTuUa1q1CtcgVmLvoxAVGGW5u27Vm6ZDHLs5exZcsWXhszip69++Yr07N3X0a+GP2W07jXxnLUMV0xMzLrHMxHH7wPwC+//MLsmTNpdOihpX4OZV3bdu1ZvHgR2cuibTzmlVH06ds/X5neffvxwojnAHht7BiO6XIsZsY773/I14uW8fWiZVxy2eVce91fuPhPlybiNMq0Nm3bsXRpzHU89hWOL3AdH9+7L6Nejl7H418fy5HHdMHMyKhTh2kfTgWi1/GcWTM4pLGu44JaZ7Vj2ZLFfBe08RtjX+G4Xn2LPxDo0q0HH7z3DuvXr2P9+nV88N47dOnWI84RS1gk0wNdPwIuNLPngOrA0cC1wb5ngZnA9+6+sPDDy57IVufaZ2cx9rpulEsxXvhgCV/nbOCGAYcxb9la3pwb7ZQN6FSPsZ9k73T8pL8eR+P0KlSumMqCR0/isic/5b0vVpXuSZRxqamp/OP+hzn1xD5sjUQ4c9BQmjRrzt/vuJXWWW3p1acfZw0Zxp/OG0r7w5pQLS2Nfz/7IgDDLriY4RedxxHtWuHunDFoCM1bHJbgMyp7UlNTeeChR+nfpyeRrREGDzmHZs2bc/utN5PVth19+/Vn6Dnncu7QwbRo2oi0tOo8/8LLiQ47VFJTU/nHvQ9x+kl9iES2cuagITRp2px/3Bm9jnv27sdZg8/hkguG0qFVU9LS0vi/Z14AYNj5F3P5n87jqA7R63jg2bqOC5Oamspd9z7EmQP6EolEGHj2UA5t2ox77rqNVm2yOL53Pz6bO5tzzz6N9evX8fbkidz399uZ+ulnpKVV54prb6B31+j3yq78842kpWke3h9nSfVAV/MkmFNkZj8BVYB7gF6AA3e6+6iYMpOB1939X8XVl1qjge/X8/Z4hSvAkicHFl9IdkulCuUSHULS07eSS0fe1vD/nSrLenbpxPx5c0Lz8saUanV9n6Oui0vdmyZcMsfd28Wl8iKEPiNmZjWAtR7tUV7LjixYbJlKQCNA/8wWEREJO730u2wws3TgE6DIx22bWXfgK+BRd99QWrGJiIhInCTRZP1QZ8TcPRdoXEyZd4C6pRORiIiISMmFuiMmIiIieyENTYqIiIjI7lJGTERERMLDkuvxFclzJiIiIiIho4yYiIiIhEsSzRFTR0xERERCxZKoI6ahSREREZEEUUZMREREQsNQRkxERERE9gBlxERERCQ8LFiShDJiIiIiIgmijJiIiIiEiCXVHDF1xERERCRUkqkjpqFJERERkQRRRkxERERCRRkxEREREdltyoiJiIhIqCgjJiIiIiK7TRkxERERCQ890FVEREQkMSx4jlg8lmI/26ynmX1jZovN7PpC9j9oZp8Fy7dmtr64OpURExERESmGmZUDHgd6ACuBWWY2zt0Xbivj7lfGlL8MaFNcvcqIiYiISKgkKCPWAVjs7kvdfQswEjhhF+XPAF4urlJ1xERERESKlwGsiFlfGWzbiZnVBeoD7xVXqYYmRUREJFTi+PiKmmY2O2b9SXd/8g/UMxAY4+6R4gqqIyYiIiKhEseO2I/u3q6IfTlAnZj1zGBbYQYCl5TkAzU0KSIiIlK8WUAjM6tvZhWIdrbGFSxkZk2ANOCTklSqjpiIiIiEh8Vx2QV3zwMuBaYAXwGvuPsCM7vdzPrHFB0IjHR3L8npaGhSREREpATcfRIwqcC2mwus3/p76lRHTEREREJF75oUERERkd2mjJiIiIiExrZXHCULdcREREQkVJKpI6ahSREREZEEUUZMREREwiV5EmLKiImIiIgkijJiIiIiEh6WXHPE1BErRMu61Xn/P2ckOoykVvu42xIdQtJb867aON4q76NbaGnYEtma6BCSWkoSdWrCSHcRERERCRVlxEREREQSJJk6YpqsLyIiIpIgyoiJiIhIaCTbk/WVERMRERFJEGXEREREJFySJyGmjJiIiIhIoigjJiIiIuGhB7qKiIiIJE4ydcQ0NCkiIiKSIMqIiYiISKgoIyYiIiIiu00ZMREREQmX5EmIKSMmIiIikijKiImIiEioJNMcMXXEREREJDTM9K5JEREREdkDlBETERGRUFFGTERERER2mzJiIiIiEirKiImIiIjIblNGTERERMIleRJi6oiJiIhIuGhoUkRERER2mzJiIiIiEh6mjJiIiIiI7AHKiImIiEhoGJBECTF1xERERCRM9K5JEREREdkDlBETERGRUEmihJgyYiIiIiKJooyYiIiIhIrmiImIiIjIblNGTERERMLDkmuOmDpiIiIiEhoGpKQkT09MQ5MiIiIiCaKMmIiIiIRKMg1NKiMmIiIikiDqiImIiEiomFlclhJ8bk8z+8bMFpvZ9UWUOc3MFprZAjN7qbg6NTQpIiIiUgwzKwc8DvQAVgKzzGycuy+MKdMI+AtwhLuvM7MDiqtXGbEy7p23JtO+VTOyWhzKg/fdvdP+zZs3M2zQGWS1OJTuR3fiu+XZ2/d9+cXnHNflCDq1PYzO7VuzadOmUow8PHp0OIT5Lw7ny5cv55qzjtppf50DqjL54XP45KmLmfnsnzj+8Ebb911z9lF8+fLlzH9xON07HFKaYYfKW1Mm07pFE1o2bcR99/5jp/2bN29m8FkDadm0EccceTjLs7Pz7V/x3XccUH1/HnrgvlKKOHzUxvGn+3EZETy+Ih5LMToAi919qbtvAUYCJxQocz7wuLuvA3D3/xZXaag6YmY23My+MrMXEx1LaYhEIlx75XBGvz6BT+d+wdjRo/j6q4X5yox49mmqVktj7pffcPFlV3DrTX8BIC8vjwvPHcL9jzzBJ3M+Z8LkdylfvnwiTqNMS0kxHrqqLydcM4I2gx7j1O4taVKvVr4y1w05hrHvf0mnc//J4FtH8/BVfQFoUq8Wp3ZrSdbgx+h/zfM8fFXfpPpK9Z4SiUS46vJLeW3cJObMX8DoUSP5qsB1/NwzT1GtWjW++GoRlw6/gr/emD/jf/2fr+a443uVZtihojaOP92Pyw4jrkOTNc1sdsxyQcxHZwArYtZXBttiNQYam9l0M/vUzHoWdz6h6ogBfwJ6uPtZf7QCMwvNcOyc2TNp0LAh9eo3oEKFCpx8ymlMmjAuX5k3J47jjLMHAXDCSQP4YOp7uDvvvfMWzVu0pOVhrQCoXqMG5cqVK/VzKOvaN81kSc5aslet47e8CKPf/YK+RzbJV8bdqVJpHwCqVq7Iqh9/AqDvkU0Y/e4XbPktwvJV61mSs5b2TTNL/RzKutmzZtKg4SHUbxC9jk857XQmjH8jX5kJ48dx1qAhAJx08ilMff9d3B2A8W+8Tt169WjarFmpxx4WauP40/14r/Gju7eLWZ78ncenAo2ALsAZwL/NrNquDghNR8zM/gU0AN40sxvN7Gkzm2lm88zshKBMPTP7yMzmBkvnYHuXYPs4YOEuPqZMWZWbS0ZGne3r6RmZrMrNzVcmN6ZMamoqVapUZe2aNSxZvAgzY0D/XhzTqT0PP3BvqcYeFum19mflfzdsX89ZvZGMmlXylbnrmfcZeFwrFo+9mtfuPZurHpoIQEbNKvmP/e8G0mvtXzqBh0hubg6ZdXZ0UDMyMlmVk7Nzmcz81/GaNWv4+eefeeD+e7jhpltKNeawURvHn+7HZUl8smElmKyfA9SJWc8MtsVaCYxz99/cfRnwLdGOWZFCkx1y94uCFF9X4CrgPXcfFvQ0Z5rZO8B/iWbMNgUT5l4G2gVVZAEtgobZSZB+vAAgs87BcT6b+MvLy+PTj6fz3kefsm+lSpzYuwet22RxTNduiQ4tdE7rfhgvvDmPh0d9TMfmdXjqrwNoO/jxRIe1V7jrjlu5dPgV7LfffokOJWmpjeNP9+OkMQtoZGb1iXbABgJnFijzOtFM2DNmVpPoUOXSXVUamo5YAccB/c3smmC9InAwkAs8ZmatgQjRBthmZlGdMIAg/fgkQJusdh6XqH+n2unp5OTsGI7OzVlJ7fT0fGXSgzIZmZnk5eWxceMGqteoQXpGJp2PPIoaNWsC0OP4Xsz/bJ7+xy8gd/VPZB5Qdft6Rq0q5Py4MV+ZIX2yOOGa5wGYsWAFFSukUrNqJXJ+3Jj/2AOqkrv6p9IJPETS0zNYuWLl9vWcnJXUzsjYuczK/NdxjRo1mD1rJq+/NpabbriODevXk5KSQsWKFbnoT5eW9mmUaWrj+NP9uGxJxANd3T3PzC4FpgDlgKfdfYGZ3Q7Mdvdxwb7jzGwh0X7Ite6+Zlf1hmZosgADBrh762A52N2/Aq4EfgBaEc2EVYg55pcExLlbstq2Z8nixSzPXsaWLVt4dcwr9OrTL1+Znr378fILIwB447WxHH1MV8yMbt2PY+GXX/Lrr7+Sl5fH9GkfcmiTpok4jTJt9tc5HJJZnbq1q1E+tRyndmvJxGlf5yuz4ocNdGnbAIBD69akYoVUVq//hYnTvubUbi2pUL4cdWtX45DM6sz6amVhH7NXa9uuPUsWLyJ7WfQ6HvPKKPr07Z+vTJ++/XhxxHMAvPbqGI7pcixmxtvvfchX3y7jq2+Xcclll3PNn/+iDkIh1Mbxp/uxALj7JHdv7O4N3f2uYNvNQScMj7rK3Zu5e0t3H1lcnWHNiE0BLjOzy9zdzayNu88DqgIr3X2rmQ0h2mMNrdTUVO554GEG9O9NJBLhrMFDadqsOX+7/RZaZ7Wjd99+DBo6jIvOHUJWi0NJS0vjqeejz46rlpbGn4ZfQbejDgczehzfk+N79UnwGZU9kchWrnxwIuPvH0y5lBSemziXr7JX89dzj2Xu1zlMnP4N1z8+mSf+fAKXndYZd+f8v70GwFfZqxn73pfMG3EZeZGtXPHARLZuLRPJ1DIlNTWV+x96lBP69iQSiTB46Dk0a9acO267maysdvTp158h55zLeecMpmXTRqRVr85zI15OdNihojaOP92Py5aSPHw1LGzbt2bCwMyyiWa6fgEeAjoTzeotc/e+wbywsYADk4FL3H0/M+sCXOPufUvyOW2y2vn702fE4Qxkm9rH3ZboEJLemnfVxpIctkS2JjqEpNb1iI7Mmzs7ND2bShmHepML/xmXuufd0m2Ou7crvuSeE6qMmLvXi1m9sJD9i4DDYjZdF2yfCkyNY2giIiIiv1uoOmIiIiKyd9v2QNdkEdbJ+iIiIiKhp4yYiIiIhEoSJcSUERMRERFJFGXEREREJFSSaY6YOmIiIiISKknUD9PQpIiIiEiiKCMmIiIi4WHJNTSpjJiIiIhIgigjJiIiIqERfaBroqPYc5QRExEREUkQZcREREQkRE8F6IUAACAASURBVCyp5oipIyYiIiKhkkT9MA1NioiIiCSKMmIiIiISKsk0NKmMmIiIiEiCKCMmIiIi4WGaIyYiIiIie4AyYiIiIhIa0Qe6Jk9KTB0xERERCZVk6ohpaFJEREQkQZQRExERkVBJooSYMmIiIiIiiaKMmIiIiIRKMs0RU0dMREREwkPPERMRERGRPUEZMREREQkNw5JqaFIZMREREZEEUUZMREREQiWJEmLKiImIiIgkijJiIiIiEiopSZQSU0dMREREQiWJ+mEamhQRERFJFGXEREREJDTMkuvJ+sqIiYiIiCSIMmIiIiISKinJkxBTRkxEREQkUZQRExERkVBJpjli6ogVwgxSkynvWQb98PatiQ4h6R046PlEh5D0FvxzYKJD2CtU3Vd/qiS/JOqHaWhSREREJFH0zwwREREJDQOM5EmJKSMmIiIikiDKiImIiEioJNM0bmXERERERErAzHqa2TdmttjMri9k/1AzW21mnwXLecXVqYyYiIiIhIdZQh5fYWblgMeBHsBKYJaZjXP3hQWKjnL3S0tarzpiIiIiEioJenxFB2Cxuy+NxmAjgROAgh2x30VDkyIiIiLFywBWxKyvDLYVNMDMPjezMWZWp7hK1RETERGR0DAgxSwuC1DTzGbHLBf8zvDGA/Xc/TDgbeC54g7Q0KSIiIhI1I/u3q6IfTlAbIYrM9i2nbuviVn9D3BPcR+ojJiIiIiEill8lmLMAhqZWX0zqwAMBMblj8tqx6z2B74qrlJlxERERESK4e55ZnYpMAUoBzzt7gvM7HZgtruPA4abWX8gD1gLDC2uXnXEREREJFQS8fgKAHefBEwqsO3mmJ//Avzl99SpjpiIiIiERgmHEUNDc8REREREEkQZMREREQmVlCRKiSkjJiIiIpIgyoiJiIhIqCRPPkwZMREREZGEUUZMREREQiVRj6+IB3XEREREJDSi75pMdBR7TpEdMTOrsqsD3X3jng9HREREZO+xq4zYAsDJPydu27oDB8cxLhEREZGdme0dQ5PuXqeofSIiIiKy+0r0rUkzG2hmNwQ/Z5pZ2/iGJSIiIlK4ba852tNLIhTbETOzx4CuwKBg06/Av+IZlIiIiMjeoCTfmuzs7llmNg/A3deaWYU4xyUiIiJSqL1ijliM38wshegEfcysBrA1rlGJiIiIFCLZHl9RkjlijwNjgVpmdhswDbg7rlGJiIiI7AWKzYi5+/NmNgfoHmw61d2/jG9YIiIiIoXb24YmAcoBvxEdntT7KUVERET2gJJ8a/JG4GUgHcgEXjKzv8Q7MBEREZHCWJyWRChJRmww0MbdfwUws7uAecDf4xmYiIiISEFmkJJEQ5MlGWZcRf4OW2qwTURERER2w65e+v0g0Tlha4EFZjYlWD8OmFU64YmIiIjkl0QJsV0OTW77ZuQCYGLM9k/jF46IiIjI3mNXL/1+qjQDERERESmJverxFWbWELgLaAZU3Lbd3RvHMS4RERGRpFeSyfrPAs8Q/WZnL+AVYFQcYxIREREpkll8lkQoSUeskrtPAXD3Je5+E9EOmYiIiEipMowUi8+SCCXpiG0OXvq9xMwuMrN+wP5xjksCb781mTYtm9KqWWPuv3fnV3xu3ryZIWcPpFWzxnQ9qhPLs7MBWJ6dTa1qlencIYvOHbK4/NKLSzny8Hjnrcm0PawprZs35oEi2njo2QNp3bwxxx7VieXLs7fv+/KLz+l+zBF0zGpJp3at2LRpUylGHh7dW6Uz98ET+ezhk7jqhBY77f/74PZMv7sf0+/ux7wHT2TF02cA0LJuGu/e0YuZ953AJ/f04+RO9Uo58vCY+u5bdO3QkqPbNeOJh+7daf+Mjz+id9fDaXBAZSaOe3X79gVfzOfE44+he+c2HH9UO8a/Nro0ww6Vd96aTLtWzWjT4lAevK/we8U5g86gTYtD6Xb0zveKHl2O4PC2h9G5fWvdK2S7kjzQ9UqgMjCc6FyxqsCweAYlUZFIhKsvv4w3Jk4hIzOTY47oSJ++/WjStNn2Ms8/+zTVqqUxf+G3jHllJDffdD3PvTASgPoNGvLxzLmJCj8UIpEIV19xGa9PnEJGRiZdj+xI78LaOC2NzxZE2/iWG6/n2RdGkpeXxwXDBvN/Tz1Hy8NasXbNGsqXL5/AsymbUsy4f9jhnHDXW+Ss+ZUP/t6HibNX8E3Ohu1l/vL8jifiXNizCa3qVQfgf1siXPD4NJZ8/xMHpe3LR3/vy7vzc9jw62+lfh5lWSQS4a9/vpwXx07koPRM+nc/gu49+9K4SdPtZdIz63D/Y//myccezHfsvvtW4sEnnqJ+w0P4YVUufbp15uhje1C1arXSPo0yLRKJcM2Vw3l9wmTSMzLpetTh9OqT/14xIrgfz/vyG8aOHsWtN/2FZ0a8HL1XnDuE//vPs7pX7AkJHEaMh2IzYu4+w91/cvfv3H2Qu/d39+mlEVw8WFQo3pc5e9ZMGjRsSP0GDahQoQIDTj2dCePH5SszcfwbnHn2YABOPPkUpr7/Hu6eiHBDac62Nq4fbeOTTz2diRPyt/GkCW9w5lk72viDqdE2fu+dt2jeoiUtD2sFQPUaNShXrlypn0NZ1+6Qmiz9YSPZ//2Z3yJbGfvxMvq2r1Nk+VM712f09GUALF61kSXf/wTA9+v+x+qNm6hZpWKRx+6tPps7i3r1G3Jwveh13O+kU3n7zfH5ytQ5uB5Nm7ckJSX/7a/BIY2o3/AQAA6snU7NmrVY++OPpRZ7WMyZHb1X1AvuFQNOOY1JBe8VE8dxxtmDADjhpAH57hUtdK+QIhTZITGz18zs1aKWPR2Imb1uZnPMbIGZXRBs+9nM7jKz+Wb2qZkdGGxvGKx/YWZ3mtnPMfVca2azzOxzM7st2FbPzL4xs+eJPh+t6L8CZciq3BwyMneEmpGRwarcnHxlcnNzyQzKpKamUrVKVdasWQPA8uxlHNGxLT27d2X6tI9KL/AQyS2sjXPyt/Gq3NztZVJTU6lSpSpr16xh8aJFmBkn9evJUZ3a8dD9Ow8HCdSuXomcNb9sX89Z8yu10yoXWrZOzcrUPWA/Pvjy+532tW1YkwqpKSz94ae4xRpW36/KpXZG5vb12ukZfL8q93fX89mcWWzZsoW69RvsyfCSwqrcXDIydtwr0jMyWZWbW2SZfPeKxYvAjJP79+LoTu15+AHdK3aXmcVlSYRdDU0+VmpRRA1z97Vmti8wy8zGEh0S/dTdbzSze4DzgTuBh4GH3f1lM7toWwVmdhzQCOhA9Fue48zsaOC7YPsQdy/0gbRB5+8CgDp1Do7bSZaWg2rXZuGibGrUqMG8uXM449STmTnvC6pUqZLo0JJGXl4en3w8nanTZrBvpUr079WD1llZdOnaLdGhhdYpnevz+ozlbC2Q1T2w2r78+9IjufCJaSjhGx8/fL+KKy8exv2P/2enrJnsnkheHp9+PJ33P/qUfStV4oTePWjdJotjdK8QdpERc/d3d7XEIZbhZjaf6JP76xDtOG0BJgT75wD1gp87AdtmlL4UU8dxwTIPmAs0CeoBWF5UJwzA3Z9093bu3q5mrVq7fzZ7QO30DHJWrti+npOTQ+30jHxl0tPTWRmUycvLY8PGDdSoUYN99tmHGjVqANAmqy31GzRk8aJvSy/4kEgvrI0z8rdx7fT07WXy8vLYuHED1WvUID0jgyOOPIoaNWtSqVIljuvZi/nz5pVq/GGwau2vZNTYkQHLqFGJVet+KbTsgM71GBMMS26z/77lGXN9N24bOY9ZizRkVpiDaqezKmfl9vVVuTkcVDu9xMf/tHEj55xxEtfcdBtZ7TvGI8TQq52eTk7OjntFbs5KaqenF1km/70ik84x94oex/di/me6V+yOlDgtiVAm/tljZl2A7kAnd29FtCNVEfjNd0x4ilD8lwsM+Lu7tw6WQ2LeEFD4nb8Ma9uuPUsWLyZ72TK2bNnC2NGj6NO3X74yvfv256UXngfg9VfHcEyXrpgZq1evJhKJALBs6VKWLFlEPQ037CRrWxtnR9v41dGj6N2nQBv36c9LL+5o46OPibZxtx7Hs2DBl/z666/k5eUx7aMPadK0aWEfs1ebs+RHGh5Uhbq19qN8uRQGdK7PxNkrdyrXOL0K1Srvw4xvV2/fVr5cCi9d3ZWXP1zCGzOWl2bYodKqTTuWLV3Md8uj1/H410bTo1ffEh27ZcsWLhh8GgNOP4s+/U+Oc6ThldU2/71i7JhX6FXgXtGrdz9efmEEAG+8NnbHvaL7cSz8cse9Yvq0Dzm0ie4Vf5Sx9wxNlqaqwDp3/9XMmgCHF1P+U2AA0QfLDozZPgW4w8xedPefzSwDCO3Xq1JTU7nvoUc4sV8vtkYiDBpyDk2bNefO226hTdu29Onbn8FDh3H+sMG0ataYtOrVeeb5aILw42kfcuftt1K+fHlSUlJ46NEnqF69eoLPqOxJTU3lvgcf4eR+vYhEIpwdtPFdt99Cm6y29O7bn0FDh3HBsMG0bt6YtLTqPD0i2sZpaWlcOvwKuh7ZETOjx/G9OL5XnwSfUdkT2epc8/QMXr+hOykpKYyYuoivV67nxlNbM2/pGibNiWYQBnSuz9iP82fDTu5UjyOaHkj1/ffhrGOiE8ovemIaXyxfV+rnUZalpqZy+90PMfjUfkQiEU47cwiNmzTj/r/fxmGt29KjV1/mz53NBYNPZ8OGdbwzZRIP/uMO3vl4HhNeH8PMT6axft1axrwc7UTc99i/ad6yVYLPqmxJTU3l3gceZkD/3tF7xeChMfeKdvTu249BQ4dx4blDaNPiUNLS0ng6uB9XS0vjkuFXcOxRhwf3ip66V8h2VtJv2JnZPu6+OS5BmO0DvE506PEboBpwKzDB3fcLypwC9HX3oWbWCHgB2BeYDJzl7hlBucuB84KqfwbOJppNm+DuOz/AqBBZbdv5hx/P3DMnJ4Xaqnk+cZcxZESiQ0h6C/45sPhCstuq7ltWcgbJqcsRHZk3d3ZoHghx4CEt/Iz7x8Sl7odPbDrH3dvFpfIilORdkx2Ap4hmrQ42s1bAee5+2Z4KIujgFfa0/v1iyowBtrV8DnC4u7uZDQQOjSn3MNHJ/AWVqBMmIiIiUlpK8s+MR4C+RDNWuPt8M+sa16iK1xZ4zKIDuuvRA2ZFRET2Gimhyd8VryQdsRR3X15gElskTvGUiLt/BGgCg4iIiIRaSTpiK4LhSTezcsBlgJ6DICIiIqXOjIR9wzEeStIRu5jo8OTBwA/AO8E2ERERkVK3Vw1Nuvt/yf+ICBERERHZA0ryrcl/Azs9bMDdL4hLRCIiIiK7kEQjkyUamnwn5ueKwEnAiiLKioiIiEgJlWRoclTsupmNAKbFLSIRERGRIhiQkkQpsT/yrsn6wIF7OhARERGRvU1J5oitY8ccsRRgLXB9PIMSERERKcofySKVVbs8l+DJ9a2AWsGS5u4N3P2V0ghOREREpKDos8T2/FL851pPM/vGzBabWZFJKTMbYGZuZsW+t3KXHTGPvhF8krtHgkWvahYREZG9TvBQ+8eJvhu7GXCGmTUrpNz+wOXAjJLUW5Ls3mdm1uZ3xCoiIiISF2ZGSpyWYnQAFrv7UnffAowETiik3B3A3cCmkpxPkR0xM9s2f6wNMCtIxc01s3lmNrcklYuIiIiESE0zmx2zxD4zNYP8j+9aGWzbzsyygDruPrGkH7iryfozgSygf0krExEREYm3OD694kd3L3ZeV2HMLAV4ABj6e47bVUfMANx9yR8JSERERCSJ5AB1YtYzg23b7A+0AKYGLyU/CBhnZv3dfXZRle6qI1bLzK4qaqe7P1CSqEVERET2pAS99HsW0MjM6hPtgA0Ezty20903ADW3rZvZVOCaXXXCYNcdsXLAfgSZMREREZFES9ST9d09z8wuBaYQ7SM97e4LzOx2YLa7j/sj9e6qI7bK3W//I5WKiIiIJBt3nwRMKrDt5iLKdilJncXOERMREREpS5LoVZO7fI5Yt1KLQkRERGQvVGRGzN3XlmYgIiIiIsWyhE3Wj4tiX/otIiIiUpZYEs2eSqYXmIuIiIiEijJiIiIiEhrRx1ckOoo9RxkxERERkQRRRkxERERCRRkxEREREdltyoiJiIhIqFgSPdFVHTEREREJDU3WFxEREZE9QhkxERERCQ/be941KSIiIiJxpIyYiIiIhEpKEqXElBETERERSRBlxERERCQ0ku1bk+qIiYiISKgk0cikhiZFREREEkUZsSK4JzqC5FYhVf8GiLdVzw9KdAhJr9bhwxMdwl5h3azHEh1CUgvfMJ+RQuiCLpL+GoqIiIgkiDJiIiIiEhqG5oiJiIiIyB6gjJiIiIiEh4VxXlvR1BETERGRUNGT9UVERERktykjJiIiIqGhyfoiIiIiskcoIyYiIiKhojliIiIiIrLblBETERGRUEmihJg6YiIiIhIeRnIN5yXTuYiIiIiEijJiIiIiEh4GlkRjk8qIiYiIiCSIMmIiIiISKsmTD1NGTERERCRhlBETERGR0DCS64Gu6oiJiIhIqCRPN0xDkyIiIiIJo4yYiIiIhEoSjUwqIyYiIiKSKMqIiYiISIiYHugqIiIiIrtPGTEREREJjWR76bc6YiIiIhIqGpoUERER2cuYWU8z+8bMFpvZ9YXsv8jMvjCzz8xsmpk1K65OdcREREQkVCxOyy4/06wc8DjQC2gGnFFIR+sld2/p7q2Be4AHijsXdcREREREitcBWOzuS919CzASOCG2gLtvjFmtDHhxlWqOmIiIiISHJWyOWAawImZ9JdCxYCEzuwS4CqgAHFtcpcqIiYiISGhs+9ZkPBagppnNjlku+L3xufvj7t4QuA64qbjyyoiJiIiIRP3o7u2K2JcD1IlZzwy2FWUk8M/iPlAZMREREQkVM4vLUoxZQCMzq29mFYCBwLgCcTWKWe0DLCquUmXERERERIrh7nlmdikwBSgHPO3uC8zsdmC2u48DLjWz7sBvwDpgSHH1qiMmIiIioZKox7m6+yRgUoFtN8f8fPnvrVNDkyIiIiIJooyYiIiIhEoSveFIHTEREREJj+jjK5KnJ6ahSREREZEEUUZMREREQiWZhiaVESvj3n5rMlmHNaVV88Y8cO/dO+3fvHkzQ88eSKvmjel6VCeWL88GYPnybA5Iq8wRHbM4omMWV1x2cSlHHh5vTZnMYc0PpXmTQ7j3nn/stH/z5s2cfebpNG9yCEd17sjy7GwAZs2cSce2renYtjUdslrxxuuvlXLk4fH2W5Np07IprZo15v4iruMhZw+kVbPgOg7aeHl2NrWqVaZzhyw6d8ji8kt1HRelR+emzH/tr3z5xi1cc06PnfbXOSiNyU8O55OXr2PmqL9w/JHNdtq/evr9XDGoW2mFHEq6X8ieVuYyYmZWD5jg7i0SHErCRSIRrr7iMt6YOIWMjEy6HNmR3n370aTpjhvo888+TbW0NOYv+JYxr4zklhuv59kXRgJQv0FDps+Ym6jwQyESiXDF8EuY+ObbZGRmcuTh7enbtz9Nm+1o42effoq0amks+Hoxr4wayY03XMcLL42ieYsWTJ8xm9TUVFatWkXHtq3o07cfqall7n+rhIpEIlx9eXAdZ2ZyzBEd6VPYdVwtjfkLo9fxzTddz3Mx1/HHM3Ud70pKivHQ9afR5+LHyPlhPdNevJYJH3zB10u/317muvN6Mvbtufx79DSaNDiI1x+9mCZ9btm+/+6rT+at6QsSEX5o6H5RVhimOWJSGmbPmkmDhg2pX78BFSpUYMCppzNxQr6H+DJxwhuccdZgAE48+RSmTn0P92Jf9i6BWTNn0rDhIdRvEG3jU08fyITxb+QrM2H8G5w1KPpMvpMHnMLU997F3alUqdL2m+jmTZsS9RLaMm/7ddxgx3U8YXyB63j8G5x5dsx1/L6u49+jfYt6LFnxI9k5a/gtL8LoKXPp2+WwfGXcnSqVKwJQdb99WbV6w/Z9/bocRnbOGhYu+R4pmu4XEg9x64iZWWUzm2hm883sSzM73cxuNrNZwfqTFlyJZtY2KDcfuCSmjqFm9qqZTTazRWZ2T8y+48zsEzOba2ajzWy/YPs/zGyhmX1uZvcF204NPnO+mX0Yr3Pe01bl5pCZueO1VukZGeTm5BQok7u9TGpqKlWqVGXtmjUALM9expGHt6VXj658PO2j0gs8RHILtHFGRiY5Bdo4NzeHzDoxbVy1KmuCNp45YwZZrZrTrk1LHnn8X/rXbSFW5eaQka+NM1iVW7CN81/HVavsaOPl2cs4omNbenbvynRdx4VKP6AqK39Yt30954d1ZNSqmq/MXf83iYG9O7B48h289ujFXHX3aAAq71uBq8/pwV3/l+8ZlVII3S/KDrP4LIkQz6ugJ5Dr7n0AzKwq8La73x6sjwD6AuOBZ4BL3f1DM7u3QD2tgTbAZuAbM3sU+B/RN5p3d/dfzOw64Cozexw4CWji7m5m1YI6bgaOd/ecmG35BG9YvwCgTp2D91ATJM5BB9VmwbfZ1KhRg3lz53DmaSczY+4XVKlSJdGhJZUOHTsyd/4Cvv7qK84bNoTje/aiYsWKiQ4raRxUuzYLF+24js849WRmztN1/Eec1rMdL4z/lIdHvEfHw+rz1J2DaXvK37jpoj48+sJ7/PK/LYkOMenpfrFn6PEVJfcF0MPM7jazo9x9A9DVzGaY2RfAsUDzoGNUzd23ZapGFKjnXXff4O6bgIVAXeBwoBkw3cw+I/oup7rABmAT8JSZnQz8GtQxHXjWzM4n+n6onbj7k+7ezt3b1axVaw81we6pnZ7BypUrtq/n5uSQnpFRoEz69jJ5eXls3LiB6jVqsM8++1CjRg0A2mS1pX6Dhixe9G3pBR8S6QXaOCdnJRkF2jg9PYOVK2LaeMOG7W27TZOmTdlvv/1Y8OWX8Q86ZGqnZ5CTr41zqJ1esI3zX8cbNkbbWNdxyeT+dwOZB6ZtX884MI2cmKFHgCEndmLsW9G5djM+X0bFCuWpWa0y7VvU5a4rTuTribdx6VlduPbc47jo9KNLNf6w0P1C4iFuHTF3/xbIItohu9PMbgaeAE5x95bAv4GS/FNgc8zPEaJZPCOaXWsdLM3c/Vx3zwM6AGOIZtsmB7FcRDSDVgeYY2b5/68oo9q2a8/SxYvJzl7Gli1bGDt6FL379MtXpnef/rz84vMAvP7qGI45pitmxo+rVxOJRABYtmwpSxYvol79BqV+DmVdu/btWbx4EdnLom08etRI+vTtn69Mn779eXHEcwC8OnYMx3Q9FjMje9ky8vLyAFi+fDnffPM1devVK+1TKPPatmvPksWLt7fx2NGj6NO3wHXctz8vvRBzHXeJXserY6/jpUtZskTXcWFmL1jOIQfXom56DcqnluPU47OYOPXzfGVWfL+WLh0OBeDQ+gdScZ/yrF73M93PfYgmfW6hSZ9beOzFqdz71Fv8a1RoZnCUKt0vyog4DUsm3dCkmaUDa939BTNbD5wX7PoxmM91CjDG3deb2XozO9LdpwFnlaD6T4HHzewQd19sZpWBDCAXqOTuk8xsOrA0iKWhu88AZphZL6IdsjV79ITjIDU1lXsffIST+vUiEokwaMg5NG3WnDtvv4WsrLb07tufwUOHccGwwbRq3pi0tOo8M+IlAKZP+5C77riV8uXLk5KSwkOPPkH16tUTfEZlT2pqKg8+/Bj9+hxPJBJhyNBhNGvenNtvvZmstu3o268/Q4edy7Chg2je5BDS0qoz4sXot/k+nj6N++79B+VTo2388KNPULNmzQSfUdmTmprKfQ89won9erE19jq+7RbatG1Ln+A6Pn/YYFo1a0xa9eo883z0Ov542ofcebuu4+JEIlu58u5XGP/EJZRLMZ5741O+Wvo9f724D3MXfsfED77g+gde44m/nsFlZ3fFHc6/ueDggxRH9wuJB4vXN5PM7HjgXmAr8BtwMXAicAbwPfAtsNzdbzWztsDTgANvAb3dvYWZDQXaufulQZ0TgPvcfaqZHQvcDewTfORNwCzgDaKZNgvKPmdmrwKNgm3vAlf4Lk48q207/2D6zD3XGLKT8qn6wm685UW2JjqEpFfr8OGJDmGvsG7WY4kOIakd0bEdc+bMDs2kq8YtWvtjo9+OS93HNztgjru3i0vlRYhbRszdpwBTCmyeTbTDVLDsHOD/27vvcKnKa4/j39+hWACpFjhYAAuIkXIAu6Cx0FUUBSzBGFETTdSYxBRjokk0mmvJjebasdNsKJYYu0YjSMReEEGKBtDEggpyWPePvcHhSDlwyj57+H185nHKPnvWvM8ws2a97167S8FdP03vHw2MLthuYMH1R4Geq3jqXqvY/5DKR25mZmZWO3zsrJmZmeVKMTV0dSJmZmZmuSGgpHjyMHfWNzMzM8uKK2JmZmaWK8U0NemKmJmZmVlGXBEzMzOzXCmmc6a7ImZmZmaWEVfEzMzMLFeKaY2YEzEzMzPLDbevMDMzM7Nq4YqYmZmZ5YiKamrSFTEzMzOzjLgiZmZmZvkht68wMzMzs2rgipiZmZnlShEVxJyImZmZWX4k7SuKJxXz1KSZmZlZRlwRMzMzs1wpnnqYK2JmZmZmmXFFzMzMzPKliEpiroiZmZmZZcQVMTMzM8uVYjrFkRMxMzMzy5Ui6l7hqUkzMzOzrLgiZmZmZrlSRAUxV8TMzMzMsuKKmJmZmeVLEZXEnIiZmZlZbojiOmrSU5NmZmZmGXFFzMzMzPJDbl9hZmZmZtXAFTEzMzPLlSIqiLkiZmZmZlYZkvpKelPSdElnr+LxMyW9JuklSY9I2nZt+3QiZmZmZvmiGrqs6SmlesAVQD9gZ2C4pJ0rbPYvoEdE7ApMAC5a20txImZmZmY5ohr7by16AdMjYkZELAHGAIcUbhARj0XE5+nN54C2a9upEzEzMzOzRCtJNh8YxQAAHOhJREFUUwouowoeKwVmF9yek963OicAD6ztCb1Y38zMzHKlBttXLIyIHlXdiaRjgB5A77Vt60TMzMzMbO3mAlsX3G6b3rcSSQcAvwR6R8Tite3UU5NmZmaWGzW1Tr8SRbbJwA6S2klqCAwDJq4Um9QNuAoYHBHzK/N6XBFbhWURfPlVedZhFLWvypdlHULRa1DPv7Nq2vxn/5x1CBuE5kOvyTqEorZ4xsKsQ8iFiFgq6VTgIaAecH1EvCrpPGBKREwELgYaA+OVzJ++FxGD17RfJ2JmZmaWLxl1dI2I+4H7K9z364LrB6zrPp2ImZmZWa5UotVEbnjuwszMzCwjroiZmZlZrtRg+4pa54qYmZmZWUZcETMzM7NcKaKCmCtiZmZmZllxRczMzMzyo5LdV/PCiZiZmZnlittXmJmZmVmVuSJmZmZmuSHcvsLMzMzMqoErYmZmZpYrRVQQc0XMzMzMLCuuiJmZmVm+FFFJzImYmZmZ5YrbV5iZmZlZlbkiZmZmZrni9hVmZmZmVmWuiJmZmVmuFFFBzBUxMzMzs6y4ImZmZmb5UkQlMSdiZmZmlhvC7SvMzMzMrBq4ImZmZmb5IbevMDMzM7Nq4IqYmZmZ5UoRFcRcETMzMzPLiitiZmZmli9FVBJzImZmZmY5IrevMDMzM7Oqc0XMzMzMcsXtK8zMzMysylwRMzMzs9wQRbVW34mYmZmZ5UwRZWKemjQzMzPLiCtiZmZmlituX2FmZmZmVeaKmJmZmeWK21dYrXn04YfYo3tnenXpxJ8vuegbjy9evJgTR46gV5dO9N1vL96bNROAJUuW8MNTvkfv3bvRZ88ynnnqiVqOPD8eefghenXrTI9dO3LZ/6x6jE84bgQ9du3IgX32XDHG48feRu89ylZcWjVpyMsvvVjL0efDw397kO67dqJL5x255OI/fuPxxYsXM/KYYXTpvCP77bMHs9IxnjVrJls0b8Reu3Vnr926c/ppp9Ry5PnhMa55B3Zry7S/DOWVK4/krCFdvvH4RcfvznOXDOG5S4bw0hVH8v4tx630eJNNGjD9muFceuKetRWy5UAuK2KStgP2jIjb1uNvP4uIxtUeVA0oLy/nZz/+EePvuZ82pW05qM8eHNx/IDt13HnFNrfedANNmzXn+Wmvc9eEsZx/7i+4ZvRt3Dz6OgCeeO5fLFgwn+GHD+Jvjz9LSYlz70Ll5eX89MwfcsfEB2hT2pYD9t2dvv0H0rHT12N8y43X06xZM6a89AZ3jh/Lb8/5BdfddBtDjxrB0KNGAPDaKy9z7PAj+NauXbN6KXVWeXk5Pz79NO6Z9BClpW3ps/du9B84aKUxvmn09TRr3pxpr77FhHFjOPeXZzP6ljEAtGvfgWf+OTWr8HPBY1zzSkrEZaP2YsBv7mfuh4t4+qJDue/5Wbwx578rtvnpDc+tuH5K/850ad9ypX2cO6IHT7/2Qa3FXMyKqCCW24rYdsCIVT0gKZfJ5apMnTKZdu07sF279jRs2JDDDj+SByfdu9I2D066l6OGHwvAoEMP56nHHyMieOuN19l73z4AbL75FjRt2owXp75Q2y+hzps65fmVx/iIo3igwhg/MOlehh2djPHgww7nyccfJSJW2uaOCWM57PAjay3uPJky+Xnad+hAu3SMDx96FJPum7jSNpPuu4fhRyfVg0OHHMHjqxhjWz2Pcc3rucPmvPP+J8z896d8tXQZ459+h4G9tl3t9kfu04FxT72z4na39q3Youkm/P3FObURbnFTMjVZE5cs1GoiJmk7Sa9LukbSq5L+JmkTSR0kPSjpBUlPSeqYbj9a0hEFf/9ZevVCYB9JL0o6Q9JISRMlPQo8IqmxpEckTZX0sqRDavN1VpcP3p9Ladu2K263blPK+/PmrXab+vXr02Szpnz00Yd0/tauPPTAfSxdupRZM99l2otTmTt3dq3Gnwfvz5u30hi3KS3l/Xlzv7FNm7ZbA8kYb9a0KR99+OFK29x9x3gOH3pUzQecQ+/Pm0vbdPwgGeN5c785xm0Lx3izr8d41sx32Xv3MvoduB//ePqp2gs8RzzGNa9Ni0bMWfjZittzP1xEactGq9x2m80bs+0WTXj85eTzWoILj9+Nn9/4z1qJ1fIli+rRDsDwiDhR0jjgcOB44OSIeFvSbsCVwP5r2MfZwFkRMRBA0kigO7BrRHyUVsUOi4hPJLUCnpM0Mdbw80/SKGAUQNutt6n6q8zYiGNH8vabb3Bg793Zeutt6NlrD+rVq5d1WEVpyuR/sskmm9Cp8y5Zh1J0ttqqNa++NZOWLVvyr6kvMOLIIfxz6ststtlmWYdWNDzG1W/o3h24+9l3WbYs+co5qe/OPPTCbOZ+uCjjyIpJ8UxOZpGIvRsRy1c0v0AyzbgnMF5f1wU3Wo/9PhwRH6XXBfxB0r7AMqAU2BJY7eR8RFwNXA3QtXtZnajXb9W6lLlzvi5jvz9vLq3btFnlNm1K27J06VI+/eRjWrRoiSTOv/BPK7brf8C+dNh+h1qLPS9at2mz0hjPmzuX1m1Kv7HNvDmzKU3H+JOPP6ZFy6/Xftw1YRxDhg6rtZjzpnWbUubM+boaO2/uXNqUfnOM58yZTWnbdIw/ScZYEhttlHwcdOteRrv2HZj+9lt0L+tRq6+hrvMY17x5Hy2ibauvlxeXtmy02sTqiL3bc8bVz6y4vdtOW7LXzlsxqt/ONNq4AQ3rl/DZl19xzs2Tazxuq/uyWCO2uOB6OdAC+G9EdC24dEofX0oao6QSoOEa9lv4L+JoYHOgLCK6Av8GNq6uF1BbupX1YMaM6cya+S5LlizhrjvGcXD/gSttc3D/gYy9/WYA7r37Dvbu3QdJfP755yxalAzJ44/+nfr166+0yN8S3cp6MuOdgjGeMJZ+Fca4b/+BjLk1GeOJd93BPr33Y/mPhmXLlnH3nRMYcoTXh61OWY+ezJg+nZnpGN8xfiz9BwxaaZv+AwZz+603AXD3nRPonY7xwgULKC8vB+Ddd2fwzvS32a5d+1p/DXWdx7jmTXl7Adu33oxtt2hCg/olDN27A5Mmv/eN7XYsbUrzxhvx3JvzV9x3/GWPseOo2+l40hh+Pvo5bnv8bSdhVSCKa41YXVjY/gnwrqShETFeyTfcrhExDZgJlAHjgMFAg/RvPgWarGGfTYH5EfGVpP2A1a+orMPq16/PhRdfxlGHDaC8fBkjjv0OHTt15sLf/Yau3cvo238QRx93PD8YNZJeXTrRvHlzrrrhFgAWLpjPUYcNoKSkhK3alHLF1Tdk+2LqqPr16/PH/7mcoYcOoLy8nBHHjqTjzp254PxkjPsNGMQx3/kup3xvJD127Uiz5s25dvStK/7+H08/RWnbtv7iWoP69etz8aV/5rBB/SgvL+fY7xxPp50787vzzqV79zL6DxzMcSO/y6jvHkeXzjvSvHkLbrg5OSD6maef5Pfn/4YGDRpQUlLCZf97JS1atMj4FdU9HuOaV74sOOOaf3Dvuf2oVyJufORNXp/9H84ZXsbU6QtWJGVD9+7A+KffWcvezL6m2jxqJm07cV9E7JLePgtoDNwI/BVoTZJsjYmI8yRtCdwDbAI8CPwgIhpLagA8BLQERgP/AXpExKnpflsB96b7ngLsDvSLiJmVaV/RtXtZPPzEc2vaxKqoXknxzO/XVQ3q5fWgaLOVbTH8uqxDKGqLH/89y/4zMzcfyl26lcUDjz1bI/subb7RCxGx2nl5SX2By4F6wLURcWGFx/cFLgN2BYZFxIS1PWetVsQiYiawS8HtPxU83HcV2/+bJIla7mfp/V/xzcX8owv+biGwx2piyEUPMTMzM1u1LKYRJdUDrgAOBOYAk9MDAV8r2Ow9YCRwVmX3WxemJs3MzMzqul7A9IiYASBpDHAIsCIRSwtOSFpW2Z06ETMzM7NcUTbtK0qBwoacc4DdqrpTJ2JmZmZmiVaSphTcvjptb1VjnIiZmZlZvtRcQWzhGhbrzwW2LrjdNr2vSnxYlZmZmdnaTQZ2kNROUkNgGDBxLX+zVk7EzMzMLFdUQ5c1iYilwKkk7bNeB8ZFxKuSzpM0GEBST0lzgKHAVZJeXdtr8dSkmZmZ5UaWXfAj4n7g/gr3/brg+mSSKctKc0XMzMzMLCOuiJmZmVmuZNS+oka4ImZmZmaWEVfEzMzMLF+KpyDmipiZmZlZVlwRMzMzs1wpooKYEzEzMzPLl6zaV9QET02amZmZZcQVMTMzM8sRuX2FmZmZmVWdK2JmZmaWG8JrxMzMzMysGjgRMzMzM8uIpybNzMwsVzw1aWZmZmZV5oqYmZmZ5YrbV5iZmZlZlbkiZmZmZvmh4loj5kTMzMzMckMU10m/PTVpZmZmlhFXxMzMzCxfiqgk5oqYmZmZWUZcETMzM7NccfsKMzMzM6syV8TMzMwsV9y+wszMzCwjRZSHeWrSzMzMLCuuiJmZmVm+FFFJzBUxMzMzs4y4ImZmZma54vYVZmZmZlZlroiZmZlZbojial+hiMg6hjpH0gJgVtZxrKNWwMKsgyhyHuOa5zGueR7jmpe3Md42IjbPOojKkvQgyRjXhIUR0beG9r1KTsSKhKQpEdEj6ziKmce45nmMa57HuOZ5jG1deI2YmZmZWUaciJmZmZllxIlY8bg66wA2AB7jmucxrnke45rnMbZK8xoxMzMzs4y4ImZmZmaWESdiZmZmZhlxImZmZlYNpKTN6PL/m1WGE7EiIGkHSTtlHUcx8gdr7ZK0VdYxFKOK71+/n2vMLgARER5jqywnYjmmxMbAOcDBWcdTbCQpvj6aZZdMg9kASNoXuE9Si6xjKSaF72NJe0KSKGQbVXEpSLrGSBoPTsas8pyI5VgkvgSuAoa7Kla9Cr68jgPGSWrsD9aaIWl34OfATyLiI0n+bKomBe/jHwBXStom45CKTkFi2xXoIOmm5ff7M8PWxh92OSVpF0kHSGodEc8ATwJbpI/Vyza64iFpf+AHwKCI+Azw2NaM1iRV3Y5ZB1KMJPUHjgcOioj3JO0oqX7WcRWDguUL9SPiK2A3oMzJmFWWE7H8GgAMBu6UtBvQGDhTUr2IKM82tPwq/MBMv6g2BbYDjgOIiKX+UK0+ktpI2iwi7gKOBM6QNCAilmUdW56t4j26MTAJ2F3S+en1iZJq6sTJG4QKyxe2kLRtmox1A7o5GbPKcEPXHFj+Dzj9x7wTUB94LyI+lTQU6AmUAv2AYyNiUoUPCKuECmtpmgJLI2JRWk34PjApIv5acVtbP5IOJRnXD4DXgOuBfYFfAOdFxN0ZhpdbFd7HRwDzgbeAm9LrtwOPpLdviIgHsoq1WEj6MXAg0BwYGxGXSGoAPA/MjIjDMg3Q6jSXpnOg4EN1IHAJ8AbQUtIlETFe0n1AK+Ar4CCShMFJwjoqGOczgX2ATSVdFRF3SgrgREkbR8SlHt+qkfQtkjVhBwF/AA4AroiICenU+gWSngEWeqzXTcH7+CfAocBJEfGBpEERsTh9bACwE/BqdpHmV4VkdxQwOCJ6S7oOOE9S44g4L52teExSG+B9v5dtVTw1WYdJ2lrSNen1FsAZwLCIGAxcC/SX1D0ivoiI2RExEugladvsos43SacAg4BjgP8C4yWNTKsGNwI9JTXLMsY8K5ie2QK4B+gDdAdGpRXejhExFtgvIhb4i2v9SNoZGBgRewEzJO0HfDd9bBhwHnBMRLyXYZi5VCEJ2wp4AThW0o+AZiRV3TMkXRARSyJir4iY5/eyrY4rYnVYRMyW9Jd03cEsSbNJ1itNjYgbJHUCfgoMA5BURlIZW5RZ0DmWJgmLSMbzJCCAvsAkSeURcbOkv0eEx3f97URS0X2T5L07guRAiHclDQJOkXRMRHyQZZB5s4qp8v+QVHSvB5aQrHXsk657vBF4JiJmZxBq7hUkYScBQ0nW6m4E7A/8KiJelnQXsL+kZhHx3+yitTxwRayOKlgXNg24VtKrwDSghaSu6WYTgYUFRz/NB/aPiIW1HnDOKFFScLth2g7kJpJ/F/2An0XEw8DfgAslNXEStv4k7QA8L+nyiJgDPJ5eDpTUF7gA+GtEfJRdlPlToUJzsKQeQCNgJMkPiysj4jiSxLdRRHziJKxqlPS8OxoYHhGfA58C04Ej06UNjYAjnIRZZbgiVkcV/rqNiAMl3Q78BriO5GicEmA/kmRhabqdP1wrr1HajgJJp5P0/mkF/BJYCMwkmeYdAMwgnTrLKti8kzSY5Ivrr8Bxkr6KiLPSg036kxxl9jMfaLLuCpKwM0jWhP2dZM3diRFxWvrYySRtWIZlFWeeSWoaER+n13chmU7fnuQzeFx6NPWTJO/jw0nW5fnz2CrFR03WcZJKlh/KL+lWYC/gKKAdMC8invQX17pJk4JDIuIESceQrJ0ZSDJldltEnJ1+qbUnWcM0IiJezizgnJPUiKRdwqURcY+k5sBkYEJEnJ1us2lEfO738vqRtCNwWUT0l/QnkvfuESSVmRbA/5E0y30lwzBzSVJDkh8LHUgqjK2Bm4FDSPrejUsr58u33zStkplVihOxHKiQjN0LNIiIvhUfs7WT1BIYC5wKfA6cCdxC0oRxIHDo8iPL0u1X/BK29ZMeBXkNyVGRL6T39QPGA3+OiF9kGV8eVUxYJXUEfkZSye1JMi32Zfqj42ngi4j4IpNgi4CkrYH7gC2Bnun63e1JljDsTHKk+n1Zxmj55TViORARy5avZ4qIQcCXki5a/limweXPEmApcC5wGckv3D8A3yY5BH2xpHMl/Trd/pNswsw/Se0kNYqkwfCrwC2SNk0f/pTk1FzflrRPZkHmUIU1Ya0AIuINYBPgWGBomoR9DzgbKHESVmUfkLyH/wGMUtJFfzpwJ/AOsF9a+TVbZ14jlhPLk7E08ZoI9E4/DJZmHVuepC0SHgV+DfwWGA08BfwOaCWpN3AYMDzd3iXj9SDpYJIq2BOSZpCsb2wB/EPS30iOlhwMlAP+MVFJFZKw04DBkuYBvyJJbOcDd6frlY4EjvbBO1Uj6ViSKtgISaXAhcBFJNX0liRVyGt9II+tL09N5pCkPsD8iHgt61jySEmftR2Av5D0U5pNMlUZQFO8lqZKJPUkWTS+vGP7IKAhcBbQi6TFypsk0zz/CwyJiBkZhJo7y3+MKTkrwcnA6SQ/Kj4CbiBJCoYCHwMvRMRbWcWaV6uY9m0CvAJMjIjTlPRoOwfYmqRtxRAvzLeqcCJmG6y079pYkg/VcSRT9Zt6Tdj6k7QR8Dbw74jomd5XRrJwvCXw60i6vHcmOQL4pLRFi62BpD2BLyNiqqRuwMXAExFxfroG71KSZPfKiHgpy1iLRdpu5bOIeD9Nxl4AHouIk9JpyJHAw052raq8Rsw2WOnC8cNJqjInRcRXTsLWX7p4uQlJZ/FtJJ0NK8b5bpImoy3TzecAA5yEVVoPYFzaOmEGyTkM95fUOyLKI+KHQAPge2kybOsp7TG4I/BHkh53W6ata8qAIyRdHxGLIuIKJ2FWHVwRsw1e+uX2RUS8k3UseaWkK/7vgFkk045PkKy/uygiLkq32SwifPDDOqhwxPRvSdooDAfeI5mW7ADcGhFPpttsGRH/zirevFpV25T0yN6jSVqvPJ5Wxn4LfIfkKOv5XkNq1cGL9W2D5/VgVSNpd5J1Sgeml6uBL0imbiZIqhcRFzgJW3cFSdipJOfnXAqMITk68grgFOBkJafgesZJ2PopOADiVJLktjHJkgWRrLnbWtImwI7A7h5nq05OxMysquYA3we6Aj8CupAcwdeOJGHwaV6qQFIvkupXb5Lpx0HArSRHRV4NHE8yXWlVIOkUkoNMRpG0pTg7Ik6XFMAuJP3Zfh4+D6pVM09Nmlm1kPR7kumayyUdR5KUHZo2v3TH/EpaPlYF/+8GnBURR6f9BDcCbiJJfPsCMzy2624V43wuSZXxOyQn8B5C0lqlJO0v2CAivsoyZitOroiZWXV5GThJUgOSL7EfLj+s34lC5VRIWDcmmeJ9G+gi6ZcR8XvgC0lTSJriLvPYrrsK47xD2uuuPTCBpHnrIZGcP/JUoFzSVSTTwmbVzomYmVWX+0mqNYOB30fEMxnHkzsFa5VOAvaWNJmkgfNg4A5JbUkOiBgG9I+IeZkFm1MVmuKeSlK5nQi8S3KaszFpEjaSZMr9EJ/BxGqSpybNrFotP+ODpyPXj6QTSQ50OIPk7ATTSNbcvUmSGJQAd4RPRF8l6Xk4B5K0qTgI2IzkJN59SI6U7Aac6MbZVtNcETOz6lYOno6srAoVmo7AtsAAktYJHwPTSao2l0fEeZkFWkTSUxX9Bfh7RLwj6XqSnoIA84DLgcXuK2i1wQ1dzaxaOQGrvApJ2PeBA0iqYFsCgyJiX+Ba4FvAQEmNMwu2iETEXJIjUftKGhYRi0nagiwg+V5c4iTMaosrYmZmGamwJux40vMWpi0rtkkPfCgD3gAujYjPsou2uETEnZIWAxdIIiLGSBoNNEo76ZvVCidiZmYZShuF9gN+BXwu6WSSilhb4FGStUvHRsT87KIsThExSdIy4GpJSyNiAsnRqGa1xov1zcwyJmkUSZf82STVrxkkydhEYK6TsJol6UDgnYhwY1yrdU7EzMwyJmljknVg70TER5KOBr5H0qLii2yjM7Oa5ETMzKyOSDvnH0+ykHy4z4NqVvy8RszMrO7YmOS0OkdGxOtZB2NmNc8VMTOzOsSNcM02LE7EzMzMzDLihq5mZmZmGXEiZmZmZpYRJ2JmZmZmGXEiZmZmZpYRJ2JmGyhJ5ZJelPSKpPGSNq3CvvpIui+9PljS2WvYtll6gut1fY7fSDqrsvdX2Ga0pCPW4bm2k+QeXmZW45yImW24voiIrhGxC7AEOLnwQSXW+TMiIiZGxIVr2KQZsM6JmJlZMXIiZmYATwHbp5WgNyXdBLwCbC3pIEnPSpqaVs4aA0jqK+kNSVOBIct3JGmkpL+k17eUdJekaellT+BCoENajbs43e4nkiZLeknSbwv29UtJb0l6GthpbS9C0onpfqZJuqNCle8ASVPS/Q1Mt68n6eKC5z6pqgNpZrYunIiZbeAk1Qf6AS+nd+0AXBkRnYFFwK+AAyKiOzAFODM9N+I1wCCgDNhqNbv/M/BERHQBugOvAmeTnFOxa0T8RNJB6XP2AroCZZL2lVQGDEvv6w/0rMTLuTMieqbP9zpwQsFj26XPMQD4v/Q1nAB8HBE90/2fKKldJZ7HzKxa+BRHZhuuTSS9mF5/CrgOaAPMiojn0vt3B3YGnpEE0BB4FugIvBsRbwNIugUYtYrn2B84DiAiyoGPJTWvsM1B6eVf6e3GJIlZE+CuiPg8fY6JlXhNu0j6Hcn0Z2PgoYLHxkXEMuBtSTPS13AQsGvB+rGm6XO/VYnnMjOrMidiZhuuLyKia+EdabK1qPAu4OGIGF5hu5X+rooEXBARV1V4jtPXY1+jgUMjYpqkkUCfgscqnkYk0uc+LSIKEzYkbbcez21mts48NWlma/IcsJek7QEkNZK0I/AGsJ2kDul2w1fz948Ap6R/W09SU+BTkmrXcg8B3y1Ye1YqaQvgSeBQSZtIakIyDbo2TYD3JTUAjq7w2FBJJWnM7YE30+c+Jd0eSTtKalSJ5zEzqxauiJnZakXEgrSydLukjdK7fxURb0kaBUyS9DnJ1GaTVeziR8DVkk4AyoFTIuJZSc+k7SEeSNeJdQKeTStynwHHRMRUSWOBacB8YHIlQj4H+CewIP1/YUzvAc8DmwEnR8SXkq4lWTs2VcmTLwAOrdzomJlVnU/6bWZmZpYRT02amZmZZcSJmJmZmVlGnIiZmZmZZcSJmJmZmVlGnIiZmZmZZcSJmJmZmVlGnIiZmZmZZeT/AXCYYyaoD08eAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 900x540 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"\\nF1 Score: {:.2f}\".format(f1_score(data_test.Emotion, predictions, average='micro') * 100))\n",
    "\n",
    "# Plot normalized confusion matrix\n",
    "plot_confusion_matrix(data_test.Emotion, predictions, classes=class_names, normalize=True, title='Normalized confusion matrix')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Let's try other inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Message: My boyfriend didn't turn up after promising that he was coming.\n",
      "Predicted: sadness\n"
     ]
    }
   ],
   "source": [
    "print('Message: {}\\nPredicted: {}'.format(X_test[4], predictions[4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Message: ['delivery was hour late and my pizza was cold!']\n",
      "predicted: anger (0.01 seconds)\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "message = ['delivery was hour late and my pizza was cold!']\n",
    "\n",
    "seq = tokenizer.texts_to_sequences(message)\n",
    "padded = pad_sequences(seq, maxlen=max_seq_len)\n",
    "\n",
    "start_time = time.time()\n",
    "pred = model.predict(padded)\n",
    "\n",
    "print('Message: ' + str(message))\n",
    "print('predicted: {} ({:.2f} seconds)'.format(class_names[np.argmax(pred)], (time.time() - start_time)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Done\n",
    "Save the model for later use 🙃 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creates a HDF5 file 'my_model.h5'\n",
    "model.save('models/cnn_w2v.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import load_model\n",
    "predictor = load_model('models/cnn_w2v.h5')"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}