NLP_PS4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import operator\n",
    "import random\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import csv\n",
    "import re\n",
    "\n",
    "from itertools import chain, islice\n",
    "from functools import partial\n",
    "\n",
    "import nltk\n",
    "from nltk.tokenize import word_tokenize\n",
    "\n",
    "import sklearn\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.metrics import classification_report, accuracy_score, precision_recall_curve, precision_recall_fscore_support\n",
    "from sklearn.utils.fixes import signature\n",
    "\n",
    "import keras\n",
    "from keras.models import Model\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from keras.models import Sequential\n",
    "from keras.layers import InputLayer, Embedding, Flatten, Dense, Activation, Dropout, BatchNormalization, Input, Bidirectional, LSTM, GRU, TimeDistributed, concatenate\n",
    "from keras.callbacks import EarlyStopping\n",
    "from keras import backend as K\n",
    "\n",
    "import tensorflow as tf\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "from pprint import pprint\n",
    "\n",
    "import gc\n",
    "from numpy import array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_seed(seed):\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    tf.set_random_seed(seed)\n",
    "    \n",
    "set_seed(1992)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Preprocessing</h2>\n",
    "\n",
    "We operate on a subset of two datasets:\n",
    "<ol>\n",
    "    <li>\n",
    "        <h4>LingSpam Dataset (Bare)</h4>\n",
    "        <p>\n",
    "            This is the dataset that we used in the 2nd assignment.\n",
    "            It consists of a few large emails, appriximately 1000 messages with an average of 3500 words.\n",
    "    </li>\n",
    "    <li>\n",
    "        <h4>Kaggles Spam/Ham Dataset</h4>\n",
    "        <p>\n",
    "            This dataset is bigger, consisting of approximately 5500 messages.\n",
    "            Each messagehowever is quiet short and a lot of jargon is used in them.\n",
    "        </p>\n",
    "    </li>\n",
    "</ol>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "lingspam_data_path = \"/media/spiros/Data/lingspam_public/bare/\"\n",
    "kaggle_data_path   = \"Kaggle/kaggle_spam_data.csv\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_lingspam_data(path):\n",
    "\n",
    "    ham, spam = [], []\n",
    "\n",
    "    for dirpath, _, filenames in os.walk(path):\n",
    "        for filename in filenames:\n",
    "            with open(os.path.join(dirpath, filename), encoding=\"utf8\") as file:\n",
    "                message = file.read()\n",
    "            if filename.startswith(\"spm\"):\n",
    "                spam.append(message)\n",
    "            else:\n",
    "                ham.append(message)\n",
    "\n",
    "    return ham, spam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_kaggle_data(path):\n",
    "    \n",
    "    ham, spam = [], []\n",
    "    \n",
    "    pattern = re.compile(\"\\\"?(?P<Category>spam|ham),(?:\\\"\\\")?(?P<Text>.*?)(?:\\\"\\\"\\\")?;+\")\n",
    "    \n",
    "    with open(path, 'r', encoding=\"utf8\") as file:\n",
    "        for line in file.readlines():\n",
    "            match = pattern.match(line)\n",
    "            if match:\n",
    "                text = \" \".join(word_tokenize(match[\"Text\"]))\n",
    "                if match[\"Category\"].startswith(\"s\"):\n",
    "                    spam.append(text)\n",
    "                else:\n",
    "                    ham.append(text)\n",
    "            \n",
    "    return ham, spam"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ham: 2412, Spam: 481\n"
     ]
    }
   ],
   "source": [
    "dataset = \"lingspam\" # Specify the dataset to be loaded: kaggle, lingspam, or both\n",
    "\n",
    "ham, spam = \\\n",
    "    load_kaggle_data(kaggle_data_path) if dataset.startswith(\"k\") else (\n",
    "        load_lingspam_data(lingspam_data_path) if dataset.startswith(\"l\") else\n",
    "        tuple(map(operator.concat, load_kaggle_data(kaggle_data_path), load_lingspam_data(lingspam_data_path)))\n",
    "    )\n",
    " \n",
    "print(\"Ham: {}, Spam: {}\".format(len(ham), len(spam)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_split(x, y, sizes=(0.1, 0.1)):\n",
    "    \n",
    "    data_size = len(x)\n",
    "    splits = []\n",
    "    \n",
    "    for size in sizes:\n",
    "        x, test_x, y, test_y = train_test_split(x, y, test_size=int(data_size*size), shuffle=True)\n",
    "        splits.append((test_x, test_y))\n",
    "    splits.append((x, y))\n",
    "    \n",
    "    return splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Split Sizes: [2084, 231, 578]\n"
     ]
    }
   ],
   "source": [
    "x = ham + spam\n",
    "y = [0] * len(ham) + [1] * len(spam)\n",
    "\n",
    "(test_x, test_y), (valid_x, valid_y), (train_x, train_y) = data_split(x, y, sizes=(0.2, 0.08))\n",
    "\n",
    "print(\"Split Sizes: {}\".format(list(map(len, (train_x, valid_x, test_x)))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Tokenizer Initialization</h3>\n",
    "<p>We consider two tokenizers. <i>Tokenizer_TRAIN_GLB</i> is fitted in all tokens onservable in the training set. <i>Tokenizer_UNK</i> is fitted in a subset of the training sequences in order to simulate the unobservability of a number of tokens in the validation data.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tokens discovered by Tokenizer_GLB: 51439\n"
     ]
    }
   ],
   "source": [
    "tokenizer_GLB = Tokenizer(num_words=None, lower=True, oov_token=\"*UNK*\")\n",
    "tokenizer_GLB.fit_on_texts(train_x)\n",
    "\n",
    "print(\"Tokens discovered by Tokenizer_GLB: {}\".format(len(tokenizer_GLB.word_index)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tokens discovered by Tokenizer_UNK: 48507\n"
     ]
    }
   ],
   "source": [
    "tokenizer_UNK = Tokenizer(num_words=None, lower=True, oov_token=\"*UNK*\")\n",
    "tokenizer_UNK.fit_on_texts(random.sample(train_x, len(train_x) - len(valid_x))) # We want the number of unknown words in the train set to be approximately the same as in the validation set.\n",
    "\n",
    "print(\"Tokens discovered by Tokenizer_UNK: {}\".format(len(tokenizer_UNK.word_index)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>Tokenization</h3>\n",
    "<p>We transform each set in sequences of tokens according the chosen tokenizer.</p>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "tokenizer = tokenizer_UNK"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_sequences = pad_sequences(tokenizer.texts_to_sequences(train_x), maxlen=150, padding=\"post\", truncating=\"post\") # We are contrained by the hardware limitations.\n",
    "input_length = len(train_sequences[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "valid_sequences = pad_sequences(tokenizer.texts_to_sequences(valid_x), maxlen=input_length, padding=\"post\", truncating=\"post\")\n",
    "test_sequences  = pad_sequences(tokenizer.texts_to_sequences(test_x), maxlen=input_length, padding=\"post\", truncating=\"post\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Utilities</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_model(model):\n",
    "    \n",
    "    K.clear_session()\n",
    "    del model\n",
    "    gc.collect() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_history(history):\n",
    "    \n",
    "    plt.plot(\n",
    "        history.history[\"acc\"],\n",
    "        label=\"Train\"\n",
    "    )\n",
    "    plt.plot(\n",
    "        history.history[\"val_acc\"],\n",
    "        label=\"Validation\"\n",
    "    )\n",
    "    \n",
    "    plt.title(\"Model Accuracy\")\n",
    "    plt.ylabel(\"Accuray\")\n",
    "    plt.xlabel(\"Epoch\")\n",
    "    plt.legend([\"Train\", \"Validation\"], loc=\"best\")\n",
    "    \n",
    "    plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate_model(model, sequences, y):\n",
    "    y_pred = (model.predict(sequences).flatten() >= 0.5).astype(float)\n",
    "    \n",
    "    \n",
    "    print(classification_report(y, y_pred))\n",
    "    \n",
    "    print(\"Accuracy: \"+str(accuracy_score(y,  y_pred.round()))) \n",
    "    \n",
    "    precision_curve, recall_curve, _ = precision_recall_curve(y,  y_pred.round())\n",
    "    step_kwargs = ({'step': 'post'}\n",
    "               if 'step' in signature(plt.fill_between).parameters\n",
    "               else {})\n",
    "    plt.step(recall_curve, precision_curve, color='b', alpha=0.2,\n",
    "             where='post')\n",
    "    plt.fill_between(recall_curve, precision_curve, alpha=0.2, color='b', **step_kwargs)\n",
    "\n",
    "    plt.xlabel('Recall')\n",
    "    plt.ylabel('Precision')\n",
    "    plt.ylim([0.0, 1.05])\n",
    "    plt.xlim([0.0, 1.0])\n",
    "    plt.title('Precision-Recall curve')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "glove_embeddings_path = \"/media/spiros/Data/glove.6B/glove.6B.100d.txt\"\n",
    "embeddings_df = pd.read_csv(glove_embeddings_path, sep=\" \", index_col=0, header=None, quoting=csv.QUOTE_NONE, na_values=None, keep_default_na=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Non-Zero Embeddings: 32806\n"
     ]
    }
   ],
   "source": [
    "token_iter = map(\n",
    "    operator.itemgetter(0),\n",
    "    sorted(\n",
    "        filter(lambda item: item[1] <= tokenizer.num_words, tokenizer.word_index.items()) if tokenizer.num_words\n",
    "            else tokenizer.word_index.items(),\n",
    "        key=operator.itemgetter(1)\n",
    "    )\n",
    ")\n",
    "\n",
    "embedding_weights = embeddings_df.reindex(chain((None,), token_iter), fill_value=0.0).values # The zero-indexed vector is used only for masking by the layer.\n",
    "\n",
    "print(\"Non-Zero Embeddings: {}\".format(np.count_nonzero(embedding_weights, axis=0)[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>Bidirectional LSTMs on Pretrained (Glove) Embeddings</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 150)               0         \n",
      "_________________________________________________________________\n",
      "embedding_1 (Embedding)      (None, 150, 100)          4850800   \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 150, 100)          0         \n",
      "_________________________________________________________________\n",
      "bidirectional_1 (Bidirection (None, 150, 200)          160800    \n",
      "_________________________________________________________________\n",
      "bidirectional_2 (Bidirection (None, 200)               240800    \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 1)                 201       \n",
      "=================================================================\n",
      "Total params: 5,252,601\n",
      "Trainable params: 401,801\n",
      "Non-trainable params: 4,850,800\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "inputs =  Input(shape=(150, ), dtype='int32')\n",
    "embeddings = Embedding(\n",
    "    input_dim=embedding_weights.shape[0],\n",
    "    output_dim=embedding_weights.shape[1],\n",
    "    input_length=input_length,\n",
    "    embeddings_initializer=\"zeros\",\n",
    "    weights=[embedding_weights],\n",
    "    trainable=False\n",
    ")(inputs)\n",
    "dropped_embeddings = Dropout(0.0)(embeddings)\n",
    "lstms_1 = Bidirectional(LSTM(100, return_sequences=True))(dropped_embeddings)\n",
    "lstms_2 = Bidirectional(LSTM(100))(lstms_1)\n",
    "outputs = Dense(1, activation='sigmoid')(lstms_2)\n",
    "\n",
    "# Wrap model\n",
    "model = Model(inputs=inputs, outputs=outputs)\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer=\"adam\", loss=\"binary_crossentropy\", metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 2084 samples, validate on 231 samples\n",
      "Epoch 1/20\n",
      "2084/2084 [==============================] - 17s 8ms/step - loss: 0.2761 - acc: 0.8872 - val_loss: 0.0754 - val_acc: 0.9827\n",
      "Epoch 2/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0683 - acc: 0.9789 - val_loss: 0.0540 - val_acc: 0.9784\n",
      "Epoch 3/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0370 - acc: 0.9885 - val_loss: 0.3830 - val_acc: 0.9091\n",
      "Epoch 4/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0621 - acc: 0.9760 - val_loss: 0.0328 - val_acc: 0.9827\n",
      "Epoch 5/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0209 - acc: 0.9942 - val_loss: 0.0176 - val_acc: 0.9913\n",
      "Epoch 6/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0241 - acc: 0.9933 - val_loss: 0.1079 - val_acc: 0.9437\n",
      "Epoch 7/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0268 - acc: 0.9899 - val_loss: 0.0165 - val_acc: 0.9957\n",
      "Epoch 8/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0205 - acc: 0.9928 - val_loss: 0.0379 - val_acc: 0.9913\n",
      "Epoch 9/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0079 - acc: 0.9976 - val_loss: 0.0312 - val_acc: 0.9870\n",
      "Epoch 10/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0057 - acc: 0.9981 - val_loss: 0.0263 - val_acc: 0.9913\n",
      "Restoring model weights from the end of the best epoch\n",
      "Epoch 00010: early stopping\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "    train_sequences, train_y,\n",
    "    validation_data=(valid_sequences, valid_y),\n",
    "    batch_size=64,\n",
    "    epochs=20,\n",
    "    callbacks=[EarlyStopping(patience=3, restore_best_weights=True, verbose=1)],\n",
    "    verbose=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "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"
    }
   ],
   "source": [
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00      1740\n",
      "           1       0.99      1.00      0.99       344\n",
      "\n",
      "   micro avg       1.00      1.00      1.00      2084\n",
      "   macro avg       1.00      1.00      1.00      2084\n",
      "weighted avg       1.00      1.00      1.00      2084\n",
      "\n",
      "Accuracy: 0.9980806142034548\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAF1pJREFUeJzt3X20XXV95/H3xwREBUI1YDUJhMcqRRRNAYe1lI5IgWpwWUUyosWhpLXS6mhtnVVHKC1adbRjB6ymQlFUEBzrSmsoPiGMVjRxQAooNCIPCczwHEQwPH3nj70vOV6SfU8ud997Et6vte5iP/zO3t/94+Z87t6/c/ZOVSFJ0qY8ZaYLkCSNNoNCktTJoJAkdTIoJEmdDApJUieDQpLUyaDQFiXJ1UkOnaDNrknuSzJrmsrqXZIbkhzWTp+S5LMzXZOePAwKTYn2jeyB9g36/yU5O8n2U72fqvr1qvrWBG1uqqrtq+qRqd5/+yb9UHuc9yT51yQvner9SKPEoNBUenVVbQ+8GFgEvHd8gzS29N+7L7THORe4GLhghuuZcklmz3QNGh1b+j9YjaCqWgtcCOwHkORbSU5L8h3gfmCPJHOSnJnk1iRrk/zV4KWiJCcm+VGSnyW5JsmL2+WDl2AOTLIqyb3tWcxH2+ULk9TYm12S5yZZnuSuJKuTnDiwn1OSnJ/kM+2+rk6yaMjjfBj4HDAvyc4D23xVkisGzjj2H1i3IMmXktye5M4kp7fL90zyzXbZHUk+l2SnyfR/kqPb/d+b5CdJjhjfdwPH/tlxfXZCkpuAbya5MMlJ47b9wySvbaefl+Rrbb9em+SYydSr0WdQaMolWQAcBVw+sPhNwFJgB+BG4GzgYWAv4ADgcOD32te/HjgFeDOwI7AYuHMju/oY8LGq2hHYEzh/EyWdB6wBngu8Dnh/kv84sH5x22YnYDlw+pDHuW1b453A3e2yA4CzgN8HngV8Elie5KltEP5ze/wLgXntfgECfKCt8fnAgrYPNkuSA4HPAO9uj+dlwA2bsYmXt/v/LeBcYMnAtvcFdgO+kuQZwNeAzwO7AMcCH2/baCtjUGgqfTnJPcC3gUuA9w+sO7uqrm7/Cn8mTZC8o6p+XlW3AX9D82YDTWB8qKpWVmN1Vd24kf09BOyVZG5V3VdVl41v0IbWIcCfVdUvquoK4FM0b/Bjvl1VK9oxjXOAF05wnMe0x/kAcCLwuva4oAnDT1bV96rqkar6NLAeOBg4kCYI3t0e9y+q6tsA7TF+rarWV9XtwEdp3rQ31wnAWe22Hq2qtVX14814/SltbQ8A/wi8KMlu7bo3Al+qqvXAq4Abquofqurhqroc+F/A6ydRs0acQaGp9Jqq2qmqdquqP2zfbMbcPDC9G7ANcGt7eeYemr+8d2nXLwB+MsT+TgD2AX6cZGWSV22kzXOBu6rqZwPLbqT5a37M/x2Yvh/YLsnsJG9sB63vS3LhQJvzq2on4NnAVcBLxh3bu8aOqz22BW0dC4AbB0LlMUmeneS89jLcvcBnacZANtewfbcpj/1/avvsK2wI8CU0l9qgOc6Dxh3nG4FffQL71ohywErTZfA2xTfT/JU9d2Nvmu36PSfcYNW/A0vawfHXAl9M8qxxzW4Bnplkh4Gw2BVYO8T2P8eGN8aNrb8jyVJgVZLPV9Wtbe2nVdVp49u3n47aNcnsjRz3+2n66AVVdVeS1zDkJbBxuvru58DTB+Y39qY+/nbS5wInJ7kU2I5m8H5sP5dU1SsnUaO2MJ5RaNq1b6hfBT6SZMckT2kHc8cutXwK+JMkL2k+JJW9Bi5/PCbJcUl2rqpHgXvaxY+O29fNwL8CH0iyXTuwfALNX+xTcSzXAhcBf9ou+nvgD5Ic1Nb+jCS/nWQH4PvArcBft8u3S3JI+7odgPuAdUnm0YwxTMaZwFuSvKLt13lJnteuuwI4Nsk27YD964bY3gqas4dTaT7tNda//wzsk+RN7fa2SfIbSZ4/ybo1wgwKzZQ3A9sC19AMBH8ReA5AVV0AnEYzUPoz4Ms04xrjHQFcneQ+moHtY8dd7hqzhGbw+Baa6+4nV9XXp/BYPgwsTbJLVa2iGbc4vT2u1cDxAO0YyKtpBvBvohlgf0O7jb+g+VjxOprLPV+aTCFV9X3gLTRjPutoxorGQva/0Zxt3N3u7/NDbG99W8thg+3bs7PDaS5L3UJz+e6DwFMnU7dGW3xwkSSpi2cUkqROBoUkqZNBIUnqZFBIkjptcd+jmDt3bi1cuHCmy5CkLcoPfvCDO6pq54lbPt4WFxQLFy5k1apVM12GJG1RkmzsNjhD8dKTJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSerUW1AkOSvJbUmu2sT6JPnbNM8wvjLtM5ElSaOlzzOKs2luA70pRwJ7tz9Lgb/rsRZJ0iT1FhRVdSlwV0eTo4HPtM9EvgzYKclzJtrugw9OVYWSpGHM5BjFPH75Ocpr+OXnGD8mydIkq5KsuvXWu6elOElSY4u4hUdVLQOWAeyxx6K67roZLkiStiDP3NjzITfDTAbFWmDBwPx8hnjgPcCll/ZSjyRtddav37KDYjlwUpLzgIOAdVV160Qvmj0bDjig99okaatw441wV9do8RB6C4ok5wKHAnOTrAFOBrYBqKpPACuAo2gePn8/zQPhJUkjpregqKolE6wv4G197V+SNDX8ZrYkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE69BkWSI5Jcm2R1kvdsZP2uSS5OcnmSK5Mc1Wc9kqTN11tQJJkFnAEcCewLLEmy77hm7wXOr6oDgGOBj/dVjyRpcvo8ozgQWF1V11fVg8B5wNHj2hSwYzs9B7ilx3okSZMwu8dtzwNuHphfAxw0rs0pwFeT/BHwDOCwjW0oyVJgKcAuu+w65YVKkjZtpgezlwBnV9V84CjgnCSPq6mqllXVoqpaNGfOztNepCQ9mfUZFGuBBQPz89tlg04Azgeoqu8C2wFze6xJkrSZ+gyKlcDeSXZPsi3NYPXycW1uAl4BkOT5NEFxe481SZI2U29BUVUPAycBFwE/ovl009VJTk2yuG32LuDEJD8EzgWOr6rqqyZJ0ubrczCbqloBrBi37H0D09cAh/RZgyTpiZnpwWxJ0ogzKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSp9nDNkwyD9ht8DVVdWkfRUmSRsdQQZHkg8AbgGuAR9rFBXQGRZIjgI8Bs4BPVdVfb6TNMcAp7fZ+WFX/adjiJUn9G/aM4jXAr1XV+mE3nGQWcAbwSmANsDLJ8qq6ZqDN3sB/BQ6pqruT7DJ86ZKk6TDsGMX1wDabue0DgdVVdX1VPQicBxw9rs2JwBlVdTdAVd22mfuQJPVs2DOK+4ErknwDeOysoqr+uOM184CbB+bXAAeNa7MPQJLv0FyeOqWq/mXImiRJ02DYoFje/vSx/72BQ4H5wKVJXlBV9ww2SrIUWAqwyy679lCGJGlThgqKqvp0km1pzwCAa6vqoQlethZYMDA/v102aA3wvXZbP01yHU1wrBy3/2XAMoB99llUw9QsSZoaQ41RJDkU+HeawemPA9cledkEL1sJ7J1k9zZkjuXxZyVfpjmbIMlcmiC6ftjiJUn9G/bS00eAw6vqWoAk+wDnAi/Z1Auq6uEkJwEX0Yw/nFVVVyc5FVhVVcvbdYcnGfvY7bur6s7JH44kaaoNGxTbjIUEQFVdl2TCT0FV1Qpgxbhl7xuYLuCd7Y8kaQQNGxSrknwK+Gw7/0ZgVT8lSZJGybBB8VbgbcDYx2H/N81YhSRpKzfsp57WAx9tfyRJTyKdQZHk/Ko6Jsm/0dyL6ZdU1f69VSZJGgkTnVG8vf3vq/ouRJI0mjq/R1FVt7aTdwA3V9WNwFOBFwK39FybJGkEDHtTwEuB7dpnUnwVeBNwdl9FSZJGx7BBkaq6H3gt8PGqej3w6/2VJUkaFUMHRZKX0nx/4ivtsln9lCRJGiXDBsU7aB4w9I/tbTj2AC7uryxJ0qgY9nsUlwCXDMxfz4Yv30mStmITfY/if1TVO5L8Exv/HsXi3iqTJI2Eic4ozmn/+9/7LkSSNJo6g6KqftBOrgIeqKpHAZLMovk+hSRpKzfsYPY3gKcPzD8N+PrUlyNJGjXDBsV2VXXf2Ew7/fSO9pKkrcSwQfHzJC8em0nyEuCBfkqSJI2SYZ9H8Q7ggiS3AAF+FXhDb1VJkkbGsN+jWJnkecCvtYuuraqH+itLkjQqhrr0lOTpwJ8Bb6+qq4CFSbz1uCQ9CQw7RvEPwIPAS9v5tcBf9VKRJGmkDBsUe1bVh4CHANo7yaa3qiRJI2PYoHgwydNob+ORZE9gfW9VSZJGxrCfejoZ+BdgQZLPAYcAx/dVlCRpdEwYFEkC/JjmoUUH01xyentV3dFzbZKkETBhUFRVJVlRVS9gw0OLJElPEsOOUfyfJL/RayWSpJE07BjFQcBxSW4Afk5z+amqav++CpMkjYZhg+K3eq1CkjSyJnrC3XbAHwB7Af8GnFlVD09HYZKk0TDRGMWngUU0IXEk8JHeK5IkjZSJLj3t237aiSRnAt/vvyRJ0iiZ6IzisTvEeslJkp6cJgqKFya5t/35GbD/2HSSeyfaeJIjklybZHWS93S0+50klWTR5h6AJKlfnZeeqmrWZDecZBZwBvBKYA2wMsnyqrpmXLsdgLcD35vsviRJ/Rn2C3eTcSCwuqqur6oHgfOAozfS7i+BDwK/6LEWSdIk9RkU84CbB+bXtMse0z6He0FVdd4aJMnSJKuSrFq37vapr1SStEl9BkWnJE8BPgq8a6K2VbWsqhZV1aI5c3buvzhJ0mP6DIq1wIKB+fntsjE7APsB32pvDXIwsNwBbUkaLX0GxUpg7yS7J9kWOBZYPrayqtZV1dyqWlhVC4HLgMVVtarHmiRJm6m3oGi/d3EScBHwI+D8qro6yalJFve1X0nS1Br2poCTUlUrgBXjlr1vE20P7bMWSdLkzNhgtiRpy2BQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqVOvQZHkiCTXJlmd5D0bWf/OJNckuTLJN5Ls1mc9kqTN11tQJJkFnAEcCewLLEmy77hmlwOLqmp/4IvAh/qqR5I0OX2eURwIrK6q66vqQeA84OjBBlV1cVXd385eBszvsR5J0iT0GRTzgJsH5te0yzblBODCja1IsjTJqiSr1q27fQpLlCRNZCQGs5McBywCPryx9VW1rKoWVdWiOXN2nt7iJOlJbnaP214LLBiYn98u+yVJDgP+HHh5Va3vsR5J0iT0eUaxEtg7ye5JtgWOBZYPNkhyAPBJYHFV3dZjLZKkSeotKKrqYeAk4CLgR8D5VXV1klOTLG6bfRjYHrggyRVJlm9ic5KkGdLnpSeqagWwYtyy9w1MH9bn/iVJT9xIDGZLkkaXQSFJW7kHHnhirzcoJGkrNmcOzJoFsMMzJrsNg0KStmI77QQHHQRjcTEZBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKlTr0GR5Igk1yZZneQ9G1n/1CRfaNd/L8nCPuuRJG2+3oIiySzgDOBIYF9gSZJ9xzU7Abi7qvYC/gb4YF/1SJImp88zigOB1VV1fVU9CJwHHD2uzdHAp9vpLwKvSJIea5IkbabZPW57HnDzwPwa4KBNtamqh5OsA54F3DHYKMlSYGk799CiRb9yQy8Vb3HWz4GnrpvpKkaDfbGBfbGBfbHBvfMn+8o+g2LKVNUyYBlAklVVdy+a4ZJGQtMX99sX2BeD7IsN7IsNkqya7Gv7vPS0FlgwMD+/XbbRNklmA3OAO3usSZK0mfoMipXA3kl2T7ItcCywfFyb5cDvttOvA75ZVdVjTZKkzdTbpad2zOEk4CJgFnBWVV2d5FRgVVUtB84EzkmyGriLJkwmsqyvmrdA9sUG9sUG9sUG9sUGk+6L+Ae8JKmL38yWJHUyKCRJnUY2KLz9xwZD9MU7k1yT5Mok30iy20zUOR0m6ouBdr+TpJJstR+NHKYvkhzT/m5cneTz013jdBni38iuSS5Ocnn77+Somaizb0nOSnJbkqs2sT5J/rbtpyuTvHioDVfVyP3QDH7/BNgD2Bb4IbDvuDZ/CHyinT4W+MJM1z2DffGbwNPb6bc+mfuibbcDcClwGbBopuuewd+LvYHLgV9p53eZ6bpnsC+WAW9tp/cFbpjpunvqi5cBLwau2sT6o4ALgQAHA98bZrujekbh7T82mLAvquriqrq/nb2M5jsrW6Nhfi8A/pLmvmG/mM7iptkwfXEicEZV3Q1QVbdNc43TZZi+KGDHdnoOcMs01jdtqupSmk+QbsrRwGeqcRmwU5LnTLTdUQ2Kjd3+Y96m2lTVw8DY7T+2NsP0xaATaP5i2BpN2BftqfSCqvrKdBY2A4b5vdgH2CfJd5JcluSIaatueg3TF6cAxyVZA6wA/mh6Shs5m/t+Amwht/DQcJIcBywCXj7TtcyEJE8BPgocP8OljIrZNJefDqU5y7w0yQuq6p4ZrWpmLAHOrqqPJHkpzfe39quqR2e6sC3BqJ5RePuPDYbpC5IcBvw5sLiq1k9TbdNtor7YAdgP+FaSG2iuwS7fSge0h/m9WAMsr6qHquqnwHU0wbG1GaYvTgDOB6iq7wLbAXOnpbrRMtT7yXijGhTe/mODCfsiyQHAJ2lCYmu9Dg0T9EVVrauquVW1sKoW0ozXLK6qSd8MbYQN82/kyzRnEySZS3Mp6vrpLHKaDNMXNwGvAEjyfJqguH1aqxwNy4E3t59+OhhYV1W3TvSikbz0VP3d/mOLM2RffBjYHrigHc+/qaoWz1jRPRmyL54UhuyLi4DDk1wDPAK8u6q2urPuIfviXcDfJ/kvNAPbx2+Nf1gmOZfmj4O57XjMycA2AFX1CZrxmaOA1cD9wFuG2u5W2FeSpCk0qpeeJEkjwqCQJHUyKCRJnQwKSVIng0KS1MmgkMZJ8kiSK5JcleSfkuw0xds/Psnp7fQpSf5kKrcvTTWDQnq8B6rqRVW1H813dN420wVJM8mgkLp9l4GbpiV5d5KV7b38/2Jg+ZvbZT9Mck677NXts1IuT/L1JM+egfqlJ2wkv5ktjYIks2hu+3BmO384zb2SDqS5n//yJC+jucfYe4H/UFV3JHlmu4lvAwdXVSX5PeBPab4hLG1RDArp8Z6W5AqaM4kfAV9rlx/e/lzezm9PExwvBC6oqjsAqmrseQDzgS+09/vfFvjp9JQvTS0vPUmP90BVvQjYjebMYWyMIsAH2vGLF1XVXlV1Zsd2/idwelW9APh9mhvRSVscg0LahPapgX8MvKu9lf1FwH9Osj1AknlJdgG+Cbw+ybPa5WOXnuaw4RbOv4u0hfLSk9Shqi5PciWwpKrOaW9R/d32Lr33Ace1dyo9DbgkySM0l6aOp3mq2gVJ7qYJk91n4hikJ8q7x0qSOnnpSZLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ3+P6ld96C3N8iIAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluate_model(model, train_sequences, train_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.99      1.00       192\n",
      "           1       0.97      1.00      0.99        39\n",
      "\n",
      "   micro avg       1.00      1.00      1.00       231\n",
      "   macro avg       0.99      1.00      0.99       231\n",
      "weighted avg       1.00      1.00      1.00       231\n",
      "\n",
      "Accuracy: 0.9956709956709957\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluate_model(model, valid_sequences, valid_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.99      0.99       480\n",
      "           1       0.96      0.96      0.96        98\n",
      "\n",
      "   micro avg       0.99      0.99      0.99       578\n",
      "   macro avg       0.98      0.98      0.98       578\n",
      "weighted avg       0.99      0.99      0.99       578\n",
      "\n",
      "Accuracy: 0.986159169550173\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluate_model(model, test_sequences, test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "clean_model(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bidirectional LSTMs with self attention on Pretrained (Glove) Embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Self attention layer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras import initializers, regularizers, constraints\n",
    "from keras.layers.core import Layer\n",
    "\n",
    "\n",
    "def dot_product(x, kernel):\n",
    "    \"\"\"\n",
    "    Wrapper for dot product operation, in order to be compatible with both\n",
    "    Theano and Tensorflow\n",
    "    Args:\n",
    "        x (): input\n",
    "        kernel (): weights\n",
    "    Returns:\n",
    "    \"\"\"\n",
    "    if K.backend() == 'tensorflow':\n",
    "        return K.squeeze(K.dot(x, K.expand_dims(kernel)), axis=-1)\n",
    "    else:\n",
    "        return K.dot(x, kernel)\n",
    "\n",
    "\n",
    "class SimpleAttention(Layer):\n",
    "    def __init__(self,\n",
    "                 kernel_regularizer=None, bias_regularizer=None,\n",
    "                 W_constraint=None, b_constraint=None,\n",
    "                 bias=True,\n",
    "                 return_attention=False,\n",
    "                 **kwargs):\n",
    "        \n",
    "        self.supports_masking = True\n",
    "        self.init = initializers.get('glorot_uniform')\n",
    "\n",
    "        self.W_regularizer = regularizers.get(kernel_regularizer)\n",
    "        self.b_regularizer = regularizers.get(bias_regularizer)\n",
    "\n",
    "        self.W_constraint = constraints.get(W_constraint)\n",
    "        self.b_constraint = constraints.get(b_constraint)\n",
    "\n",
    "        self.bias = bias\n",
    "        self.return_attention = return_attention\n",
    "        super(SimpleAttention, self).__init__(**kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        assert len(input_shape) == 3\n",
    "\n",
    "        self.W = self.add_weight((input_shape[-1],),\n",
    "                                 initializer=self.init,\n",
    "                                 name='{}_W'.format(self.name),\n",
    "                                 regularizer=self.W_regularizer,\n",
    "                                 constraint=self.W_constraint)\n",
    "        if self.bias:\n",
    "            self.b = self.add_weight((1,),\n",
    "                                     initializer='zero',\n",
    "                                     name='{}_b'.format(self.name),\n",
    "                                     regularizer=self.b_regularizer,\n",
    "                                     constraint=self.b_constraint)\n",
    "        else:\n",
    "            self.b = None\n",
    "\n",
    "        self.built = True\n",
    "\n",
    "    def compute_mask(self, inputs, mask=None):\n",
    "        # do not pass the mask to the next layers\n",
    "        if self.return_attention:\n",
    "            return [None, None]\n",
    "        return None\n",
    "\n",
    "    def call(self, x, mask=None):\n",
    "        \n",
    "        # eij = Wx + b\n",
    "        eij = dot_product(x, self.W)\n",
    "\n",
    "        if self.bias:\n",
    "            eij += self.b\n",
    "\n",
    "        # Apply mask\n",
    "        if mask is not None:\n",
    "            eij *= K.cast(mask, K.floatx())\n",
    "\n",
    "        # a = softmax(eij)\n",
    "        a = K.expand_dims(K.softmax(eij, axis=-1))\n",
    "        weighted_input = x * a\n",
    "        result = K.sum(weighted_input, axis=1)\n",
    "\n",
    "        if self.return_attention:\n",
    "            return [result, a]\n",
    "        return result\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        if self.return_attention:\n",
    "            return [(input_shape[0], input_shape[-1]),\n",
    "                    (input_shape[0], input_shape[1])]\n",
    "        else:\n",
    "            return input_shape[0], input_shape[-1]\n",
    "\n",
    "\n",
    "class DeepAttention(Layer):\n",
    "    def __init__(self,\n",
    "                 kernel_regularizer=None, u_regularizer=None, bias_regularizer=None,\n",
    "                 W_constraint=None, u_constraint=None, b_constraint=None,\n",
    "                 bias=True,\n",
    "                 return_attention=False,\n",
    "                 **kwargs):\n",
    "\n",
    "        self.supports_masking = True\n",
    "        self.init = initializers.get('glorot_uniform')\n",
    "\n",
    "        self.W_regularizer = regularizers.get(kernel_regularizer)\n",
    "        self.u_regularizer = regularizers.get(u_regularizer)\n",
    "        self.b_regularizer = regularizers.get(bias_regularizer)\n",
    "\n",
    "        self.W_constraint = constraints.get(W_constraint)\n",
    "        self.u_constraint = constraints.get(u_constraint)\n",
    "        self.b_constraint = constraints.get(b_constraint)\n",
    "\n",
    "        self.bias = bias\n",
    "        self.return_attention = return_attention\n",
    "        super(DeepAttention, self).__init__(**kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        assert len(input_shape) == 3\n",
    "\n",
    "        self.W = self.add_weight((input_shape[-1], input_shape[-1],),\n",
    "                                 initializer=self.init,\n",
    "                                 name='{}_W'.format(self.name),\n",
    "                                 regularizer=self.W_regularizer,\n",
    "                                 constraint=self.W_constraint)\n",
    "        if self.bias:\n",
    "            self.b = self.add_weight((input_shape[-1],),\n",
    "                                     initializer='zero',\n",
    "                                     name='{}_b'.format(self.name),\n",
    "                                     regularizer=self.b_regularizer,\n",
    "                                     constraint=self.b_constraint)\n",
    "        else:\n",
    "            self.b = None\n",
    "\n",
    "        self.u = self.add_weight((input_shape[-1],),\n",
    "                                 initializer=self.init,\n",
    "                                 name='{}_u'.format(self.name),\n",
    "                                 regularizer=self.u_regularizer,\n",
    "                                 constraint=self.u_constraint)\n",
    "\n",
    "        super(DeepAttention, self).build(input_shape)\n",
    "\n",
    "    def compute_mask(self, inputs, mask=None):\n",
    "        # do not pass the mask to the next layers\n",
    "        if self.return_attention:\n",
    "            return [None, None]\n",
    "        return None\n",
    "\n",
    "    def call(self, x, mask=None):\n",
    "        # uit = tanh(Wx + b)\n",
    "        uit = dot_product(x, self.W)\n",
    "\n",
    "        if self.bias:\n",
    "            uit += self.b\n",
    "\n",
    "        uit = K.tanh(uit)\n",
    "\n",
    "        # ait = softmax(Ueij)\n",
    "        eij = dot_product(uit, self.u)\n",
    "\n",
    "        # Apply mask\n",
    "        if mask is not None:\n",
    "            eij *= K.cast(mask, K.floatx())\n",
    "\n",
    "        a = K.expand_dims(K.softmax(eij, axis=-1))\n",
    "        \n",
    "        weighted_input = x * a\n",
    "        result = K.sum(weighted_input, axis=1)\n",
    "\n",
    "        if self.return_attention:\n",
    "            return [result, a]\n",
    "        return result\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        if self.return_attention:\n",
    "            return [(input_shape[0], input_shape[-1]),\n",
    "                    (input_shape[0], input_shape[1])]\n",
    "        else:\n",
    "            return input_shape[0], input_shape[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "input_1 (InputLayer)         (None, 150)               0         \n",
      "_________________________________________________________________\n",
      "embedding_1 (Embedding)      (None, 150, 100)          4850800   \n",
      "_________________________________________________________________\n",
      "dropout_1 (Dropout)          (None, 150, 100)          0         \n",
      "_________________________________________________________________\n",
      "bidirectional_1 (Bidirection (None, 150, 200)          160800    \n",
      "_________________________________________________________________\n",
      "bidirectional_2 (Bidirection (None, 150, 200)          240800    \n",
      "_________________________________________________________________\n",
      "deep_attention_1 (DeepAttent (None, 200)               40400     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 1)                 201       \n",
      "=================================================================\n",
      "Total params: 5,293,001\n",
      "Trainable params: 442,201\n",
      "Non-trainable params: 4,850,800\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "inputs =  Input(shape=(150, ), dtype='int32')\n",
    "embeddings = Embedding(\n",
    "    input_dim=embedding_weights.shape[0],\n",
    "    output_dim=embedding_weights.shape[1],\n",
    "    input_length=input_length,\n",
    "    embeddings_initializer=\"zeros\",\n",
    "    weights=[embedding_weights],\n",
    "    trainable=False\n",
    ")(inputs)\n",
    "dropped_embeddings = Dropout(0.0)(embeddings)\n",
    "lstms_1 = Bidirectional(LSTM(100, return_sequences=True))(dropped_embeddings)\n",
    "lstms_2 = Bidirectional(LSTM(100, return_sequences=True))(lstms_1)\n",
    "attention =  DeepAttention()(lstms_2)\n",
    "outputs = Dense(1, activation='sigmoid')(attention)\n",
    "\n",
    "# Wrap model\n",
    "model = Model(inputs=inputs, outputs=outputs)\n",
    "model.summary()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer=\"adam\", loss=\"binary_crossentropy\", metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 2084 samples, validate on 231 samples\n",
      "Epoch 1/20\n",
      "2084/2084 [==============================] - 17s 8ms/step - loss: 0.2775 - acc: 0.8916 - val_loss: 0.1192 - val_acc: 0.9307\n",
      "Epoch 2/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.1194 - acc: 0.9559 - val_loss: 0.0645 - val_acc: 0.9784\n",
      "Epoch 3/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0637 - acc: 0.9779 - val_loss: 0.0559 - val_acc: 0.9870\n",
      "Epoch 4/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0353 - acc: 0.9885 - val_loss: 0.0308 - val_acc: 0.9870\n",
      "Epoch 5/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0276 - acc: 0.9899 - val_loss: 0.0214 - val_acc: 0.9957\n",
      "Epoch 6/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0195 - acc: 0.9928 - val_loss: 0.0261 - val_acc: 0.9913\n",
      "Epoch 7/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0177 - acc: 0.9947 - val_loss: 0.0575 - val_acc: 0.9740\n",
      "Epoch 8/20\n",
      "2084/2084 [==============================] - 15s 7ms/step - loss: 0.0149 - acc: 0.9957 - val_loss: 0.0267 - val_acc: 0.9957\n",
      "Restoring model weights from the end of the best epoch\n",
      "Epoch 00008: early stopping\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "    train_sequences, train_y,\n",
    "    validation_data=(valid_sequences, valid_y),\n",
    "    batch_size=64,\n",
    "    epochs=20,\n",
    "    callbacks=[EarlyStopping(patience=3, restore_best_weights=True, verbose=1)],\n",
    "    verbose=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xd8VuX5+PHPlR0yGAkzYSMCIjOCsp0FB4gbRYVWUatVa/3Vtt/WaqvfLuxXq7aKiIoLEctQUaQWBVSUkbBlykjCCCGMkISs6/fHOcEQQxLCc/I8T3K9X6/nlbPPlYjneu5x7ltUFWOMMaYqIf4OwBhjTOCzZGGMMaZaliyMMcZUy5KFMcaYalmyMMYYUy1LFsYYY6plycI0aCLSQURURMJqcOwEEVlaF3EZE2gsWZigISI7RKRQRBIrbE91H/gd/BPZSbHEikiuiHzk71iM8SVLFibYfAeMK1sRkXOBRv4L5weuBY4Dl4pIq7q8cU1KR8bUliULE2xeB24rt347ML38ASLSWESmi0iWiOwUkd+KSIi7L1REJovIARHZDlxRybkvi8geEckQkSdEJPQ04rsdeAFYA4yvcO22IvJvN65sEXmu3L47RWSjiBwVkQ0i0s/driLSpdxxr4rIE+7yCBFJF5FHRGQv8IqINBWRD9x75LjLyeXObyYir4hIprt/jrt9nYhcVe64cPdv1Pc0fndTj1myMMFmGRAvIt3dh/hNwBsVjnkWaAx0AobjJJeJ7r47gSuBvkAKcF2Fc18FioEu7jGXAXfUJDARaQ+MAN50P7eV2xcKfADsBDoAScAMd9/1wGPu8fHAaCC7JvcEWgHNgPbAJJz/p19x19sB+cBz5Y5/Hackdg7QAvg/d/t0Tk5ulwN7VDW1hnGY+k5V7WOfoPgAO4BLgN8CfwJGAguBMEBxHsKhQCHQo9x5dwGfucv/Be4ut+8y99wwoCVOFVJ0uf3jgEXu8gRgaRXx/RZIc5eTgBKgr7t+AZAFhFVy3gLggVNcU4Eu5dZfBZ5wl0e4v2tUFTH1AXLc5dZAKdC0kuPaAEeBeHd9FvBLf/83t0/gfKyO0wSj14HFQEcqVEEBiUA4zjf4MjtxHt7gPBR3V9hXpr177h4RKdsWUuH4qtwGvASgqhki8jlOtVQq0BbYqarFlZzXFthWw3tUlKWqBWUrItIIp7QwEmjqbo5zSzZtgYOqmlPxIqqaKSJfANeKyGxgFPBALWMy9ZBVQ5mgo6o7cRq6Lwf+XWH3AaAI58Ffph2Q4S7vwXlolt9XZjdOySJRVZu4n3hVPae6mERkEHAW8GsR2eu2IQwEbnYbnncD7U7RCL0b6HyKS+dxcgN+xUbzisNG/wI4GxioqvHAsLIQ3fs0E5Emp7jXazhVUdcDX6lqximOMw2QJQsTrH4CXKSqx8pvVNUSYCbwpIjEue0ID/F9u8ZM4H4RSRaRpsCvyp27B/gEeEpE4kUkREQ6i8jwGsRzO06VWA+cqp8+QE8gGudb+jc4ierPIhIjIlEiMtg9dyrwsIj0F0cXN26ANJyEEyoiI3HaYKoSh9NOcUhEmgG/r/D7fQT8020IDxeRYeXOnQP0wylRVCyxmQbOkoUJSqq6TVVXnGL3z4BjwHZgKfAWMM3d9xJOG8FqYBU/LJncBkQAG4AcnLr71lXFIiJRwA3As6q6t9znO5wqs9vdJHYVTsP5LiAduNH9Xd4FnnTjPIrz0G7mXv4B97xDwC3uvqo8jZOgDuB0Bvi4wv5bcUpe3wL7gQfLdqhqPvAeTvVexb+LaeBE1SY/MsY4RORRoKuqjq/2YNOgWAO3MQZw3sHAqd671d+xmMBj1VDGGETkTpwG8I9UdbG/4zGBx6qhjDHGVMuzkoWITBOR/SKy7hT7RUT+ISJbRWRN2fAG7r7bRWSL+7ndqxiNMcbUjGclC7dLXi4wXVV7VrL/cpxeK5fj9Ed/RlUHuvWmK3CGYlBgJdC/sheJyktMTNQOHTr49pcwxph6buXKlQdUtXl1x3nWwK2qi6sZMnoMTiJRYJmINBGR1jhDGCxU1YMAIrIQ523Ut6u6X4cOHVix4lQ9KY0xxlRGRHZWf5R/G7iTOHkYhXR326m2/4CITBKRFSKyIisry7NAjTGmoQvq3lCqOkVVU1Q1pXnzaktRxhhjasmfySKDk8foSXa3nWq7McYYP/FnspgH3Ob2ijofOOyOXbMAuMwdu6YpzhDSC/wYpzHGNHieNXCLyNs4jdWJIpKOM6BZOICqvgDMx+kJtRVnZM2J7r6DIvJHYLl7qT+UNXYbY4zxDy97Q42rZr8C955i3zS+H/jNGGOMnwV1A7cxxpi6YQMJGhOMDn4HmxdAXCtodS407Qgh9t2vPlBVCktKKSgsJa+omLzCEvILS8gvKnGXi8stl9Bi7+ckhBUweOw9nsZlycKYYHE8FzbMhbQ3YecXJ++LiINWPZ3E0aqX87NFdwiL9E+s9VxhcSn5Rc7DOs99eDvLzqegqGy5uNxyhYd+UfGJc8rOzy8sIa+ohJLSmo2scUXIMp4Of57vwrvAmEkQEurZ72zJwphApgq7voLUN2H9bCg6Bs06w0W/g57XQsEh2LvW+exZA2lvQeEU59yQMGje7eQE0qonRDet+p4NQFFJKTnHCjmQW8jBY4VkHztOdq7z8+AxZ9ux46f+Nl9cw4d5mfBQISo8lEYRoTSKCDuxHBMZRmJsJNERznp0eBjRESE0iggj2j0mOiLUXXb2RYeH0SgilGab3yFu4XOQPICut8z0NFGAJQtjAtOh3bB6hlOKyPkOImKh5zXQdzy0HQgi3x/bpu/3y6WlzvF713yfQLYtgtXlRstp0q5c8nB/Nk4++ZpBpriklIN57oM/t5DsY4Vk5zoPfichOMnAWT/OkYLiSq8TGiI0i4mgWaMIYiKdB3TTRhHuQz603AM/lOhKH+ih7oPf2VeWBMJDfVxF+NU/4ZNfQ+eL4cY3IKJR9eecIUsWxgSKonzY+AGkvQHbPwcUOgyF4Y9Aj9EQEVP9NUJCIKGz8zln7Pfbc/efnED2roVvP3TuAU5p40TycBNIYlcI9c8joqRUyckrPPFtv+xBn5173E0E7oPfLQkcyiuq9DohAs1iIkiIiaRZTATd28STGBNBs5hIEmIjSIiJICHW2ZcYG0F8VDghIQGcNFVh8d9g0ZPQfTRcO7XOqhotWRjjT6qQsRJS34B1/4bjh6FxOydB9BkHTTv45j6xLaDLJc6nzPFc2L/BSSJlCWT5VCgucPaHRkLLHicnkZbnQGTsad++1H34H6yk6ufkaiBnPSevkMoGxBaBpo2ch3yzmAi6t4p3kkElD/5mMZE0iQ7wh//pUIWFv4Mvn4XeN8PoZ+s0mVuyMMYfju51q5neggObICwaeoyBvrdA+yF107MpMhbaDnA+ZUqKIXuLWwJZ7fzc+D6smu4eIE6ppUIpRGNbkHX0OLtz8knPySM9J9/9OMsZOfkUlpRWGkbTRuHuAz+Ss1rEkuA+6J0HfoT78HeSQNNGEYTWl4f/6SgtgQ8fgpWvwoBJMPIvdd77rd7MlJeSkqI2RLkJaMXHYdNHToLY+h/QEqf9oc8tTpVRVLy/I6ycKno4nSM7UsnbuQr2riUmZwPxBZknDtmvTdhQ2p712p4NpR3YoO05Gt2WpGYxJDdtRHKzaFrFR5EQG+lUA8U6VUNNG4UT5uv6/PqmpAhm3w3rZsGQh+DiR33aviQiK1U1pbrjrGRhjNf2rHZ6M62dCfk5ENcGBj/gJInELv6ODnD69mcfKzypNJCek8fug87PjEP5FBSFAue5H2jXqIjBcXvoF76Ls9lBr4KtDDs2nxB1G49DYyC6JzTpBS3OhU4joGkbP/2GQaqoAN6dAJs/got/D0Mf8lsoliyM8cKxA7BmplOK2LcWQiOg2xXQZzx0vtDzbo4VqSo5eUUnJYD0ClVG+UUlJ53TpFE4bZs2omvLOC7q1sIpITSNPvEzJrKSx0fxccj69vs2kL1rneq25S85VW1XTHZ6dJnqHc+FGePgu8Vw+WQYcKdfw7FkYYyvlBQ51UupbzhvV5cWOd1aL5/svBPRqJlnt1ZVDuUV/bBkUG49r/DkZNA4OpzkptF0ah7D8K7Nv08EzaJJahJNXFT46QcSFgmtezufMqWlkL0V5v8C5t4LO75wkkZNenc1VPk58Ob1TueHq19wOjv4mSULY87U/o1OglgzE47th5jmMPAup5qpZY9aXbKkVDlaUMSR/GKOFBRxJL/I/fn9+qH8IjIP5Z8oGeQeP/ndgfioMJKbNqJDQgxDupQlg2jaNmtEUtNo4muTDGojJASad4Vb58Dnf4HP/wqZqXDDa9D87LqJIZjkZsHrY50S2vWvOd2mA4AlC2NqIz8H1s5yqpkyVzlvS3cd6SSIsy6lVMI4eryYIwfzTjzkD5944BdxpKC40gRw1N1+9HjlL42VEYH4qHBaN46ibbNGXNA5oVw1kVNCaBxdR8mgpkJC4cLfOI36/54EUy6EK/8Pet/o78gCx+F0mH618/PmGSd3dfYz6w1lTCVKS5XcQveBXvYwzysgevcSknb8m3b7FxGmhWRGdmZx7I/4NHQY6UWxJxJA7vHiSt8TKC8uKoz4qHAaR4cTH+0sx0eHuz/Lr4cRH112nLMeExEW3O8PHMmEWT92hjLpdzuM+guER/s7Kv/K3uYkioJDcPNMaH9BndzWekMZcxo2ZB7hpSXbWb7j4Ilv9mUP+46yh+tCP+ea0KW0loPkaCxvlIxgfuhFZNCVuJJw4iPCSYoJp3vruBMP+cblHvQVE0BsZFjDfF+gTHwbuP0D+O8f4YunIWOVUy2V0NnfkfnHvg3w+tVOu9ft70ObPv6O6AesZGEaLFXlq23ZvLB4O4s3ZxETEcpF3VuSEBNBYlgBvY5+Rve979M8JxWVEHKTR1DQcxwR3S8nNjamYT/sfWnzAph9l/NC4JhnTx6mpCHIWAlvXAthUU67TotudXp7K1mYwFB8HEoK/R3FSYpLSlm4cT+vfPEd6zOPkBATyW8ubseNKW1pfGid+07EPCjKg4Sz4JLHkF43ERffmjh/B18fdf0R3LUEZk103inY+SVc9kTDGF59xxfw1o1OT7nb5kKzjv6O6JSsZGF8r6QYti50Rkzd9LHThTSYRMY7I7z2GQ/JKUE9GmtQKS6E/zwGy553uhxf/6rvxsYKRFsWwjvjnVGAb5vrVM35gZUsTN3b/60zYurqd77vQjrgTr/9T1Amr7CEFTtyWLHzIHmFJSQ1ieaCzgl0bRlLSMVEEN8Guo6qkyGfTQVhETDyf6H9IJjzU3hhGIz9l/MyY32zfja8d6czQdWtsyEm0d8RVcuShTkz+Tmw7j2n6qaSLqSE+q/75u6Deby89DveWb6b/KISLu7WgruGd+a8Dk0RKy0Eru5XOqPbvjsBZtwMF9wHlzzm139LPpX6Bsz7GSQPgJvfgegm/o6oRixZmNNXWgLbFznvGGz8AEqOQ8ue8KM/Qa8b/P4taV3GYaYs3s6Ha/cQIjCmTxKThnWia0trcQgazTrCTz6BBf8DXz0Hu7+G616BJm39HdmZWfYCfPwIdLoQbnozqN5it2Rhai57m9MOsXoGHMlwJszpf7tTimjd2691+6rKF1uzeXHxNpZsOUBsZBg/GdKRiYM70LpxA++/H6zCIp1hQdoPgnn3w4tDYewU6HqZvyM7faqwZDL89wnodiVcNy3oGvAtWZiqHT/q1K+mvgm7l4GEOG+V/uh/4exRfv8HX1xSyvx1e3nx822szzxC87hIHhnZjZsHtgu8N5hN7fS8xpk3493b4a3rYcjP4cLf+m0Wv9OmCgsfhS//Ab1uhDH/DJ7Yywm+iI33Skth51KnmmnDXKcLaWJXuORx5x97fGt/R0heYTHvrkjnpSXbSc/Jp1PzGP5y7blc3TeJyLC6HdHV1IHELnDHf+CjR2Dp/8Gur51v5wHwb7FKpaXOAIorpkHKT5xBJet40iJfsWRhvpezE1a/7SSJQzudLqS9bgioLqTZuceZ/tVOpn+1g5y8Ivq1a8KjV/bgku4tg3v4C1O98GgY/Q9oPxg+eBBeGALXvgSdL/J3ZJUrKYa5P4U178DgB51G+gD4f6i2LFk0dIV5sHGe00NjxxJAoNNwuOh3Tq+UABmvZ1d2HlOXbmfmit0UFJVySfeW3D28EykdvBv22wSo3jc6bWTv3g6vXwPDf+nMWV7Hc4RUqfi4M/bVtx84M9sN/YW/IzpjliwaIlWnd0nam7BuNhQedV5+uvB/oPe4gOpxsjb9MC8u3sb8tXsIDRHG9nV6NnVpYT2bGrQW3eDO/8KHv3CGPd/1FVz7MsS28HdkUHgMZtzi9Bgc9TcYOMnfEfmEJYuG5Ejm99VM2VshPAbOudrpzdR+UMAUkVWVJVsO8OLibXyxNZu4yDDuHNaJiYM60qpxlL/DM4EiIgau/pdTLTX/Ybda6mXoONR/MeUfgrdugPTlTkN231v8F4uPeZosRGQk8AwQCkxV1T9X2N8emAY0Bw4C41U13d33V+AKIARYCDyg9WVskrpUVACbPnR6M21fBFrq/M815CHoMQYiY/0d4QlFJaXMX7uHFz7fzsY9R2gRF8mvR3Vj3MB2dTdRjwkuItDvVmd4kHdvh+mjnRLykIfqviH52AFn5Nj93zrvhJxzdd3e32OeJQsRCQWeBy4F0oHlIjJPVTeUO2wyMF1VXxORi4A/AbeKyCBgMNDLPW4pMBz4zKt46xVV523qtLecCXoKDkF8slNv2udmaNbJ3xGeJK+wmHeW72bqku/IOJRP5+Yx/PW6Xozp08Z6NpmaadUTJn0G7z/gDHu+6yvnnYyYhLq5/+EMJ1Ec2gXj3nZGL6hnvCxZDAC2qup2ABGZAYwByieLHsBD7vIiYI67rEAUEAEIEA7s8zDW+iF3v9PzIvVNyNroDHnc/SqnmqnjsMBqAAQO5B5n+pc7mL5sJ4fyijivQ1MeH30OF3VrYT2bzOmLjHOqodoPho9/5VRLXf8KtDvf2/se3A7Tx0BeDoz/N3QY7O39/MTLZJEE7C63ng4MrHDMauAanKqqsUCciCSo6lcisgjYg5MsnlPVjRVvICKTgEkA7dq18/1vEAyKC2HLAqcUsXkBaAkkpTjTVZ5zTUCOO7PjwDGmLt3OuyvSOV5cymU9WnLX8E70b289m8wZEoHzfgJJ/Z1qqVcud7qsDvqZN21y+zc6s9uVHIfb50FSP9/fI0D4u4H7YeA5EZkALAYygBIR6QJ0B5Ld4xaKyFBVXVL+ZFWdAkwBZ4jyOos6EOxd6ySINe9AXjbEtoRB9zmliOZn+zu6Sq3efYgpi7fz0bo9hIWEcE2/JO4Y2okuLQKn3cTUE236wF2LYe59sPB3zhwZV//TmTfCVzJTna67oeEwYT607OG7awcgL5NFBlC+D2ayu+0EVc3EKVkgIrHAtap6SETuBJapaq677yPgAuCkZNEg7fwKPvol7F0DIeHQ7XLnpbnOFwXkEAKqyuebs3jx8+18tT2buKgw7hremYmDOtAi3no2GQ9FNYYbpsPXL8Inv4UXhzvVUsnVTt1QvZ1fwps3OOOj3TanQUwH6+XTZTlwloh0xEkSNwE3lz9ARBKBg6paCvwap2cUwC7gThH5E0411HDgaQ9jDQ6lJTD3XueFn1F/hXOv9+03JR/bfTCPu99YyfrMI7SKj+J/Lu/OTQPaEmc9m0xdEYHz74bk85whz6eNdGbhG3hX7aultv4HZoyHxsnOpEWNk3wacqDyLFmoarGI3AcswOk6O01V14vIH4AVqjoPGAH8SUQUpxrqXvf0WcBFwFqcxu6PVfV9r2INGutnw8FtzrelHmP8HU2VvjtwjJtfWsax48X87bpejOmTRERYcI6JY+qB5P5w1+fOpEofPwI7v4Axzzmlj9OxYZ7zZnaLbjB+NsQ29ybeAGTTqgaL0lKnd0dpMfx0WUAPRrZl31Funvo1JaXKGz8ZSI828f4OyRiHKnz5rDN9a5O2cP1rTvtGTaS97Yz1lJQCt7wbkJ1HaqOm06oG7hPHnGzzx7B/PQz1w8tGp2F95mFunLIMgHcmnW+JwgQWERh8P0yc7/QkfPlSWP6yk0Sq8s1LMOdu6DDUmQa1niSK0xG4Tx3zvbKJU5q0h57X+TuaU0rbfYhxU5YRFRbCzLsu4Cybmc4Eqnbnw91LnIf/hw/Bez9x5m6pzJKnnOFEzr4cbp4ZUKMe1CVLFsFg+2eQsRKGPBiQPZ4Alu84yPipX9O4UTjv3HUBHRODZ7pI00DFJMIts5wRltfPhikjYN/67/erOtVVn/7B6Uxyw3QIb7g9+CxZBIMlT0Fca+cdigD0xdYD3PbyN7SIj+TduwbRtlkjf4dkTM2EhMCwh+G2eU7J4qWLYNXr7qRFDzsTLfWfAGNfdN6naMAsWQS6XcuceSYG3e/3KUwrs+jb/Ux8dTntmjXinUkX2KiwJjh1HAp3L4W2A2DeffDPgbB8qvPm95VPB9xQOf5gySLQLZ4MjRKg/+3+juQHPl63l0mvr6Bry1jennQ+zeMCL5kZU2OxLeDWOTD8V5C9zRm99tI/BszQ/f4WmBXgxpGZBlsXOnWqEYHVBjA3LYOHZq6mV3JjXp04gMbRDbuIbuqJkFC48Ncw5OcNun2iMpYsAtmSpyCyMQy409+RnGTmit088t4azuvQjGkTziM20v4ZmXrGEsUPWDVUoMraBBvfdxLF6b5l6qHXv9rBL2etYUiXRF6bOMAShTENhP2fHqiW/B3Co+H8n/o7khOmLtnOEx9u5JLuLXju5n5EhVujnzENhSWLQHTwO1j7Lgy8u+5m+qrGs59u4amFm7n83FY8fWNfG+fJmAbGkkUg+uIZp6Ft0M/8HQmqyuRPNvH8om2M7ZvE367rRVioJQpjGhpLFoHmSCakvQl9x0N8a7+Goqo88eFGXl76HeMGtOXJq8+16U6NaaAsWQSaL5915q0Y/IBfwygtVR6dt443lu1iwqAO/P6qHoj1NzemwbJkEUiOHYAVr0CvG6BpB7+FUVKqPPLeGmatTOeu4Z341chuliiMaeAsWQSSZf+E4gIY8pDfQigqKeWhmat5f3UmD15yFg9cfJYlCmOMJYuAkX/IGTO/x2ho3tUvIRwvLuH+t1NZsH4fj4zsxj0j6v+8wsaYmrFkESiWvwTHj8DQX/jl9gVFJdz9xko+25TFY1f1YMLgjn6JwxgTmCxZBILCY/DVP+Gsy6B17zq/fV5hMXe8toKvtmfzp2vOZdyAdnUegzEmsFmyCAQrX4X8gzDs/9X5rY8WFDHxleWs2pXDU9f35pp+yXUegzEm8Fmy8LeiAvjiH870jm0H1OmtD+UVcvu0b1ifeYRnx/Xjil7+fa/DGBO4LFn4W9qbkLsXrnmxTm+bnXuc8S9/w7b9ubwwvj+X9GhZp/c3xgQXSxb+VFIEXzwNSSnQcXid3Xb/kQJunvo16Tl5TL09hWFdm9fZvY0xwcmShT+tnQWHdsGov9bZbFwZh/K55aVl7D96nFcnDuD8ToExUKExJrBZsvCX0lJY+ndo2RO6jqyTW+7KzmPcS8s4kl/E6z8ZSP/2TevkvsaY4GfJwl82zoMDm+G6aXVSqtiWlcvNLy3jeHEpb915PucmB86ESsaYwGfJwh9UnSlTE7pAj6s9v923e48wfurXAMyYdD7dWsV7fk9jTP1iExP4w5aFsHeNMwZUiLezza3LOMxNU5YRGiLMmHSBJQpjTK1YyaKuqcLiv0Hjds7osh5auTOHCa98Q3xUOG/dOZD2CTGe3s8YU395WrIQkZEisklEtorIryrZ315EPhWRNSLymYgkl9vXTkQ+EZGNIrJBRDp4GWud2bEE0r+BwfdDaLhnt1m2PZvbXv6ahJgIZt59gSUKY8wZ8SxZiEgo8DwwCugBjBORHhUOmwxMV9VewB+AP5XbNx34m6p2BwYA+72KtU4tngyxLaHvrd7dYnMWE175htZNonnnrgtIahLt2b2MMQ2DlyWLAcBWVd2uqoXADGBMhWN6AP91lxeV7XeTSpiqLgRQ1VxVzfMw1rqRvgK++xwuuA/Cozy5xX827OOO11bQMTGWGZPOp2W8N/cxxjQsXiaLJGB3ufV0d1t5q4Fr3OWxQJyIJABdgUMi8m8RSRWRv7kllZOIyCQRWSEiK7Kysjz4FXxs8WSIbgopP/bk8h+u2cPdb6yke+s43r5zIImxkZ7cxxjT8Pi7N9TDwHARSQWGAxlACU7D+1B3/3lAJ2BCxZNVdYqqpqhqSvPmAT5kxd51sPkjGHgPRMb6/PKzU9P52dur6NO2Ca/fMZAmjSJ8fg9jTMPlZbLIANqWW092t52gqpmqeo2q9gX+x912CKcUkuZWYRUDc4B+HsbqvSVPQUQcDJzk80vP+GYXD81czfmdEnjtxwOIj/Ku4dwY0zB5mSyWA2eJSEcRiQBuAuaVP0BEEkWkLIZfA9PKndtERMqKCxcBGzyM1VsHtsD62TDgDqcayode/eI7fvXvtQzv2pxpE84jJtJ6QxtjfM+zZOGWCO4DFgAbgZmqul5E/iAio93DRgCbRGQz0BJ40j23BKcK6lMRWQsI8JJXsXpu6f9BWBScf69PL/vC59t47P0NXNajJS/e2p+ocG9f8DPGNFyefg1V1fnA/ArbHi23PAuYdYpzFwK9vIyvThzaBWvegfPugFjftKuoKs98uoWn/7OFq3q34e839CY81N/NT8aY+szqLLz2xTOAwKD7fXI5VeUvH2/ihc+3cV3/ZP5ybS9CQ+pmeHNjTMNlX0e9dHQvrHod+oyDxhV7DdfOS0u288Ln2xh/fjv+aonCGFNHrGThpa+eg9IiGPygTy5XWqq89uVOBnVO4I9jeiJ1NGGSMcZYycIreQdh+TToeR0kdPbJJVfszCHjUD7XpyRbojDG1ClLFl75+gUoOgZDH/LZJWenZhAdHsplPVr57JrGGFMTliy8UHDESRbdroQW3X1yycLiUuav3cNl57S0dymMMXXOkoUXlk+FgsMw7GGfXfKzTfs5nF/E1X1801BujDGno9pkUdmS4HVNAAAcLElEQVQAfqYKhXnw1fPQ+WJo09dnl52blkmzmAiGnJXos2saY0xN1aRkscUd9bXiXBSmMqumQ94Bn5YqjhYU8Z+N+7iyV2t7+c4Y4xc1efL0BjYDU0VkmTssuE3kXJniQvjyH9BuELQf5LPLfrxuL8eLSxljVVDGGD+pNlmo6lFVfUlVBwGPAL8H9ojIayLSxfMIg8nqt+FIBgz7hU8vOyctg3bNGtGvXROfXtcYY2qqRm0WIjJaRGYDTwNP4cwv8T4Vxn1q0EqKnQED2/R12it8ZN+RAr7cls3VfdrYuxXGGL+pSR/MLThTnv5NVb8st32WiAzzJqwgtH425HwHl70JPnyov786E1UY09eqoIwx/lOTZNFLVXMr26GqvhkdL9iVlsKSydC8O5x9uU8vPSctg3OTGtO5ue9n1zPGmJqqSbIoFpF7gXOAqLKNqurNRNLBaNOHkPUtXDMVQnzXW2nr/qOsyzjCb6/wzYt9xhhTWzV5sr0OtAJ+BHyOMz3qUS+DCiqqsHgyNO0I54z16aXnpGYSIjC6dxufXtcYY05XTZJFF1X9HXBMVV8DrgAGehtWENn2KexJgyE/h1DfDcOhqsxdncHgLom0iI+q/gRjjPFQTZJFkfvzkIj0BBoDLbwLKcgsfgrik6D3OJ9edtWuHHYfzLd3K4wxAaEmX4WniEhT4LfAPCAW+J2nUQWLnV/Cri9h1F8hLMKnl56TmklkWAg/OqelT69rjDG1UWWyEJEQ4Iiq5gCLcd6vMGUWT4aY5tDvNp9etqiklA/WZHJJj5bERYX79NrGGFMbVVZDqWop8Ms6iiW4ZKx02isuuBfCo3166cWbs8jJK2KsVUEZYwJETdos/iMiD4tIWxFpVvbxPLJAt+TvENUYUn7i80vPScukSaNwhnVt7vNrG2NMbdSkzeJG9+e95bYpDblKat8G+PYDGP4IRPl2TMXc48Us3LCXa/slExFmI8waYwJDtclCVTvWRSBBZenfITwGBt7t80t/sn4vBUWlXG3DexhjAki1yUJEKm29VdXpvg8nCGRvg3XvOW0VjXxfGzcnLZOkJtH0b9fU59c2xpjaqkk11HnllqOAi4FVQMNMFl88DSHhcMF9Pr901tHjLN2SxT0jOhMSYiPMGmMCR02qoX5Wfl1EmgAzPIsokB1Oh7S3of8EiGvl88u/vzqTUsXm2TbGBJzatKAeAxpmO8aXzwIKgx/w5PJz0zLo0Tqes1rGeXJ9Y4yprZq0WbyP0/sJnOTSA5jpZVABKXc/rHwVet0ETdr6/PLfHTjG6vTD/Obybj6/tjHGnKmatFlMLrdcDOxU1fSaXFxERgLPAKHAVFX9c4X97YFpQHPgIDC+/LXdub43AHNU1feNBKfjq+ehpNAZMNADc1IzEIHRva0KyhgTeGqSLHYBe1S1AEBEokWkg6ruqOokEQkFngcuBdKB5SIyT1U3lDtsMjBdVV8TkYuAPwG3ltv/R5xhRvwrPweWvww9roZE3087rqrMTcvggk4JtGpsI8waYwJPTdos3gVKy62XuNuqMwDYqqrbVbUQp1F8TIVjegD/dZcXld8vIv2BlsAnNbiXt76eAoVHYegvPLl82u5D7MjOs4ZtY0zAqkmyCHMf9gC4yzUZYjUJ2F1uPd3dVt5q4Bp3eSwQJyIJ7gCGTwEPV3UDEZkkIitEZEVWVlYNQqqF47nw9b+g6yho1dOTW8xNyyQiLISR5/q+h5UxxvhCTZJFloiMLlsRkTHAAR/d/2FguIikAsOBDJySy0+B+dW1jajqFFVNUdWU5s09GkdpxTSnGmpYlXmr1ordEWYv7taCeBth1hgToGrSZnE38KaIPOeupwM1GZM7AyjfbSjZ3XaCqmbilixEJBa4VlUPicgFwFAR+SnO/BkRIpKrqr+qwX19p6gAvnoOOo2A5BRPbrF06wEO5BbaJEfGmIBWk5fytgHnuw9zVDW3htdeDpwlIh1xksRNwM3lDxCRROCgOxT6r3F6RqGqt5Q7ZgKQUueJAiD1dcjdB9e+7Nkt5qZlEh8VxoXdbIRZY0zgqrYaSkT+V0SaqGququaKSFMReaK681S1GLgPWABsBGaq6noR+UO5aq0RwCYR2YzTmP1krX8TXyspgi+egbYDocMQT26RV1jMgvV7uaJXayLDQj25hzHG+EJNqqFGqepvylZUNUdELseZZrVKqjofmF9h26PllmcBs6q5xqvAqzWI07fWvAOHd8MVfwfxZpymhRv2kVdYYlVQxpiAV5MG7lARiSxbEZFoILKK44NfaYkzuVGrXnDWpZ7dZk5qBm0aRzGgg80lZYwJbDUpWbwJfCoirwACTABe8zIov9swBw5ug+tf86xUkZ17nMVbDnDH0I42wqwxJuDVpIH7LyKyGrgEZ4yoBUB7rwPzG1WnVJHYFbqPrv74Wvpw7R5KSpWxNsmRMSYI1HTU2X04ieJ64CKcBuv6afPHsG+d87Z2iHfTms5JzaBbqzi6tfLttKzGGOOFU5YsRKQrMM79HADeAURVL6yj2OqeKiyeDE3aQ8/rPLvNzuxjrNp1iEdG2gizxpjgUFU11LfAEuBKVd0KICLeDLkaKLZ/Bhkr4Mr/g9CaNOfUzty0TABG92nj2T2MMcaXqqpnuQbYAywSkZdE5GKcBu76a8lTENca+txS/bG1pKrMSctgQMdmJDWJ9uw+xhjjS6dMFqo6R1VvArrhjAj7INBCRP4lIpfVVYB1ZtfXsGMJDPoZhHnXM3hdxhG2Zx2zEWaNMUGl2hZcVT2mqm+p6lU44zulAo94HlldWzIZGiU482t7aE5aBhGhIVxxbmtP72OMMb50Wt19VDXHHen1Yq8C8os9q2HLJ3D+PRAR49ltSkqVeaszGXF2cxo3shFmjTHBw7u+ocFkyVMQGQ/n3enpbb7cdoCso8e52t6tMMYEGUsW2dtgwzwYMAmim3h6qzmpmcRFhnFRtxae3scYY3zNu/6hwaJZJ7jlXWjT19PbFBSVsGD9Xkb1bEVUuI0wa4wJLpYsRDwdLLDMfzbuI/d4sQ3vYYwJSlYNVUfmpGbSMj6SgZ0S/B2KMcacNksWdSDnWCGfbdrP6N5tCLURZo0xQciSRR34cO0eikvVJjkyxgQtSxZ1YG5aBl1axHJOGxth1hgTnCxZeCw9J4/lO3IY2zcJ8WgiJWOM8ZolC4+dGGG2t40wa4wJXpYsPKSqzEnNIKV9U9o2a+TvcIwxptYsWXhow54jbNmfyxh7t8IYE+QsWXhoblomYSFiI8waY4KeJQuPlJQq89KcEWabxUT4OxxjjDkjliw88vV32ew9UmDvVhhj6gVLFh6Zm5pJTEQol3Rv6e9QjDHmjFmy8EBBUQnz1+7hRz1bER1hI8waY4KfJQsPLPp2P0ePF9s828aYesOShQfmpGXQPC6SQZ1thFljTP3gabIQkZEisklEtorIryrZ315EPhWRNSLymYgku9v7iMhXIrLe3Xejl3H60uG8IhZ9m8VVvdoQFmq52BhTP3j2NBORUOB5YBTQAxgnIj0qHDYZmK6qvYA/AH9yt+cBt6nqOcBI4GkR8XbOUx/5aN0eCktKubqvDe9hjKk/vPzqOwDYqqrbVbUQmAGMqXBMD+C/7vKisv2qullVt7jLmcB+oLmHsfrM7NQMOiXGcG5SY3+HYowxPuNlskgCdpdbT3e3lbcauMZdHgvEichJFf0iMgCIALZVvIGITBKRFSKyIisry2eB11bmoXy+/u4gY/rYCLPGmPrF35XqDwPDRSQVGA5kACVlO0WkNfA6MFFVSyuerKpTVDVFVVOaN/d/wWPeameEWauCMsbUN2EeXjsDaFtuPdnddoJbxXQNgIjEAteq6iF3PR74EPgfVV3mYZw+Myc1g77tmtA+IcbfoRhjjE95WbJYDpwlIh1FJAK4CZhX/gARSRSRshh+DUxzt0cAs3Eav2d5GKPPbNp7lG/3HrV3K4wx9ZJnyUJVi4H7gAXARmCmqq4XkT+IyGj3sBHAJhHZDLQEnnS33wAMAyaISJr76eNVrL4wJy2D0BDhil42wqwxpv7xshoKVZ0PzK+w7dFyy7OAH5QcVPUN4A0vY/Ol0lJlbmoGQ89KJDE20t/hGGOMz/m7gbteWL7jIJmHCxhrkxwZY+opSxY+MCctk0YRoVzaw0aYNcbUT5YszlBhcSnz1+7hsh4taRThaa2eMcb4jSWLM/TZpv0czi+yebaNMfWaJYszNCctg4SYCIZ2SfR3KMYY4xlLFmfgSEER/9m4n6t62wizxpj6zZ5wZ+DjdXspLC5lTB8b3sMYU79ZsjgDc9MyaJ/QiD5tg2L0dGOMqTVLFrW070gBX27LthFmjTENgiWLWnp/dSaqcLVVQRljGgBLFrU0OzWDXsmN6dQ81t+hGGOM5yxZ1MLW/UdZn3nERpg1xjQYlixqYU5qJiECV/a2EWaNMQ2DJYvTpKrMXZ3B4C6JtIiL8nc4xhhTJyxZnKZVu3LYfTDfqqCMMQ2KJYvTNDs1g6jwEH7Us5W/QzHGmDpjyeI0FJWU8uGaPVzaoxWxkTbCrDGm4bBkcRoWb84iJ6/I3q0wxjQ4lixOw5y0TJo2CmdY1+b+DsUYY+qUJYsayj1ezMINe7miV2vCbYRZY0wDYxXvNbRg3V4KikqtF5QxdaCoqIj09HQKCgr8HUq9ERUVRXJyMuHh4bU635JFDc1JyyC5aTT92zf1dyjG1Hvp6enExcXRoUMHG6jTB1SV7Oxs0tPT6dixY62uYfUpNbD/aAFfbD3A1TbCrDF1oqCggISEBPv/zUdEhISEhDMqqVmyqIEPVu+hVOHqvtYLypi6YonCt87072nJogbmpmVwTpt4urSI83coxhjjF5YsqrE9K5fV6YetYduYBiQ7O5s+ffrQp08fWrVqRVJS0on1wsLCGl1j4sSJbNq0yeNI6441cFdjTlomIjDaXsQzpsFISEggLS0NgMcee4zY2Fgefvjhk45RVVSVkJDKv3O/8sornsdZlyxZVEFVmZuWwaDOCbSMtxFmjfGHx99fz4bMIz69Zo828fz+qnNO+7ytW7cyevRo+vbtS2pqKgsXLuTxxx9n1apV5Ofnc+ONN/Loo48CMGTIEJ577jl69uxJYmIid999Nx999BGNGjVi7ty5tGjRwqe/k9esGqoKabsPsTM7jzFWBWWMcX377bf8/Oc/Z8OGDSQlJfHnP/+ZFStWsHr1ahYuXMiGDRt+cM7hw4cZPnw4q1ev5oILLmDatGl+iPzMeFqyEJGRwDNAKDBVVf9cYX97YBrQHDgIjFfVdHff7cBv3UOfUNXXvIy1MnPTMokIC2GkjTBrjN/UpgTgpc6dO5OSknJi/e233+bll1+muLiYzMxMNmzYQI8ePU46Jzo6mlGjRgHQv39/lixZUqcx+4JnyUJEQoHngUuBdGC5iMxT1fJpdzIwXVVfE5GLgD8Bt4pIM+D3QAqgwEr33Byv4q2oqKSU91dnckn3FsRH1e6NR2NM/RMTE3NiecuWLTzzzDN88803NGnShPHjx1f6LkNERMSJ5dDQUIqLi+skVl/yshpqALBVVberaiEwAxhT4ZgewH/d5UXl9v8IWKiqB90EsRAY6WGsP7B06wGyjxVaLyhjzCkdOXKEuLg44uPj2bNnDwsWLPB3SJ7xshoqCdhdbj0dGFjhmNXANThVVWOBOBFJOMW5P3hqi8gkYBJAu3btfBY4wNzUDBpHhzPi7OBqhDLG1J1+/frRo0cPunXrRvv27Rk8eLC/Q/KMv3tDPQw8JyITgMVABlBS05NVdQowBSAlJUV9FVReYTGfbNjHmD5JRIRZHwBjGrLHHnvsxHKXLl1OdKkF563o119/vdLzli5demL50KFDJ5ZvuukmbrrpJt8H6jEvk0UG0LbcerK77QRVzcQpWSAiscC1qnpIRDKAERXO/czDWE+ycMM+8gpLbJIjY4xxefm1eTlwloh0FJEI4CZgXvkDRCRRRMpi+DVOzyiABcBlItJURJoCl7nb6sSc1AzaNI7ivA7N6uqWxhgT0DxLFqpaDNyH85DfCMxU1fUi8gcRGe0eNgLYJCKbgZbAk+65B4E/4iSc5cAf3G2ey849zuItBxjTN4mQEBvIzBhjwOM2C1WdD8yvsO3RcsuzgFmnOHca35c06swHa/ZQUqrWC8oYY8qx1tsK5qRl0K1VHGe3shFmjTGmjCWLcnZmHyN11yGu7mulCmOMKc+SRTlzy0aY7W29oIxpyC688MIfvGD39NNPc88995zynNjYWAAyMzO57rrrKj1mxIgRrFixosp7P/300+Tl5Z1Yv/zyy0/qeusvlixcqsqctAwGdmxGmybR/g7HGONH48aNY8aMGSdtmzFjBuPGjav23DZt2jBrVqVNsTVSMVnMnz+fJk2a1Pp6vuLvl/ICxtqMw2zPOsakoZ38HYoxpryPfgV71/r2mq3OhVF/PuXu6667jt/+9rcUFhYSERHBjh07yMzMpG/fvlx88cXk5ORQVFTEE088wZgxJ49itGPHDq688krWrVtHfn4+EydOZPXq1XTr1o38/PwTx91zzz0sX76c/Px8rrvuOh5//HH+8Y9/kJmZyYUXXkhiYiKLFi2iQ4cOrFixgsTERP7+97+fGLH2jjvu4MEHH2THjh2MGjWKIUOG8OWXX5KUlMTcuXOJjvbtl14rWbjmpGYSERrCqHNb+zsUY4yfNWvWjAEDBvDRRx8BTqnihhtuIDo6mtmzZ7Nq1SoWLVrEL37xC1RPPXjEv/71Lxo1asTGjRt5/PHHWbly5Yl9Tz75JCtWrGDNmjV8/vnnrFmzhvvvv582bdqwaNEiFi1adNK1Vq5cySuvvMLXX3/NsmXLeOmll0hNTQWcAQ3vvfde1q9fT5MmTXjvvfd8/jexkgVQUqq8vyaTC7s1p3G0jTBrTECpogTgpbKqqDFjxjBjxgxefvllVJXf/OY3LF68mJCQEDIyMti3bx+tWlU+jcHixYu5//77AejVqxe9evU6sW/mzJlMmTKF4uJi9uzZw4YNG07aX9HSpUsZO3bsiVFvr7nmGpYsWcLo0aPp2LEjffr0AZwh0Hfs2OGjv8L3rGQBfLntAFlHj9u7FcaYE8aMGcOnn37KqlWryMvLo3///rz55ptkZWWxcuVK0tLSaNmyZaVDklfnu+++Y/LkyXz66aesWbOGK664olbXKRMZGXli2ash0C1Z4FRBxUWFcWE3G2HWGOOIjY3lwgsv5Mc//vGJhu3Dhw/TokULwsPDWbRoETt37qzyGsOGDeOtt94CYN26daxZswZwhjaPiYmhcePG7Nu370R1F0BcXBxHjx79wbWGDh3KnDlzyMvL49ixY8yePZuhQ4f66tetVoOvhsovLGHB+r1ccW5rosJD/R2OMSaAjBs3jrFjx57oGXXLLbdw1VVXce6555KSkkK3bt2qPP+ee+5h4sSJdO/ene7du9O/f38AevfuTd++fenWrRtt27Y9aWjzSZMmMXLkyBNtF2X69evHhAkTGDBgAOA0cPft29eTKqfKSFWNM8EkJSVFq+u/XJl9Rwp44sON3Hp+ewZ0tIEDjQkEGzdupHv37v4Oo96p7O8qIitVNeUUp5zQ4EsWLeOjeHZcX3+HYYwxAc3aLIwxxlTLkoUxJiDVlyryQHGmf09LFsaYgBMVFUV2drYlDB9RVbKzs4mKiqr1NRp8m4UxJvAkJyeTnp5OVlaWv0OpN6KiokhOTq71+ZYsjDEBJzw8nI4dO/o7DFOOVUMZY4ypliULY4wx1bJkYYwxplr15g1uEckCqh6opWqJwAEfheO1YIoVgiveYIoVgiveYIoVgiveM4m1vao2r+6gepMszpSIrKjJK++BIJhiheCKN5hiheCKN5hiheCKty5itWooY4wx1bJkYYwxplqWLL43xd8BnIZgihWCK95gihWCK95gihWCK17PY7U2C2OMMdWykoUxxphqWbIwxhhTrQafLERkpIhsEpGtIvIrf8dTFRGZJiL7RWSdv2Opjoi0FZFFIrJBRNaLyAP+jqkqIhIlIt+IyGo33sf9HVN1RCRURFJF5AN/x1IdEdkhImtFJE1ETn9KyzokIk1EZJaIfCsiG0XkAn/HdCoicrb7Ny37HBGRBz25V0NusxCRUGAzcCmQDiwHxqnqBr8GdgoiMgzIBaarak9/x1MVEWkNtFbVVSISB6wErg7gv60AMaqaKyLhwFLgAVVd5ufQTklEHgJSgHhVvdLf8VRFRHYAKaoa8C+5ichrwBJVnSoiEUAjVT3k77iq4z7PMoCBqnomLyhXqqGXLAYAW1V1u6oWAjOAMX6O6ZRUdTFw0N9x1ISq7lHVVe7yUWAjkOTfqE5NHbnuarj7CdhvUiKSDFwBTPV3LPWJiDQGhgEvA6hqYTAkCtfFwDYvEgVYskgCdpdbTyeAH2jBSkQ6AH2Br/0bSdXcap00YD+wUFUDOd6ngV8Cpf4OpIYU+EREVorIJH8HU4WOQBbwilvFN1VEYvwdVA3dBLzt1cUberIwHhORWOA94EFVPeLveKqiqiWq2gdIBgaISEBW9YnIlcB+VV3p71hOwxBV7QeMAu51q1QDURjQD/iXqvYFjgEB3ZYJ4FaXjQbe9eoeDT1ZZABty60nu9uMD7h1/+8Bb6rqv/0dT0251Q6LgJH+juUUBgOj3XaAGcBFIvKGf0OqmqpmuD/3A7NxqoADUTqQXq5UOQsneQS6UcAqVd3n1Q0aerJYDpwlIh3dzHwTMM/PMdULboPxy8BGVf27v+Opjog0F5Em7nI0TqeHb/0bVeVU9deqmqyqHXD+zf5XVcf7OaxTEpEYt5MDbpXOZUBA9uhT1b3AbhE52910MRCQnTIqGIeHVVDQwKdVVdViEbkPWACEAtNUdb2fwzolEXkbGAEkikg68HtVfdm/UZ3SYOBWYK3bDgDwG1Wd78eYqtIaeM3tURICzFTVgO+SGiRaArOd7w+EAW+p6sf+DalKPwPedL9Abgcm+jmeKrkJ+FLgLk/v05C7zhpjjKmZhl4NZYwxpgYsWRhjjKmWJQtjjDHVsmRhjDGmWpYsjDHGVMuShTGnQURKKozy6bO3e0WkQzCMKGwapgb9noUxtZDvDgliTINiJQtjfMCdr+Gv7pwN34hIF3d7BxH5r4isEZFPRaSdu72liMx2589YLSKD3EuFishL7pwan7hvkxvjd5YsjDk90RWqoW4st++wqp4LPIczKizAs8BrqtoLeBP4h7v9H8DnqtobZ+yhspEDzgKeV9VzgEPAtR7/PsbUiL3BbcxpEJFcVY2tZPsO4CJV3e4OoLhXVRNE5ADOJFBF7vY9qpooIllAsqoeL3eNDjhDo5/lrj8ChKvqE97/ZsZUzUoWxviOnmL5dBwvt1yCtSuaAGHJwhjfubHcz6/c5S9xRoYFuAVY4i5/CtwDJyZdalxXQRpTG/atxZjTE11uFF2Aj1W1rPtsUxFZg1M6GOdu+xnOrGv/D2cGtrIRTB8ApojIT3BKEPcAezyP3phasjYLY3zAbbNIUdUD/o7FGC9YNZQxxphqWcnCGGNMtaxkYYwxplqWLIwxxlTLkoUxxphqWbIwxhhTLUsWxhhjqvX/AYvjMI80ZYT5AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00      1740\n",
      "           1       0.99      0.99      0.99       344\n",
      "\n",
      "   micro avg       1.00      1.00      1.00      2084\n",
      "   macro avg       0.99      0.99      0.99      2084\n",
      "weighted avg       1.00      1.00      1.00      2084\n",
      "\n",
      "Accuracy: 0.9961612284069098\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluate_model(model, train_sequences, train_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      0.99      1.00       192\n",
      "           1       0.97      1.00      0.99        39\n",
      "\n",
      "   micro avg       1.00      1.00      1.00       231\n",
      "   macro avg       0.99      1.00      0.99       231\n",
      "weighted avg       1.00      1.00      1.00       231\n",
      "\n",
      "Accuracy: 0.9956709956709957\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAF0VJREFUeJzt3X20XXV95/H3xwREBYMasJoEgjxUqU9oCjiupXREiowGl/WBjGhxKGmttDpaW2fVUUqLVh3t2AFHqVAUFQTHutIai08ooxVNHJACCo2IkMAMoBBEkMfv/LH3JcfLzb4n17vvOTd5v9a6i/3wO3t/94+b87l7/87ZO1WFJElb87BRFyBJGm8GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBoXklyRVJDpumzV5J7kiyYI7K6l2Sa5Mc3k6flOQTo65JOw6DQrOifSO7q32D/n9Jzkqy62zvp6p+o6q+Nk2b66pq16q6f7b3375J39se521J/iXJc2Z7P9I4MSg0m15SVbsCzwJWAG+f3CCN+f579+n2OBcDFwLnj7ieWZdk4ahr0PiY7/9gNYaqahPwBeCpAEm+luSUJN8E7gSelGRRkjOS3JhkU5K/GrxUlOSEJN9P8rMkVyZ5Vrt88BLMwUnWJ7m9PYv5QLt8eZKaeLNL8sQka5L8NMmGJCcM7OekJOcl+Xi7ryuSrBjyOO8DPgksSbLHwDZfnOTSgTOOpw+sW5bks0luTvKTJKe2y/dN8tV22S1JPplk95n0f5Kj2/3fnuSHSY6c3HcDx/6JSX12fJLrgK8m+UKSEydt+3tJXtZOPznJl9p+vSrJK2dSr8afQaFZl2QZcBRwycDi1wCrgd2AHwNnAfcB+wEHAUcAv9e+/hXAScBrgUcDK4GfTLGrDwIfrKpHA/sC522lpHOBjcATgZcD70ry7wfWr2zb7A6sAU4d8jh3bmv8CXBru+wg4Ezg94HHAR8B1iR5eBuE/9Qe/3JgSbtfgADvbmt8CrCs7YNtkuRg4OPAW9vjeR5w7TZs4vnt/n8bOAdYNbDtA4G9gc8neRTwJeBTwJ7AMcCH2jbazhgUmk2fS3Ib8A3g68C7BtadVVVXtH+FP5YmSN5UVT+vqpuAv6F5s4EmMN5bVeuqsaGqfjzF/u4F9kuyuKruqKqLJzdoQ+u5wJ9V1S+q6lLgozRv8BO+UVVr2zGNs4FnTHOcr2yP8y7gBODl7XFBE4YfqapvV9X9VfUx4G7gUOBgmiB4a3vcv6iqbwC0x/ilqrq7qm4GPkDzpr2tjgfObLf1QFVtqqofbMPrT2pruwv4B+CZSfZu170a+GxV3Q28GLi2qv6+qu6rqkuA/wW8YgY1a8wZFJpNL62q3atq76r6w/bNZsL1A9N7AzsBN7aXZ26j+ct7z3b9MuCHQ+zveOAA4AdJ1iV58RRtngj8tKp+NrDsxzR/zU/4vwPTdwK7JFmY5NXtoPUdSb4w0Oa8qtodeDxwOfDsScf2lonjao9tWVvHMuDHA6HyoCSPT3JuexnuduATNGMg22rYvtuaB/8/tX32ebYE+CqaS23QHOchk47z1cCv/Qr71phywEpzZfA2xdfT/JW9eKo3zXb9vtNusOrfgFXt4PjLgM8kedykZjcAj02y20BY7AVsGmL7n2TLG+NU629JshpYn+RTVXVjW/spVXXK5Pbtp6P2SrJwiuN+F00fPa2qfprkpQx5CWySrr77OfDIgfmp3tQn3076HOCdSS4CdqEZvJ/Yz9er6oUzqFHzjGcUmnPtG+oXgfcneXSSh7WDuROXWj4K/EmSZzcfksp+A5c/HpTk2CR7VNUDwG3t4gcm7et64F+AdyfZpR1YPp7mL/bZOJargAuAP20X/R3wB0kOaWt/VJL/kGQ34DvAjcBft8t3SfLc9nW7AXcAm5MsoRljmIkzgNcleUHbr0uSPLlddylwTJKd2gH7lw+xvbU0Zw8n03zaa6J//wk4IMlr2u3tlOQ3kzxlhnVrjBkUGpXXAjsDV9IMBH8GeAJAVZ0PnEIzUPoz4HM04xqTHQlckeQOmoHtYyZd7pqwimbw+Aaa6+7vrKovz+KxvA9YnWTPqlpPM25xantcG4DjANoxkJfQDOBfRzPA/qp2G39B87HizTSXez47k0Kq6jvA62jGfDbTjBVNhOx/pTnbuLXd36eG2N7dbS2HD7Zvz86OoLksdQPN5bv3AA+fSd0ab/HBRZKkLp5RSJI6GRSSpE4GhSSpk0EhSeo0775HsXjx4lq+fPmoy5CkeeW73/3uLVW1x/QtH2reBcXy5ctZv379qMuQpHklyVS3wRmKl54kSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUqfegiLJmUluSnL5VtYnyd+meYbxZWmfiSxJGi99nlGcRXMb6K15EbB/+7Ma+J891iJJmqHegqKqLgJ+2tHkaODj7TORLwZ2T/KE6bZ7zz2zVaEkaRijHKNYwi8/R3kjv/wc4wclWZ1kfZL1N95465wUJ0lqzIvB7Ko6vapWVNWKRYseM+pyJGmHMsqg2AQsG5hfyhAPvJckza1RBsUa4LXtp58OBTZX1Y0jrEeSNIXe7h6b5BzgMGBxko3AO4GdAKrqw8Ba4Ciah8/fSfNA+Gk98ABcfXUfFUuSptJbUFTVqmnWF/CGmWz7ootmVJIk7cB2e9RMXznvnkexcCEcdNCoq5Ck+WbBgpm+cl586kmSNDoGhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnq1GtQJDkyyVVJNiR52xTr90pyYZJLklyW5Kg+65EkbbvegiLJAuA04EXAgcCqJAdOavZ24LyqOgg4BvhQX/VIkmamzzOKg4ENVXVNVd0DnAscPalNAY9upxcBN/RYjyRpBhb2uO0lwPUD8xuBQya1OQn4YpI/Ah4FHD7VhpKsBlYD7LnnXrNeqCRp60Y9mL0KOKuqlgJHAWcneUhNVXV6Va2oqhWLFu0x50VK0o6sz6DYBCwbmF/aLht0PHAeQFV9C9gFWNxjTZKkbdRnUKwD9k+yT5KdaQar10xqcx3wAoAkT6EJipt7rEmStI16C4qqug84EbgA+D7Np5uuSHJykpVts7cAJyT5HnAOcFxVVV81SZK2XZ+D2VTVWmDtpGXvGJi+EnhunzVIkn41ox7MliSNOYNCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHVaOGzDJEuAvQdfU1UX9VGUJGl8DBUUSd4DvAq4Eri/XVxAZ1AkORL4ILAA+GhV/fUUbV4JnNRu73tV9R+HLV6S1L9hzyheCvx6Vd097IaTLABOA14IbATWJVlTVVcOtNkf+C/Ac6vq1iR7Dl+6JGkuDDtGcQ2w0zZu+2BgQ1VdU1X3AOcCR09qcwJwWlXdClBVN23jPiRJPRv2jOJO4NIkXwEePKuoqj/ueM0S4PqB+Y3AIZPaHACQ5Js0l6dOqqp/HrImSdIcGDYo1rQ/fex/f+AwYClwUZKnVdVtg42SrAZWA+y55149lCFJ2pqhgqKqPpZkZ9ozAOCqqrp3mpdtApYNzC9tlw3aCHy73daPklxNExzrJu3/dOB0gAMOWFHD1CxJmh1DjVEkOQz4N5rB6Q8BVyd53jQvWwfsn2SfNmSO4aFnJZ+jOZsgyWKaILpm2OIlSf0b9tLT+4EjquoqgCQHAOcAz97aC6rqviQnAhfQjD+cWVVXJDkZWF9Va9p1RySZ+NjtW6vqJzM/HEnSbBs2KHaaCAmAqro6ybSfgqqqtcDaScveMTBdwJvbH0nSGBo2KNYn+SjwiXb+1cD6fkqSJI2TYYPi9cAbgImPw/5vmrEKSdJ2bthPPd0NfKD9kSTtQDqDIsl5VfXKJP9Kcy+mX1JVT++tMknSWJjujOKN7X9f3HchkqTx1Pk9iqq6sZ28Bbi+qn4MPBx4BnBDz7VJksbAsDcFvAjYpX0mxReB1wBn9VWUJGl8DBsUqao7gZcBH6qqVwC/0V9ZkqRxMXRQJHkOzfcnPt8uW9BPSZKkcTJsULyJ5gFD/9DehuNJwIX9lSVJGhfDfo/i68DXB+avYcuX7yRJ27Hpvkfx36vqTUn+kam/R7Gyt8okSWNhujOKs9v//re+C5EkjafOoKiq77aT64G7quoBgCQLaL5PIUnazg07mP0V4JED848Avjz75UiSxs2wQbFLVd0xMdNOP7KjvSRpOzFsUPw8ybMmZpI8G7irn5IkSeNk2OdRvAk4P8kNQIBfA17VW1WSpLEx7Pco1iV5MvDr7aKrqure/sqSJI2LoS49JXkk8GfAG6vqcmB5Em89Lkk7gGHHKP4euAd4Tju/CfirXiqSJI2VYYNi36p6L3AvQHsn2fRWlSRpbAwbFPckeQTtbTyS7Avc3VtVkqSxMeynnt4J/DOwLMkngecCx/VVlCRpfEwbFEkC/IDmoUWH0lxyemNV3dJzbZKkMTBtUFRVJVlbVU9jy0OLJEk7iGHHKP5Pkt/stRJJ0lgadoziEODYJNcCP6e5/FRV9fS+CpMkjYdhg+K3e61CkjS2pnvC3S7AHwD7Af8KnFFV981FYZKk8TDdGMXHgBU0IfEi4P29VyRJGivTXXo6sP20E0nOAL7Tf0mSpHEy3RnFg3eI9ZKTJO2YpguKZyS5vf35GfD0iekkt0+38SRHJrkqyYYkb+to9ztJKsmKbT0ASVK/Oi89VdWCmW44yQLgNOCFwEZgXZI1VXXlpHa7AW8Evj3TfUmS+jPsF+5m4mBgQ1VdU1X3AOcCR0/R7i+B9wC/6LEWSdIM9RkUS4DrB+Y3tsse1D6He1lVdd4aJMnqJOuTrN+8+ebZr1SStFV9BkWnJA8DPgC8Zbq2VXV6Va2oqhWLFu3Rf3GSpAf1GRSbgGUD80vbZRN2A54KfK29NcihwBoHtCVpvPQZFOuA/ZPsk2Rn4BhgzcTKqtpcVYuranlVLQcuBlZW1foea5IkbaPegqL93sWJwAXA94HzquqKJCcnWdnXfiVJs2vYmwLOSFWtBdZOWvaOrbQ9rM9aJEkzM7LBbEnS/GBQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqZNBIUnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE4GhSSpk0EhSepkUEiSOhkUkqROBoUkqVOvQZHkyCRXJdmQ5G1TrH9zkiuTXJbkK0n27rMeSdK26y0okiwATgNeBBwIrEpy4KRmlwArqurpwGeA9/ZVjyRpZvo8ozgY2FBV11TVPcC5wNGDDarqwqq6s529GFjaYz2SpBnoMyiWANcPzG9sl23N8cAXplqRZHWS9UnWb9588yyWKEmazlgMZic5FlgBvG+q9VV1elWtqKoVixbtMbfFSdIObmGP294ELBuYX9ou+yVJDgf+HHh+Vd3dYz2SpBno84xiHbB/kn2S7AwcA6wZbJDkIOAjwMqquqnHWiRJM9RbUFTVfcCJwAXA94HzquqKJCcnWdk2ex+wK3B+kkuTrNnK5iRJI9LnpSeqai2wdtKydwxMH97n/iVJv7qxGMyWJI0vg0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUieDQpLUyaCQJHUyKCRJnQwKSVIng0KS1MmgkCR1MigkSZ0MCklSJ4NCktTJoJAkdTIoJEmdDApJUqdegyLJkUmuSrIhydumWP/wJJ9u1387yfI+65EkbbvegiLJAuA04EXAgcCqJAdOanY8cGtV7Qf8DfCevuqRJM1Mn2cUBwMbquqaqroHOBc4elKbo4GPtdOfAV6QJD3WJEnaRgt73PYS4PqB+Y3AIVtrU1X3JdkMPA64ZbBRktXA6nbu3hUrHnNtLxXPO3cvgodvHnUV48G+2MK+2MK+2OL2pTN9ZZ9BMWuq6nTgdIAk66tuXTHiksZC0xd32hfYF4Psiy3siy2SrJ/pa/u89LQJWDYwv7RdNmWbJAuBRcBPeqxJkrSN+gyKdcD+SfZJsjNwDLBmUps1wO+20y8HvlpV1WNNkqRt1Nulp3bM4UTgAmABcGZVXZHkZGB9Va0BzgDOTrIB+ClNmEzn9L5qnofsiy3siy3siy3siy1m3BfxD3hJUhe/mS1J6mRQSJI6jW1QePuPLYboizcnuTLJZUm+kmTvUdQ5F6bri4F2v5Okkmy3H40cpi+SvLL93bgiyafmusa5MsS/kb2SXJjkkvbfyVGjqLNvSc5MclOSy7eyPkn+tu2ny5I8a6gNV9XY/dAMfv8QeBKwM/A94MBJbf4Q+HA7fQzw6VHXPcK++C3gke3063fkvmjb7QZcBFwMrBh13SP8vdgfuAR4TDu/56jrHmFfnA68vp0+ELh21HX31BfPA54FXL6V9UcBXwACHAp8e5jtjusZhbf/2GLavqiqC6vqznb2YprvrGyPhvm9APhLmvuG/WIui5tjw/TFCcBpVXUrQFXdNMc1zpVh+qKAR7fTi4Ab5rC+OVNVF9F8gnRrjgY+Xo2Lgd2TPGG67Y5rUEx1+48lW2tTVfcBE7f/2N4M0xeDjqf5i2F7NG1ftKfSy6rq83NZ2AgM83txAHBAkm8muTjJkXNW3dwapi9OAo5NshFYC/zR3JQ2drb1/QSYJ7fw0HCSHAusAJ4/6lpGIcnDgA8Ax424lHGxkOby02E0Z5kXJXlaVd020qpGYxVwVlW9P8lzaL6/9dSqemDUhc0H43pG4e0/thimL0hyOPDnwMqqunuOaptr0/XFbsBTga8luZbmGuya7XRAe5jfi43Amqq6t6p+BFxNExzbm2H64njgPICq+hawC7B4TqobL0O9n0w2rkHh7T+2mLYvkhwEfIQmJLbX69AwTV9U1eaqWlxVy6tqOc14zcqqmvHN0MbYMP9GPkdzNkGSxTSXoq6ZyyLnyDB9cR3wAoAkT6EJipvntMrxsAZ4bfvpp0OBzVV143QvGstLT9Xf7T/mnSH74n3ArsD57Xj+dVW1cmRF92TIvtghDNkXFwBHJLkSuB94a1Vtd2fdQ/bFW4C/S/KfaQa2j9se/7BMcg7NHweL2/GYdwI7AVTVh2nGZ44CNgB3Aq8barvbYV9JkmbRuF56kiSNCYNCktTJoJAkdTIoJEmdDApJUieDQpokyf1JLk1yeZJ/TLL7LG//uCSnttMnJfmT2dy+NNsMCumh7qqqZ1bVU2m+o/OGURckjZJBIXX7FgM3TUvy1iTr2nv5/8XA8te2y76X5Ox22UvaZ6VckuTLSR4/gvqlX9lYfjNbGgdJFtDc9uGMdv4ImnslHUxzP/81SZ5Hc4+xtwP/rqpuSfLYdhPfAA6tqkrye8Cf0nxDWJpXDArpoR6R5FKaM4nvA19qlx/R/lzSzu9KExzPAM6vqlsAqmrieQBLgU+39/vfGfjR3JQvzS4vPUkPdVdVPRPYm+bMYWKMIsC72/GLZ1bVflV1Rsd2/gdwalU9Dfh9mhvRSfOOQSFtRfvUwD8G3tLeyv4C4D8l2RUgyZIkewJfBV6R5HHt8olLT4vYcgvn30Wap7z0JHWoqkuSXAasqqqz21tUf6u9S+8dwLHtnUpPAb6e5H6aS1PH0TxV7fwkt9KEyT6jOAbpV+XdYyVJnbz0JEnqZFBIkjoZFJKkTgaFJKmTQSFJ6mRQSJI6GRSSpE7/HyaI9O89DGkBAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluate_model(model, valid_sequences, valid_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.99      0.99      0.99       480\n",
      "           1       0.96      0.95      0.95        98\n",
      "\n",
      "   micro avg       0.98      0.98      0.98       578\n",
      "   macro avg       0.97      0.97      0.97       578\n",
      "weighted avg       0.98      0.98      0.98       578\n",
      "\n",
      "Accuracy: 0.9844290657439446\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluate_model(model, test_sequences, test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-22-48455ab65ec0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mclean_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined"
     ]
    }
   ],
   "source": [
    "clean_model(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bidirectional LSTMs with self attention and ELMO on Pretrained (Glove) Embeddings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ELMO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Logging before flag parsing goes to stderr.\n",
      "W0506 22:49:04.318979 139735243384576 __init__.py:56] Some hub symbols are not available because TensorFlow version is less than 1.14\n"
     ]
    }
   ],
   "source": [
    "import tensorflow_hub as hub\n",
    "from keras.layers import Layer\n",
    "\n",
    "class ELMo(Layer):\n",
    "    def __init__(self, elmo_representation='elmo', trainable=True, **kwargs):\n",
    "        self.module_output = elmo_representation\n",
    "        self.trainable = trainable\n",
    "\n",
    "        self.elmo = None\n",
    "        super(ELMo, self).__init__(**kwargs)\n",
    "\n",
    "    def build(self, input_shape):\n",
    "        # SetUp tensorflow Hub module\n",
    "        self.elmo = hub.Module('https://tfhub.dev/google/elmo/2',\n",
    "                               trainable=self.trainable, name=\"{}_module\".format(self.name))\n",
    "        # Assign module's trainable weights to model\n",
    "        self.trainable_weights += K.tf.trainable_variables(scope=\"^{}_module/.*\".format(self.name))\n",
    "        \n",
    "        super(ELMo, self).build(input_shape)\n",
    "\n",
    "    def call(self, x, mask=None):\n",
    "        result = self.elmo(K.squeeze(K.cast(x, tf.string), axis=1),\n",
    "                           as_dict=True,\n",
    "                           signature='default',\n",
    "                           )[self.module_output]\n",
    "        return result\n",
    "\n",
    "    def compute_mask(self, inputs, mask=None):\n",
    "        return None\n",
    "\n",
    "    def compute_output_shape(self, input_shape):\n",
    "        return input_shape[0], input_shape[0], 1024"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I0506 22:49:05.442323 139735243384576 tf_logging.py:115] Saver not created because there are no variables in the graph to restore\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "______________________________________________________________________________________________________________\n",
      "Layer (type)                        Output Shape            Param #      Connected to                         \n",
      "==============================================================================================================\n",
      "input_1 (InputLayer)                (None, None)            0                                                 \n",
      "______________________________________________________________________________________________________________\n",
      "input_2 (InputLayer)                (None, 1)               0                                                 \n",
      "______________________________________________________________________________________________________________\n",
      "embedding_1 (Embedding)             (None, None, 100)       4850800      input_1[0][0]                        \n",
      "______________________________________________________________________________________________________________\n",
      "el_mo_1 (ELMo)                      (None, None, 1024)      4            input_2[0][0]                        \n",
      "______________________________________________________________________________________________________________\n",
      "concatenate_1 (Concatenate)         (None, None, 1124)      0            embedding_1[0][0]                    \n",
      "                                                                         el_mo_1[0][0]                        \n",
      "______________________________________________________________________________________________________________\n",
      "dropout_1 (Dropout)                 (None, None, 1124)      0            concatenate_1[0][0]                  \n",
      "______________________________________________________________________________________________________________\n",
      "bidirectional_1 (Bidirectional)     (None, None, 200)       980000       dropout_1[0][0]                      \n",
      "______________________________________________________________________________________________________________\n",
      "bidirectional_2 (Bidirectional)     (None, None, 200)       240800       bidirectional_1[0][0]                \n",
      "______________________________________________________________________________________________________________\n",
      "deep_attention_1 (DeepAttention)    (None, 200)             40400        bidirectional_2[0][0]                \n",
      "______________________________________________________________________________________________________________\n",
      "dense_1 (Dense)                     (None, 1)               201          deep_attention_1[0][0]               \n",
      "==============================================================================================================\n",
      "Total params: 6,112,205\n",
      "Trainable params: 1,261,405\n",
      "Non-trainable params: 4,850,800\n",
      "______________________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "with tf.device('/cpu:0'):\n",
    "\n",
    "\n",
    "    inputs =  Input(shape=(None, ), dtype='int32')\n",
    "    elmo_inputs = Input(shape=(1,), dtype='string')\n",
    "    embeddings = Embedding(\n",
    "        input_dim=embedding_weights.shape[0],\n",
    "        output_dim=embedding_weights.shape[1],\n",
    "        #input_length=input_length,\n",
    "        embeddings_initializer=\"zeros\",\n",
    "        weights=[embedding_weights],\n",
    "        trainable=False\n",
    "    )(inputs)\n",
    "\n",
    "    # ELMo embeddings as weighted average across layers\n",
    "    elmo_embeddings = ELMo()(elmo_inputs)\n",
    "    # Concat Glove + ELMo embeddings\n",
    "    concatenated_embeddings = concatenate([embeddings, elmo_embeddings], axis=-1)\n",
    "\n",
    "    dropped_embeddings = Dropout(0.0)(concatenated_embeddings)\n",
    "    lstms_1 = Bidirectional(LSTM(100, return_sequences=True))(dropped_embeddings)\n",
    "    lstms_2 = Bidirectional(LSTM(100, return_sequences=True))(lstms_1)\n",
    "    attention =  DeepAttention()(lstms_2)\n",
    "    outputs = Dense(1, activation='sigmoid')(attention)\n",
    "\n",
    "    # Wrap model\n",
    "    model = Model(inputs=[inputs, elmo_inputs], outputs=outputs)\n",
    "    model.summary(110)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "from keras.utils import plot_model\n",
    "plot_model(model, to_file='model.png')\n",
    "\n",
    "from IPython.display import Image \n",
    "Image('model.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.compile(optimizer=\"adam\", loss=\"binary_crossentropy\", metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 2084 samples, validate on 231 samples\n",
      "Epoch 1/20\n",
      "2084/2084 [==============================] - 506s 243ms/step - loss: 0.3429 - acc: 0.7970 - val_loss: 0.0539 - val_acc: 0.9827\n",
      "Epoch 2/20\n",
      "2084/2084 [==============================] - 485s 233ms/step - loss: 0.0525 - acc: 0.9822 - val_loss: 0.0367 - val_acc: 0.9913\n",
      "Epoch 3/20\n",
      "2084/2084 [==============================] - 539s 259ms/step - loss: 0.0290 - acc: 0.9914 - val_loss: 0.0452 - val_acc: 0.9870\n",
      "Epoch 4/20\n",
      "2084/2084 [==============================] - 538s 258ms/step - loss: 0.0213 - acc: 0.9914 - val_loss: 0.0230 - val_acc: 0.9957\n",
      "Epoch 5/20\n",
      "2084/2084 [==============================] - 526s 252ms/step - loss: 0.0100 - acc: 0.9962 - val_loss: 0.0334 - val_acc: 0.9870\n",
      "Epoch 6/20\n",
      "2084/2084 [==============================] - 543s 261ms/step - loss: 0.0064 - acc: 0.9976 - val_loss: 0.0354 - val_acc: 0.9870\n",
      "Epoch 7/20\n",
      "2084/2084 [==============================] - 539s 259ms/step - loss: 0.0071 - acc: 0.9976 - val_loss: 0.0201 - val_acc: 0.9957\n",
      "Epoch 8/20\n",
      "2084/2084 [==============================] - 540s 259ms/step - loss: 0.0109 - acc: 0.9966 - val_loss: 0.0247 - val_acc: 0.9913\n",
      "Epoch 9/20\n",
      "2084/2084 [==============================] - 538s 258ms/step - loss: 0.0089 - acc: 0.9976 - val_loss: 0.0425 - val_acc: 0.9827\n",
      "Epoch 10/20\n",
      "2084/2084 [==============================] - 518s 248ms/step - loss: 0.0076 - acc: 0.9986 - val_loss: 0.0252 - val_acc: 0.9957\n",
      "Restoring model weights from the end of the best epoch\n",
      "Epoch 00010: early stopping\n"
     ]
    }
   ],
   "source": [
    "history = model.fit(\n",
    "    [train_sequences, array(tokenizer.sequences_to_texts(train_sequences))], train_y,\n",
    "    validation_data=([valid_sequences, array(tokenizer.sequences_to_texts(valid_sequences))], valid_y),\n",
    "    batch_size=256,\n",
    "    epochs=20,\n",
    "    callbacks=[EarlyStopping(patience=3, restore_best_weights=True, verbose=1)],\n",
    "    verbose=1\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "window.mpl = {};\n",
       "\n",
       "\n",
       "mpl.get_websocket_type = function() {\n",
       "    if (typeof(WebSocket) !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof(MozWebSocket) !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert('Your browser does not have WebSocket support.' +\n",
       "              'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "              'Firefox 4 and 5 are also supported but you ' +\n",
       "              'have to enable WebSockets in about:config.');\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = (this.ws.binaryType != undefined);\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById(\"mpl-warnings\");\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent = (\n",
       "                \"This browser does not support binary websocket messages. \" +\n",
       "                    \"Performance may be slow.\");\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = $('<div/>');\n",
       "    this._root_extra_style(this.root)\n",
       "    this.root.attr('style', 'display: inline-block');\n",
       "\n",
       "    $(parent_element).append(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen =  function () {\n",
       "            fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n",
       "            fig.send_message(\"send_image_mode\", {});\n",
       "            if (mpl.ratio != 1) {\n",
       "                fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n",
       "            }\n",
       "            fig.send_message(\"refresh\", {});\n",
       "        }\n",
       "\n",
       "    this.imageObj.onload = function() {\n",
       "            if (fig.image_mode == 'full') {\n",
       "                // Full images could contain transparency (where diff images\n",
       "                // almost always do), so we need to clear the canvas so that\n",
       "                // there is no ghosting.\n",
       "                fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "            }\n",
       "            fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "        };\n",
       "\n",
       "    this.imageObj.onunload = function() {\n",
       "        fig.ws.close();\n",
       "    }\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_header = function() {\n",
       "    var titlebar = $(\n",
       "        '<div class=\"ui-dialog-titlebar ui-widget-header ui-corner-all ' +\n",
       "        'ui-helper-clearfix\"/>');\n",
       "    var titletext = $(\n",
       "        '<div class=\"ui-dialog-title\" style=\"width: 100%; ' +\n",
       "        'text-align: center; padding: 3px;\"/>');\n",
       "    titlebar.append(titletext)\n",
       "    this.root.append(titlebar);\n",
       "    this.header = titletext[0];\n",
       "}\n",
       "\n",
       "\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = $('<div/>');\n",
       "\n",
       "    canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n",
       "\n",
       "    function canvas_keyboard_event(event) {\n",
       "        return fig.key_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    canvas_div.keydown('key_press', canvas_keyboard_event);\n",
       "    canvas_div.keyup('key_release', canvas_keyboard_event);\n",
       "    this.canvas_div = canvas_div\n",
       "    this._canvas_extra_style(canvas_div)\n",
       "    this.root.append(canvas_div);\n",
       "\n",
       "    var canvas = $('<canvas/>');\n",
       "    canvas.addClass('mpl-canvas');\n",
       "    canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n",
       "\n",
       "    this.canvas = canvas[0];\n",
       "    this.context = canvas[0].getContext(\"2d\");\n",
       "\n",
       "    var backingStore = this.context.backingStorePixelRatio ||\n",
       "\tthis.context.webkitBackingStorePixelRatio ||\n",
       "\tthis.context.mozBackingStorePixelRatio ||\n",
       "\tthis.context.msBackingStorePixelRatio ||\n",
       "\tthis.context.oBackingStorePixelRatio ||\n",
       "\tthis.context.backingStorePixelRatio || 1;\n",
       "\n",
       "    mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband = $('<canvas/>');\n",
       "    rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n",
       "\n",
       "    var pass_mouse_events = true;\n",
       "\n",
       "    canvas_div.resizable({\n",
       "        start: function(event, ui) {\n",
       "            pass_mouse_events = false;\n",
       "        },\n",
       "        resize: function(event, ui) {\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "        stop: function(event, ui) {\n",
       "            pass_mouse_events = true;\n",
       "            fig.request_resize(ui.size.width, ui.size.height);\n",
       "        },\n",
       "    });\n",
       "\n",
       "    function mouse_event_fn(event) {\n",
       "        if (pass_mouse_events)\n",
       "            return fig.mouse_event(event, event['data']);\n",
       "    }\n",
       "\n",
       "    rubberband.mousedown('button_press', mouse_event_fn);\n",
       "    rubberband.mouseup('button_release', mouse_event_fn);\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband.mousemove('motion_notify', mouse_event_fn);\n",
       "\n",
       "    rubberband.mouseenter('figure_enter', mouse_event_fn);\n",
       "    rubberband.mouseleave('figure_leave', mouse_event_fn);\n",
       "\n",
       "    canvas_div.on(\"wheel\", function (event) {\n",
       "        event = event.originalEvent;\n",
       "        event['data'] = 'scroll'\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        mouse_event_fn(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.append(canvas);\n",
       "    canvas_div.append(rubberband);\n",
       "\n",
       "    this.rubberband = rubberband;\n",
       "    this.rubberband_canvas = rubberband[0];\n",
       "    this.rubberband_context = rubberband[0].getContext(\"2d\");\n",
       "    this.rubberband_context.strokeStyle = \"#000000\";\n",
       "\n",
       "    this._resize_canvas = function(width, height) {\n",
       "        // Keep the size of the canvas, canvas container, and rubber band\n",
       "        // canvas in synch.\n",
       "        canvas_div.css('width', width)\n",
       "        canvas_div.css('height', height)\n",
       "\n",
       "        canvas.attr('width', width * mpl.ratio);\n",
       "        canvas.attr('height', height * mpl.ratio);\n",
       "        canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n",
       "\n",
       "        rubberband.attr('width', width);\n",
       "        rubberband.attr('height', height);\n",
       "    }\n",
       "\n",
       "    // Set the figure to an initial 600x600px, this will subsequently be updated\n",
       "    // upon first draw.\n",
       "    this._resize_canvas(600, 600);\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus () {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            // put a spacer in here.\n",
       "            continue;\n",
       "        }\n",
       "        var button = $('<button/>');\n",
       "        button.addClass('ui-button ui-widget ui-state-default ui-corner-all ' +\n",
       "                        'ui-button-icon-only');\n",
       "        button.attr('role', 'button');\n",
       "        button.attr('aria-disabled', 'false');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "\n",
       "        var icon_img = $('<span/>');\n",
       "        icon_img.addClass('ui-button-icon-primary ui-icon');\n",
       "        icon_img.addClass(image);\n",
       "        icon_img.addClass('ui-corner-all');\n",
       "\n",
       "        var tooltip_span = $('<span/>');\n",
       "        tooltip_span.addClass('ui-button-text');\n",
       "        tooltip_span.html(tooltip);\n",
       "\n",
       "        button.append(icon_img);\n",
       "        button.append(tooltip_span);\n",
       "\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    var fmt_picker_span = $('<span/>');\n",
       "\n",
       "    var fmt_picker = $('<select/>');\n",
       "    fmt_picker.addClass('mpl-toolbar-option ui-widget ui-widget-content');\n",
       "    fmt_picker_span.append(fmt_picker);\n",
       "    nav_element.append(fmt_picker_span);\n",
       "    this.format_dropdown = fmt_picker[0];\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = $(\n",
       "            '<option/>', {selected: fmt === mpl.default_extension}).html(fmt);\n",
       "        fmt_picker.append(option)\n",
       "    }\n",
       "\n",
       "    // Add hover states to the ui-buttons\n",
       "    $( \".ui-button\" ).hover(\n",
       "        function() { $(this).addClass(\"ui-state-hover\");},\n",
       "        function() { $(this).removeClass(\"ui-state-hover\");}\n",
       "    );\n",
       "\n",
       "    var status_bar = $('<span class=\"mpl-message\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.request_resize = function(x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', {'width': x_pixels, 'height': y_pixels});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_message = function(type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function() {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({type: \"draw\", figure_id: this.id}));\n",
       "    }\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function(fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] != fig.canvas.width || size[1] != fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1]);\n",
       "        fig.send_message(\"refresh\", {});\n",
       "    };\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function(fig, msg) {\n",
       "    var x0 = msg['x0'] / mpl.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / mpl.ratio;\n",
       "    var x1 = msg['x1'] / mpl.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / mpl.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0, 0, fig.canvas.width, fig.canvas.height);\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function(fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function(fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch(cursor)\n",
       "    {\n",
       "    case 0:\n",
       "        cursor = 'pointer';\n",
       "        break;\n",
       "    case 1:\n",
       "        cursor = 'default';\n",
       "        break;\n",
       "    case 2:\n",
       "        cursor = 'crosshair';\n",
       "        break;\n",
       "    case 3:\n",
       "        cursor = 'move';\n",
       "        break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_message = function(fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function(fig, msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function(fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message(\"ack\", {});\n",
       "}\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function(fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = \"image/png\";\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src);\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data);\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "        else if (typeof evt.data === 'string' && evt.data.slice(0, 21) == \"data:image/png;base64\") {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig[\"handle_\" + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\"No handler for the '\" + msg_type + \"' message type: \", msg);\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\"Exception inside the 'handler_\" + msg_type + \"' callback:\", e, e.stack, msg);\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "}\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function(e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e)\n",
       "        e = window.event;\n",
       "    if (e.target)\n",
       "        targ = e.target;\n",
       "    else if (e.srcElement)\n",
       "        targ = e.srcElement;\n",
       "    if (targ.nodeType == 3) // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "\n",
       "    // jQuery normalizes the pageX and pageY\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    // offset() returns the position of the element relative to the document\n",
       "    var x = e.pageX - $(targ).offset().left;\n",
       "    var y = e.pageY - $(targ).offset().top;\n",
       "\n",
       "    return {\"x\": x, \"y\": y};\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys (original) {\n",
       "  return Object.keys(original).reduce(function (obj, key) {\n",
       "    if (typeof original[key] !== 'object')\n",
       "        obj[key] = original[key]\n",
       "    return obj;\n",
       "  }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function(event, name) {\n",
       "    var canvas_pos = mpl.findpos(event)\n",
       "\n",
       "    if (name === 'button_press')\n",
       "    {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * mpl.ratio;\n",
       "    var y = canvas_pos.y * mpl.ratio;\n",
       "\n",
       "    this.send_message(name, {x: x, y: y, button: event.button,\n",
       "                             step: event.step,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.key_event = function(event, name) {\n",
       "\n",
       "    // Prevent repeat events\n",
       "    if (name == 'key_press')\n",
       "    {\n",
       "        if (event.which === this._key)\n",
       "            return;\n",
       "        else\n",
       "            this._key = event.which;\n",
       "    }\n",
       "    if (name == 'key_release')\n",
       "        this._key = null;\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which != 17)\n",
       "        value += \"ctrl+\";\n",
       "    if (event.altKey && event.which != 18)\n",
       "        value += \"alt+\";\n",
       "    if (event.shiftKey && event.which != 16)\n",
       "        value += \"shift+\";\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, {key: value,\n",
       "                             guiEvent: simpleKeys(event)});\n",
       "    return false;\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function(name) {\n",
       "    if (name == 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message(\"toolbar_button\", {name: name});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function(tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Pan axes with left mouse, zoom with right\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";var comm_websocket_adapter = function(comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function() {\n",
       "        comm.close()\n",
       "    };\n",
       "    ws.send = function(m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function(msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data'])\n",
       "    });\n",
       "    return ws;\n",
       "}\n",
       "\n",
       "mpl.mpl_figure_comm = function(comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = $(\"#\" + id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm)\n",
       "\n",
       "    function ondownload(figure, format) {\n",
       "        window.open(figure.imageObj.src);\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy,\n",
       "                           ondownload,\n",
       "                           element.get(0));\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element.get(0);\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error(\"Failed to find cell for figure\", id, fig);\n",
       "        return;\n",
       "    }\n",
       "\n",
       "    var output_index = fig.cell_info[2]\n",
       "    var cell = fig.cell_info[0];\n",
       "\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function(fig, msg) {\n",
       "    var width = fig.canvas.width/mpl.ratio\n",
       "    fig.root.unbind('remove')\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable()\n",
       "    $(fig.parent_element).html('<img src=\"' + dataURL + '\" width=\"' + width + '\">');\n",
       "    fig.close_ws(fig, msg);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.close_ws = function(fig, msg){\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function(remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width/mpl.ratio\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] = '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function() {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message(\"ack\", {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () { fig.push_to_output() }, 1000);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function() {\n",
       "    var fig = this;\n",
       "\n",
       "    var nav_element = $('<div/>')\n",
       "    nav_element.attr('style', 'width: 100%');\n",
       "    this.root.append(nav_element);\n",
       "\n",
       "    // Define a callback function for later on.\n",
       "    function toolbar_event(event) {\n",
       "        return fig.toolbar_button_onclick(event['data']);\n",
       "    }\n",
       "    function toolbar_mouse_event(event) {\n",
       "        return fig.toolbar_button_onmouseover(event['data']);\n",
       "    }\n",
       "\n",
       "    for(var toolbar_ind in mpl.toolbar_items){\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) { continue; };\n",
       "\n",
       "        var button = $('<button class=\"btn btn-default\" href=\"#\" title=\"' + name + '\"><i class=\"fa ' + image + ' fa-lg\"></i></button>');\n",
       "        button.click(method_name, toolbar_event);\n",
       "        button.mouseover(tooltip, toolbar_mouse_event);\n",
       "        nav_element.append(button);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = $('<span class=\"mpl-message\" style=\"text-align:right; float: right;\"/>');\n",
       "    nav_element.append(status_bar);\n",
       "    this.message = status_bar[0];\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = $('<div class=\"btn-group inline pull-right\"></div>');\n",
       "    var button = $('<button class=\"btn btn-mini btn-primary\" href=\"#\" title=\"Stop Interaction\"><i class=\"fa fa-power-off icon-remove icon-large\"></i></button>');\n",
       "    button.click(function (evt) { fig.handle_close(fig, {}); } );\n",
       "    button.mouseover('Stop Interaction', toolbar_mouse_event);\n",
       "    buttongrp.append(button);\n",
       "    var titlebar = this.root.find($('.ui-dialog-titlebar'));\n",
       "    titlebar.prepend(buttongrp);\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function(el){\n",
       "    var fig = this\n",
       "    el.on(\"remove\", function(){\n",
       "\tfig.close_ws(fig, {});\n",
       "    });\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function(el){\n",
       "    // this is important to make the div 'focusable\n",
       "    el.attr('tabindex', 0)\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    }\n",
       "    else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "\n",
       "}\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function(event, name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager)\n",
       "        manager = IPython.keyboard_manager;\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which == 13) {\n",
       "        this.canvas_div.blur();\n",
       "        event.shiftKey = false;\n",
       "        // Send a \"J\" for go to next cell\n",
       "        event.which = 74;\n",
       "        event.keyCode = 74;\n",
       "        manager.command_mode();\n",
       "        manager.handle_keydown(event);\n",
       "    }\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.handle_save = function(fig, msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "}\n",
       "\n",
       "\n",
       "mpl.find_output_cell = function(html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i=0; i<ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code'){\n",
       "            for (var j=0; j<cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] == html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "}\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel != null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"640\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_history(history)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evaluate_model(model, [valid_sequences, array(tokenizer.sequences_to_texts(valid_sequences))], valid_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.98      1.00      0.99       480\n",
      "           1       0.98      0.92      0.95        98\n",
      "\n",
      "   micro avg       0.98      0.98      0.98       578\n",
      "   macro avg       0.98      0.96      0.97       578\n",
      "weighted avg       0.98      0.98      0.98       578\n",
      "\n",
      "Accuracy: 0.9826989619377162\n"
     ]
    }
   ],
   "source": [
    "evaluate_model(model, [test_sequences, array(tokenizer.sequences_to_texts(test_sequences))], test_y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'model' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-48455ab65ec0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mclean_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined"
     ]
    }
   ],
   "source": [
    "clean_model(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "env",
   "language": "python",
   "name": "env"
  },
  "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}