02_word-vectors.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# better display of review text in dataframes\n",
    "pd.set_option('display.max_colwidth', None) \n",
    "\n",
    "# Seaborn options\n",
    "sns.set(style=\"whitegrid\", font_scale=1.4)\n",
    "\n",
    "# Auto reload modules\n",
    "%load_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "assert tf.__version__ >= \"2.0\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This cell is only here as a bug fix when running RNN on my GPU\n",
    "physical_devices = tf.config.list_physical_devices('GPU')\n",
    "tf.config.experimental.set_memory_growth(physical_devices[0], enable=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Prepare data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "PICKLE_PATH = \"allocine_dataset/data/allocine_dataset.pickle\"\n",
    "\n",
    "with open(PICKLE_PATH, 'rb') as reader:\n",
    "    data = pickle.load(reader)\n",
    "\n",
    "# Reviews need to be tokenized\n",
    "train_reviews = np.array(data[\"train_set\"]['review'])\n",
    "val_reviews = np.array(data[\"val_set\"]['review'])\n",
    "test_reviews = np.array(data[\"test_set\"]['review'])\n",
    "\n",
    "# Used to train fit tokenizer\n",
    "#all_reviews = np.concatenate((train_reviews, val_reviews, test_reviews), axis=0)\n",
    "\n",
    "train_labels = data[\"train_set\"]['polarity']\n",
    "val_labels = data[\"val_set\"]['polarity']\n",
    "test_labels = data[\"test_set\"]['polarity']\n",
    "class_names = data['class_names']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocess dataset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tokenize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We train the tokenizer on the reviews of the train set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 186308 unique tokens.\n"
     ]
    }
   ],
   "source": [
    "MAX_NB_WORDS = 20000\n",
    "\n",
    "tokenizer = tf.keras.preprocessing.text.Tokenizer(\n",
    "    num_words=MAX_NB_WORDS,\n",
    "    oov_token=\"<unk>\",\n",
    ")\n",
    "tokenizer.fit_on_texts(train_reviews)\n",
    "\n",
    "word_index = tokenizer.word_index\n",
    "print(\"Found {} unique tokens.\".format(len(word_index)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_reviews_tokenized = tokenizer.texts_to_sequences(train_reviews)\n",
    "val_reviews_tokenized = tokenizer.texts_to_sequences(val_reviews)\n",
    "test_reviews_tokenized = tokenizer.texts_to_sequences(test_reviews)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[45, 68, 4664, 17, 77, 15081, 7, 80, 9, 8746, 2505, 249, 439, 17, 1181]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_review = train_reviews_tokenized[0]\n",
    "some_review[:15]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"si vous cherchez du cinéma abrutissant à tous les étages n'ayant aucune peur du cliché\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "index_to_word = dict((i, w) for w, i in tokenizer.word_index.items())\n",
    "\" \".join([index_to_word[i] for i in some_review[:15]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average length: 91.5\n",
      "Max length: 389\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "reviews_len = [len(s) for s in train_reviews_tokenized+val_reviews_tokenized+test_reviews_tokenized]\n",
    "print(\"Average length: {:.1f}\".format(np.mean(reviews_len)))\n",
    "print(\"Max length: {}\".format(max(reviews_len)))\n",
    "\n",
    "plt.figure(figsize=(10,5))\n",
    "ax = sns.distplot(reviews_len, bins=150, kde=False, hist_kws=dict(alpha=0.8))\n",
    "ax.set(xlabel='Number of words')\n",
    "\n",
    "# Finalize the plot\n",
    "sns.despine(bottom=True)\n",
    "plt.tight_layout(h_pad=2)\n",
    "\n",
    "# Saving plot\n",
    "fig = ax.get_figure()\n",
    "fig.savefig('img/word-vectors/number_of_words.png', dpi=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-f6b1d3c0054b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# This assert is likely to fail\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0;32massert\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mreviews_len\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "# This assert is likely to fail\n",
    "assert(reviews_len.count(0) == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Remove empty sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Important not to have empty tensors: https://github.com/tensorflow/tensorflow/issues/33148"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_empty_sequences(reviews, labels):\n",
    "    reviews_not_empty = []\n",
    "    labels_not_empty = []\n",
    "    removed = 0\n",
    "    for x, y in zip(reviews, labels):\n",
    "        if len(x) > 0:\n",
    "            reviews_not_empty.append(x)\n",
    "            labels_not_empty.append(y)\n",
    "        else:\n",
    "            removed += 1\n",
    "    #print(\"Removed {} sequences !\".format(removed))\n",
    "    return reviews_not_empty, labels_not_empty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Removing 8 empty sequences\n"
     ]
    }
   ],
   "source": [
    "print('Removing {} empty sequences'.format(reviews_len.count(0)))\n",
    "\n",
    "train_reviews_tokenized, train_labels = remove_empty_sequences(\n",
    "    train_reviews_tokenized, train_labels\n",
    ")\n",
    "\n",
    "val_reviews_tokenized, val_labels = remove_empty_sequences(\n",
    "    val_reviews_tokenized, val_labels\n",
    ")\n",
    "\n",
    "test_reviews_tokenized, test_labels = remove_empty_sequences(\n",
    "    test_reviews_tokenized, test_labels\n",
    ")\n",
    "\n",
    "# Verify\n",
    "reviews_len = [len(s) for s in train_reviews_tokenized+val_reviews_tokenized+test_reviews_tokenized]\n",
    "assert(reviews_len.count(0) == 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Padding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we pad short sequences with zeros until they reach a fixed length. Long sequences are also truncated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of X_train tensor: (159993, 350)\n",
      "Shape of X_val tensor: (19999, 350)\n",
      "Shape of X_test tensor: (20000, 350)\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.preprocessing.sequence import pad_sequences\n",
    "\n",
    "MAX_LENGTH_SEQ = 350 #\n",
    "\n",
    "X_train = pad_sequences(\n",
    "    train_reviews_tokenized, \n",
    "    maxlen=MAX_LENGTH_SEQ,\n",
    "    padding='post'\n",
    ")\n",
    "\n",
    "X_val = pad_sequences(\n",
    "    val_reviews_tokenized, \n",
    "    maxlen=MAX_LENGTH_SEQ,\n",
    "    padding='post'\n",
    ")\n",
    "\n",
    "X_test = pad_sequences(\n",
    "    test_reviews_tokenized, \n",
    "    maxlen=MAX_LENGTH_SEQ,\n",
    "    padding='post'\n",
    ")\n",
    "\n",
    "print('Shape of X_train tensor:', X_train.shape)\n",
    "print('Shape of X_val tensor:', X_val.shape)\n",
    "print('Shape of X_test tensor:', X_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = np.array(train_labels)\n",
    "y_val = np.array(val_labels)\n",
    "y_test = np.array(test_labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Preprocessing pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to carry out the preprocessing phase more efficiently, we can define a Scikit-Learn transformer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "\n",
    "class SequencePreprocessor(BaseEstimator, TransformerMixin):\n",
    "    def __init__(self, max_nbr_words, max_seq_length):\n",
    "        self.tokenizer = tf.keras.preprocessing.text.Tokenizer(\n",
    "            num_words=max_nbr_words,\n",
    "            oov_token=\"<unk>\",\n",
    "        )\n",
    "        self.max_seq_length = max_seq_length\n",
    "\n",
    "    # the arguments are ignored anyway, so we make them optional\n",
    "    def fit(self, X):\n",
    "        self.tokenizer.fit_on_texts(X)\n",
    "\n",
    "    def transform(self, X, y):\n",
    "        # 1. Tokenize\n",
    "        X_tokenized = self.tokenizer.texts_to_sequences(X)\n",
    "        # 2. Remove empty sequences\n",
    "        X_not_empty, y_not_empty = remove_empty_sequences(X_tokenized, y)\n",
    "        # 3. Pad\n",
    "        X_padded = tf.keras.preprocessing.sequence.pad_sequences(\n",
    "            X_not_empty, \n",
    "            maxlen=self.max_seq_length,\n",
    "            padding='post'\n",
    "        )\n",
    "        # 4. labels\n",
    "        y_array = np.array(y_not_empty)\n",
    "        return X_padded, y_array     \n",
    "    \n",
    "    def fit_transform(self, X, y):\n",
    "        self.fit(X)\n",
    "        return self.transform(X, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# fastText"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we train an model which classify reviews based on the average vector of their embeddings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, GlobalAveragePooling1D, Dense\n",
    "\n",
    "# Hyperparameters\n",
    "max_features = MAX_NB_WORDS\n",
    "embedding_dim = 128\n",
    "\n",
    "model = Sequential(name='fasttext')\n",
    "model.add(Embedding(max_features, embedding_dim,\n",
    "                           input_shape=[None]),)\n",
    "model.add(GlobalAveragePooling1D())\n",
    "model.add(Dense(1, activation=\"sigmoid\"))\n",
    "\n",
    "model.compile(\n",
    "    loss=\"binary_crossentropy\",\n",
    "    optimizer=\"adam\",\n",
    "    metrics=[\"accuracy\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"fasttext\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_3 (Embedding)      (None, None, 128)         2560000   \n",
      "_________________________________________________________________\n",
      "global_average_pooling1d (Gl (None, 128)               0         \n",
      "_________________________________________________________________\n",
      "dense_3 (Dense)              (None, 1)                 129       \n",
      "=================================================================\n",
      "Total params: 2,560,129\n",
      "Trainable params: 2,560,129\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "initial_weights = model.get_weights()\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 159993 samples, validate on 19999 samples\n",
      "Epoch 1/10\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.4704 - accuracy: 0.8224\n",
      "Epoch 00001: val_loss improved from inf to 0.30085, saving model to data/word-vectors/fasttext_weights.hdf5\n",
      "159993/159993 [==============================] - 27s 171us/sample - loss: 0.4703 - accuracy: 0.8225 - val_loss: 0.3009 - val_accuracy: 0.9060\n",
      "Epoch 2/10\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.2559 - accuracy: 0.9119\n",
      "Epoch 00002: val_loss improved from 0.30085 to 0.22888, saving model to data/word-vectors/fasttext_weights.hdf5\n",
      "159993/159993 [==============================] - 27s 170us/sample - loss: 0.2558 - accuracy: 0.9119 - val_loss: 0.2289 - val_accuracy: 0.9203\n",
      "Epoch 3/10\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.2065 - accuracy: 0.9257\n",
      "Epoch 00003: val_loss improved from 0.22888 to 0.20960, saving model to data/word-vectors/fasttext_weights.hdf5\n",
      "159993/159993 [==============================] - 27s 170us/sample - loss: 0.2065 - accuracy: 0.9257 - val_loss: 0.2096 - val_accuracy: 0.9254\n",
      "Epoch 4/10\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.1839 - accuracy: 0.9334\n",
      "Epoch 00004: val_loss improved from 0.20960 to 0.20485, saving model to data/word-vectors/fasttext_weights.hdf5\n",
      "159993/159993 [==============================] - 27s 171us/sample - loss: 0.1839 - accuracy: 0.9334 - val_loss: 0.2049 - val_accuracy: 0.9267\n",
      "Epoch 5/10\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.1704 - accuracy: 0.9380\n",
      "Epoch 00005: val_loss improved from 0.20485 to 0.20060, saving model to data/word-vectors/fasttext_weights.hdf5\n",
      "159993/159993 [==============================] - 27s 171us/sample - loss: 0.1704 - accuracy: 0.9380 - val_loss: 0.2006 - val_accuracy: 0.9289\n",
      "Epoch 6/10\n",
      "159616/159993 [============================>.] - ETA: 0s - loss: 0.1603 - accuracy: 0.9408\n",
      "Epoch 00006: val_loss did not improve from 0.20060\n",
      "159993/159993 [==============================] - 28s 172us/sample - loss: 0.1603 - accuracy: 0.9408 - val_loss: 0.2041 - val_accuracy: 0.9276\n",
      "Epoch 7/10\n",
      "159616/159993 [============================>.] - ETA: 0s - loss: 0.1531 - accuracy: 0.9438\n",
      "Epoch 00007: val_loss did not improve from 0.20060\n",
      "159993/159993 [==============================] - 28s 173us/sample - loss: 0.1530 - accuracy: 0.9439 - val_loss: 0.2035 - val_accuracy: 0.9280\n",
      "Epoch 8/10\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.1463 - accuracy: 0.9464\n",
      "Epoch 00008: val_loss did not improve from 0.20060\n",
      "159993/159993 [==============================] - 27s 171us/sample - loss: 0.1463 - accuracy: 0.9464 - val_loss: 0.2068 - val_accuracy: 0.9262\n",
      "Epoch 9/10\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.1413 - accuracy: 0.9482\n",
      "Epoch 00009: val_loss did not improve from 0.20060\n",
      "159993/159993 [==============================] - 27s 172us/sample - loss: 0.1413 - accuracy: 0.9482 - val_loss: 0.2105 - val_accuracy: 0.9268\n",
      "Epoch 10/10\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.1372 - accuracy: 0.9495\n",
      "Epoch 00010: val_loss did not improve from 0.20060\n",
      "159993/159993 [==============================] - 28s 173us/sample - loss: 0.1372 - accuracy: 0.9495 - val_loss: 0.2153 - val_accuracy: 0.9256\n"
     ]
    }
   ],
   "source": [
    "checkpointer = tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath='data/word-vectors/fasttext_weights.hdf5',\n",
    "    save_best_only=True, verbose=1\n",
    ")\n",
    "\n",
    "history = model.fit(\n",
    "    X_train, y_train,\n",
    "    validation_data=(X_val, y_val),\n",
    "    epochs=10, batch_size=128, \n",
    "    callbacks=[checkpointer], verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from utils import plot_training_curves\n",
    "\n",
    "fig = plot_training_curves(history)\n",
    "\n",
    "# Finalize the plot\n",
    "sns.despine(bottom=True)\n",
    "plt.tight_layout(h_pad=2)\n",
    "\n",
    "# Saving plot\n",
    "fig.savefig('img/word-vectors/fasttext_training.png', dpi=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Accuracy: 92.89\n",
      "Val F1-Score: 92.74\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "\n",
    "probas = model.predict(X_val)\n",
    "y_pred = (probas > 0.5).astype(np.int)\n",
    "\n",
    "print(\"Val Accuracy: {:.2f}\".format(100 * metrics.accuracy_score(y_val, y_pred)))\n",
    "print(\"Val F1-Score: {:.2f}\".format(100 * metrics.f1_score(y_val, y_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This simple technique works surprisingly well on our task !"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/fasttext_weights.hdf5')\n",
    "\n",
    "probas = model.predict(X_test)\n",
    "y_pred = (probas > 0.5).astype(np.int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 92.92\n",
      "Test F1-Score: 92.58\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "    Negative       0.93      0.94      0.93     10408\n",
      "    Positive       0.93      0.92      0.93      9592\n",
      "\n",
      "    accuracy                           0.93     20000\n",
      "   macro avg       0.93      0.93      0.93     20000\n",
      "weighted avg       0.93      0.93      0.93     20000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Test Accuracy: {:.2f}\".format(100 * metrics.accuracy_score(y_test, y_pred)))\n",
    "print(\"Test F1-Score: {:.2f}\".format(100 * metrics.f1_score(y_test, y_pred)))\n",
    "print()\n",
    "\n",
    "report = metrics.classification_report(\n",
    "    y_test, y_pred, \n",
    "    target_names=class_names.values()\n",
    ")\n",
    "print(report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "from utils import print_confusion_matrix\n",
    "\n",
    "conf_mx = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "fig = print_confusion_matrix(\n",
    "    conf_mx, \n",
    "    class_names.values(), \n",
    "    figsize=(7,5)\n",
    ")\n",
    "\n",
    "# Finalize the plot\n",
    "sns.despine(bottom=True)\n",
    "plt.tight_layout(h_pad=2)\n",
    "\n",
    "# Saving plot\n",
    "fig.savefig('img/word-vectors/fastext_test_confusion_mx.png', dpi=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accuracy vs Training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.base import BaseEstimator\n",
    "\n",
    "class EarlyStoppingModel(BaseEstimator):\n",
    "    def __init__(self, keras_model, max_epoches, batch_size, validation_data):\n",
    "        self.model = keras_model\n",
    "        self.max_epoches = max_epoches\n",
    "        self.batch_size = batch_size\n",
    "        self.validation_data = validation_data\n",
    "        \n",
    "    def fit(self, X, y):\n",
    "        # Defines early stopper\n",
    "        early_stopper = tf.keras.callbacks.EarlyStopping(\n",
    "            monitor='val_loss', mode='auto', patience=3,\n",
    "            verbose=1, restore_best_weights=True\n",
    "        )\n",
    "        \n",
    "        # Train model on data subset\n",
    "        self.model.fit(\n",
    "            X, y,\n",
    "            validation_data=self.validation_data,\n",
    "            epochs=self.max_epoches, \n",
    "            batch_size=self.batch_size,\n",
    "            callbacks=[early_stopper], \n",
    "            verbose=2\n",
    "        )        \n",
    "        return self\n",
    "    \n",
    "    def predict(self, X):        \n",
    "        probas = self.model.predict(X)\n",
    "        y_pred = (probas > 0.5).astype(np.int)\n",
    "        return y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics \n",
    "\n",
    "def accuracy_vs_training_data(keras_model, initial_weights, \n",
    "                              preprocessor, sizes,\n",
    "                              train_reviews, train_labels,\n",
    "                              val_reviews, val_labels,\n",
    "                              test_reviews, test_labels):\n",
    "    test_accuracies = []\n",
    "    for size in sizes:        \n",
    "        # Preprocess data\n",
    "        X_train, y_train = preprocessor.fit_transform(\n",
    "            train_reviews[:size], train_labels[:size]\n",
    "        )\n",
    "        X_val, y_val = preprocessor.transform(val_reviews, val_labels)\n",
    "        X_test, y_test = preprocessor.transform(test_reviews, test_labels)\n",
    "        \n",
    "        # Reset weights to initial value\n",
    "        keras_model.set_weights(initial_weights)\n",
    "        best_model = EarlyStoppingModel(\n",
    "            keras_model, max_epoches=100, batch_size=64,\n",
    "            validation_data=(X_val, y_val)\n",
    "        )\n",
    "        \n",
    "        # Train model\n",
    "        best_model.fit(X_train, y_train)\n",
    "        \n",
    "        # Evaluate on test set\n",
    "        y_pred = best_model.predict(X_test)\n",
    "        test_acc = metrics.accuracy_score(y_test, y_pred)\n",
    "        test_accuracies.append(test_acc)\n",
    "        \n",
    "    return test_accuracies        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 1000 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "1000/1000 - 1s - loss: 0.6925 - accuracy: 0.5100 - val_loss: 0.6912 - val_accuracy: 0.5379\n",
      "Epoch 2/100\n",
      "1000/1000 - 1s - loss: 0.6894 - accuracy: 0.5430 - val_loss: 0.6896 - val_accuracy: 0.5413\n",
      "Epoch 3/100\n",
      "1000/1000 - 1s - loss: 0.6873 - accuracy: 0.5420 - val_loss: 0.6881 - val_accuracy: 0.5408\n",
      "Epoch 4/100\n",
      "1000/1000 - 1s - loss: 0.6839 - accuracy: 0.5810 - val_loss: 0.6860 - val_accuracy: 0.5734\n",
      "Epoch 5/100\n",
      "1000/1000 - 1s - loss: 0.6801 - accuracy: 0.6110 - val_loss: 0.6839 - val_accuracy: 0.5750\n",
      "Epoch 6/100\n",
      "1000/1000 - 1s - loss: 0.6761 - accuracy: 0.6380 - val_loss: 0.6813 - val_accuracy: 0.5894\n",
      "Epoch 7/100\n",
      "1000/1000 - 1s - loss: 0.6709 - accuracy: 0.6440 - val_loss: 0.6783 - val_accuracy: 0.5893\n",
      "Epoch 8/100\n",
      "1000/1000 - 1s - loss: 0.6649 - accuracy: 0.6540 - val_loss: 0.6748 - val_accuracy: 0.6007\n",
      "Epoch 9/100\n",
      "1000/1000 - 1s - loss: 0.6582 - accuracy: 0.6870 - val_loss: 0.6709 - val_accuracy: 0.6293\n",
      "Epoch 10/100\n",
      "1000/1000 - 1s - loss: 0.6505 - accuracy: 0.7200 - val_loss: 0.6665 - val_accuracy: 0.6388\n",
      "Epoch 11/100\n",
      "1000/1000 - 1s - loss: 0.6417 - accuracy: 0.7070 - val_loss: 0.6618 - val_accuracy: 0.6215\n",
      "Epoch 12/100\n",
      "1000/1000 - 1s - loss: 0.6322 - accuracy: 0.7220 - val_loss: 0.6560 - val_accuracy: 0.6516\n",
      "Epoch 13/100\n",
      "1000/1000 - 1s - loss: 0.6212 - accuracy: 0.7570 - val_loss: 0.6504 - val_accuracy: 0.6568\n",
      "Epoch 14/100\n",
      "1000/1000 - 1s - loss: 0.6093 - accuracy: 0.7610 - val_loss: 0.6441 - val_accuracy: 0.6654\n",
      "Epoch 15/100\n",
      "1000/1000 - 1s - loss: 0.5965 - accuracy: 0.7860 - val_loss: 0.6372 - val_accuracy: 0.6865\n",
      "Epoch 16/100\n",
      "1000/1000 - 1s - loss: 0.5844 - accuracy: 0.8260 - val_loss: 0.6303 - val_accuracy: 0.6867\n",
      "Epoch 17/100\n",
      "1000/1000 - 1s - loss: 0.5700 - accuracy: 0.8300 - val_loss: 0.6229 - val_accuracy: 0.7050\n",
      "Epoch 18/100\n",
      "1000/1000 - 1s - loss: 0.5553 - accuracy: 0.8220 - val_loss: 0.6152 - val_accuracy: 0.7308\n",
      "Epoch 19/100\n",
      "1000/1000 - 1s - loss: 0.5405 - accuracy: 0.8830 - val_loss: 0.6075 - val_accuracy: 0.7622\n",
      "Epoch 20/100\n",
      "1000/1000 - 1s - loss: 0.5262 - accuracy: 0.8460 - val_loss: 0.6000 - val_accuracy: 0.7390\n",
      "Epoch 21/100\n",
      "1000/1000 - 1s - loss: 0.5106 - accuracy: 0.8960 - val_loss: 0.5922 - val_accuracy: 0.7574\n",
      "Epoch 22/100\n",
      "1000/1000 - 1s - loss: 0.4959 - accuracy: 0.9300 - val_loss: 0.5843 - val_accuracy: 0.7724\n",
      "Epoch 23/100\n",
      "1000/1000 - 1s - loss: 0.4827 - accuracy: 0.8500 - val_loss: 0.5766 - val_accuracy: 0.7815\n",
      "Epoch 24/100\n",
      "1000/1000 - 1s - loss: 0.4665 - accuracy: 0.9500 - val_loss: 0.5690 - val_accuracy: 0.8020\n",
      "Epoch 25/100\n",
      "1000/1000 - 1s - loss: 0.4527 - accuracy: 0.8960 - val_loss: 0.5617 - val_accuracy: 0.7873\n",
      "Epoch 26/100\n",
      "1000/1000 - 1s - loss: 0.4376 - accuracy: 0.9320 - val_loss: 0.5542 - val_accuracy: 0.7981\n",
      "Epoch 27/100\n",
      "1000/1000 - 1s - loss: 0.4244 - accuracy: 0.9590 - val_loss: 0.5471 - val_accuracy: 0.7991\n",
      "Epoch 28/100\n",
      "1000/1000 - 1s - loss: 0.4128 - accuracy: 0.8950 - val_loss: 0.5403 - val_accuracy: 0.8178\n",
      "Epoch 29/100\n",
      "1000/1000 - 1s - loss: 0.3995 - accuracy: 0.9630 - val_loss: 0.5343 - val_accuracy: 0.7954\n",
      "Epoch 30/100\n",
      "1000/1000 - 1s - loss: 0.3856 - accuracy: 0.9260 - val_loss: 0.5274 - val_accuracy: 0.8072\n",
      "Epoch 31/100\n",
      "1000/1000 - 1s - loss: 0.3741 - accuracy: 0.9660 - val_loss: 0.5214 - val_accuracy: 0.8062\n",
      "Epoch 32/100\n",
      "1000/1000 - 1s - loss: 0.3626 - accuracy: 0.9480 - val_loss: 0.5151 - val_accuracy: 0.8182\n",
      "Epoch 33/100\n",
      "1000/1000 - 1s - loss: 0.3505 - accuracy: 0.9480 - val_loss: 0.5093 - val_accuracy: 0.8182\n",
      "Epoch 34/100\n",
      "1000/1000 - 1s - loss: 0.3399 - accuracy: 0.9620 - val_loss: 0.5041 - val_accuracy: 0.8135\n",
      "Epoch 35/100\n",
      "1000/1000 - 1s - loss: 0.3291 - accuracy: 0.9570 - val_loss: 0.4982 - val_accuracy: 0.8266\n",
      "Epoch 36/100\n",
      "1000/1000 - 1s - loss: 0.3199 - accuracy: 0.9520 - val_loss: 0.4931 - val_accuracy: 0.8277\n",
      "Epoch 37/100\n",
      "1000/1000 - 1s - loss: 0.3123 - accuracy: 0.9710 - val_loss: 0.4904 - val_accuracy: 0.8026\n",
      "Epoch 38/100\n",
      "1000/1000 - 1s - loss: 0.3005 - accuracy: 0.9560 - val_loss: 0.4835 - val_accuracy: 0.8244\n",
      "Epoch 39/100\n",
      "1000/1000 - 1s - loss: 0.2916 - accuracy: 0.9680 - val_loss: 0.4788 - val_accuracy: 0.8287\n",
      "Epoch 40/100\n",
      "1000/1000 - 1s - loss: 0.2837 - accuracy: 0.9590 - val_loss: 0.4745 - val_accuracy: 0.8328\n",
      "Epoch 41/100\n",
      "1000/1000 - 1s - loss: 0.2757 - accuracy: 0.9660 - val_loss: 0.4702 - val_accuracy: 0.8294\n",
      "Epoch 42/100\n",
      "1000/1000 - 1s - loss: 0.2668 - accuracy: 0.9690 - val_loss: 0.4662 - val_accuracy: 0.8345\n",
      "Epoch 43/100\n",
      "1000/1000 - 1s - loss: 0.2591 - accuracy: 0.9740 - val_loss: 0.4636 - val_accuracy: 0.8208\n",
      "Epoch 44/100\n",
      "1000/1000 - 1s - loss: 0.2537 - accuracy: 0.9560 - val_loss: 0.4594 - val_accuracy: 0.8366\n",
      "Epoch 45/100\n",
      "1000/1000 - 1s - loss: 0.2454 - accuracy: 0.9790 - val_loss: 0.4551 - val_accuracy: 0.8310\n",
      "Epoch 46/100\n",
      "1000/1000 - 1s - loss: 0.2377 - accuracy: 0.9710 - val_loss: 0.4519 - val_accuracy: 0.8311\n",
      "Epoch 47/100\n",
      "1000/1000 - 1s - loss: 0.2316 - accuracy: 0.9760 - val_loss: 0.4482 - val_accuracy: 0.8336\n",
      "Epoch 48/100\n",
      "1000/1000 - 1s - loss: 0.2259 - accuracy: 0.9660 - val_loss: 0.4450 - val_accuracy: 0.8343\n",
      "Epoch 49/100\n",
      "1000/1000 - 1s - loss: 0.2191 - accuracy: 0.9790 - val_loss: 0.4418 - val_accuracy: 0.8367\n",
      "Epoch 50/100\n",
      "1000/1000 - 1s - loss: 0.2130 - accuracy: 0.9760 - val_loss: 0.4392 - val_accuracy: 0.8350\n",
      "Epoch 51/100\n",
      "1000/1000 - 1s - loss: 0.2074 - accuracy: 0.9790 - val_loss: 0.4362 - val_accuracy: 0.8367\n",
      "Epoch 52/100\n",
      "1000/1000 - 1s - loss: 0.2020 - accuracy: 0.9770 - val_loss: 0.4336 - val_accuracy: 0.8359\n",
      "Epoch 53/100\n",
      "1000/1000 - 1s - loss: 0.1974 - accuracy: 0.9780 - val_loss: 0.4309 - val_accuracy: 0.8397\n",
      "Epoch 54/100\n",
      "1000/1000 - 1s - loss: 0.1916 - accuracy: 0.9800 - val_loss: 0.4291 - val_accuracy: 0.8350\n",
      "Epoch 55/100\n",
      "1000/1000 - 1s - loss: 0.1871 - accuracy: 0.9790 - val_loss: 0.4260 - val_accuracy: 0.8388\n",
      "Epoch 56/100\n",
      "1000/1000 - 1s - loss: 0.1823 - accuracy: 0.9800 - val_loss: 0.4236 - val_accuracy: 0.8403\n",
      "Epoch 57/100\n",
      "1000/1000 - 1s - loss: 0.1778 - accuracy: 0.9810 - val_loss: 0.4216 - val_accuracy: 0.8398\n",
      "Epoch 58/100\n",
      "1000/1000 - 1s - loss: 0.1733 - accuracy: 0.9830 - val_loss: 0.4196 - val_accuracy: 0.8393\n",
      "Epoch 59/100\n",
      "1000/1000 - 1s - loss: 0.1689 - accuracy: 0.9820 - val_loss: 0.4175 - val_accuracy: 0.8406\n",
      "Epoch 60/100\n",
      "1000/1000 - 1s - loss: 0.1649 - accuracy: 0.9830 - val_loss: 0.4154 - val_accuracy: 0.8411\n",
      "Epoch 61/100\n",
      "1000/1000 - 1s - loss: 0.1613 - accuracy: 0.9830 - val_loss: 0.4147 - val_accuracy: 0.8373\n",
      "Epoch 62/100\n",
      "1000/1000 - 1s - loss: 0.1571 - accuracy: 0.9830 - val_loss: 0.4117 - val_accuracy: 0.8419\n",
      "Epoch 63/100\n",
      "1000/1000 - 1s - loss: 0.1546 - accuracy: 0.9850 - val_loss: 0.4110 - val_accuracy: 0.8389\n",
      "Epoch 64/100\n",
      "1000/1000 - 1s - loss: 0.1506 - accuracy: 0.9850 - val_loss: 0.4093 - val_accuracy: 0.8395\n",
      "Epoch 65/100\n",
      "1000/1000 - 1s - loss: 0.1465 - accuracy: 0.9840 - val_loss: 0.4069 - val_accuracy: 0.8420\n",
      "Epoch 66/100\n",
      "1000/1000 - 1s - loss: 0.1432 - accuracy: 0.9840 - val_loss: 0.4054 - val_accuracy: 0.8424\n",
      "Epoch 67/100\n",
      "1000/1000 - 1s - loss: 0.1399 - accuracy: 0.9850 - val_loss: 0.4043 - val_accuracy: 0.8419\n",
      "Epoch 68/100\n",
      "1000/1000 - 1s - loss: 0.1372 - accuracy: 0.9840 - val_loss: 0.4026 - val_accuracy: 0.8436\n",
      "Epoch 69/100\n",
      "1000/1000 - 1s - loss: 0.1337 - accuracy: 0.9850 - val_loss: 0.4017 - val_accuracy: 0.8419\n",
      "Epoch 70/100\n",
      "1000/1000 - 1s - loss: 0.1309 - accuracy: 0.9870 - val_loss: 0.4000 - val_accuracy: 0.8440\n",
      "Epoch 71/100\n",
      "1000/1000 - 1s - loss: 0.1280 - accuracy: 0.9860 - val_loss: 0.3989 - val_accuracy: 0.8437\n",
      "Epoch 72/100\n",
      "1000/1000 - 1s - loss: 0.1254 - accuracy: 0.9850 - val_loss: 0.3983 - val_accuracy: 0.8423\n",
      "Epoch 73/100\n",
      "1000/1000 - 1s - loss: 0.1226 - accuracy: 0.9870 - val_loss: 0.3973 - val_accuracy: 0.8421\n",
      "Epoch 74/100\n",
      "1000/1000 - 1s - loss: 0.1199 - accuracy: 0.9860 - val_loss: 0.3956 - val_accuracy: 0.8444\n",
      "Epoch 75/100\n",
      "1000/1000 - 1s - loss: 0.1179 - accuracy: 0.9850 - val_loss: 0.3947 - val_accuracy: 0.8441\n",
      "Epoch 76/100\n",
      "1000/1000 - 1s - loss: 0.1153 - accuracy: 0.9870 - val_loss: 0.3945 - val_accuracy: 0.8420\n",
      "Epoch 77/100\n",
      "1000/1000 - 1s - loss: 0.1128 - accuracy: 0.9870 - val_loss: 0.3927 - val_accuracy: 0.8455\n",
      "Epoch 78/100\n",
      "1000/1000 - 1s - loss: 0.1104 - accuracy: 0.9870 - val_loss: 0.3924 - val_accuracy: 0.8429\n",
      "Epoch 79/100\n",
      "1000/1000 - 1s - loss: 0.1084 - accuracy: 0.9900 - val_loss: 0.3915 - val_accuracy: 0.8433\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 80/100\n",
      "1000/1000 - 1s - loss: 0.1061 - accuracy: 0.9880 - val_loss: 0.3907 - val_accuracy: 0.8443\n",
      "Epoch 81/100\n",
      "1000/1000 - 1s - loss: 0.1037 - accuracy: 0.9900 - val_loss: 0.3895 - val_accuracy: 0.8451\n",
      "Epoch 82/100\n",
      "1000/1000 - 1s - loss: 0.1015 - accuracy: 0.9900 - val_loss: 0.3899 - val_accuracy: 0.8422\n",
      "Epoch 83/100\n",
      "1000/1000 - 1s - loss: 0.1001 - accuracy: 0.9900 - val_loss: 0.3891 - val_accuracy: 0.8428\n",
      "Epoch 84/100\n",
      "1000/1000 - 1s - loss: 0.0977 - accuracy: 0.9880 - val_loss: 0.3876 - val_accuracy: 0.8457\n",
      "Epoch 85/100\n",
      "1000/1000 - 1s - loss: 0.0959 - accuracy: 0.9900 - val_loss: 0.3869 - val_accuracy: 0.8466\n",
      "Epoch 86/100\n",
      "1000/1000 - 1s - loss: 0.0943 - accuracy: 0.9890 - val_loss: 0.3864 - val_accuracy: 0.8462\n",
      "Epoch 87/100\n",
      "1000/1000 - 1s - loss: 0.0925 - accuracy: 0.9940 - val_loss: 0.3878 - val_accuracy: 0.8409\n",
      "Epoch 88/100\n",
      "1000/1000 - 1s - loss: 0.0906 - accuracy: 0.9900 - val_loss: 0.3855 - val_accuracy: 0.8458\n",
      "Epoch 89/100\n",
      "1000/1000 - 1s - loss: 0.0887 - accuracy: 0.9910 - val_loss: 0.3848 - val_accuracy: 0.8468\n",
      "Epoch 90/100\n",
      "1000/1000 - 1s - loss: 0.0871 - accuracy: 0.9920 - val_loss: 0.3845 - val_accuracy: 0.8459\n",
      "Epoch 91/100\n",
      "1000/1000 - 1s - loss: 0.0855 - accuracy: 0.9910 - val_loss: 0.3839 - val_accuracy: 0.8470\n",
      "Epoch 92/100\n",
      "1000/1000 - 1s - loss: 0.0842 - accuracy: 0.9930 - val_loss: 0.3836 - val_accuracy: 0.8470\n",
      "Epoch 93/100\n",
      "1000/1000 - 1s - loss: 0.0828 - accuracy: 0.9910 - val_loss: 0.3833 - val_accuracy: 0.8464\n",
      "Epoch 94/100\n",
      "1000/1000 - 1s - loss: 0.0815 - accuracy: 0.9940 - val_loss: 0.3845 - val_accuracy: 0.8438\n",
      "Epoch 95/100\n",
      "1000/1000 - 1s - loss: 0.0795 - accuracy: 0.9890 - val_loss: 0.3827 - val_accuracy: 0.8465\n",
      "Epoch 96/100\n",
      "1000/1000 - 1s - loss: 0.0785 - accuracy: 0.9940 - val_loss: 0.3840 - val_accuracy: 0.8437\n",
      "Epoch 97/100\n",
      "1000/1000 - 1s - loss: 0.0768 - accuracy: 0.9910 - val_loss: 0.3821 - val_accuracy: 0.8464\n",
      "Epoch 98/100\n",
      "1000/1000 - 1s - loss: 0.0758 - accuracy: 0.9940 - val_loss: 0.3824 - val_accuracy: 0.8459\n",
      "Epoch 99/100\n",
      "1000/1000 - 1s - loss: 0.0738 - accuracy: 0.9920 - val_loss: 0.3819 - val_accuracy: 0.8464\n",
      "Epoch 100/100\n",
      "1000/1000 - 1s - loss: 0.0726 - accuracy: 0.9940 - val_loss: 0.3817 - val_accuracy: 0.8462\n",
      "Train on 1757 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "1757/1757 - 1s - loss: 0.6932 - accuracy: 0.5174 - val_loss: 0.6909 - val_accuracy: 0.5113\n",
      "Epoch 2/100\n",
      "1757/1757 - 1s - loss: 0.6881 - accuracy: 0.5857 - val_loss: 0.6882 - val_accuracy: 0.5823\n",
      "Epoch 3/100\n",
      "1757/1757 - 1s - loss: 0.6835 - accuracy: 0.5805 - val_loss: 0.6852 - val_accuracy: 0.5735\n",
      "Epoch 4/100\n",
      "1757/1757 - 1s - loss: 0.6775 - accuracy: 0.6386 - val_loss: 0.6815 - val_accuracy: 0.6021\n",
      "Epoch 5/100\n",
      "1757/1757 - 1s - loss: 0.6705 - accuracy: 0.6614 - val_loss: 0.6771 - val_accuracy: 0.6081\n",
      "Epoch 6/100\n",
      "1757/1757 - 1s - loss: 0.6620 - accuracy: 0.6756 - val_loss: 0.6712 - val_accuracy: 0.6246\n",
      "Epoch 7/100\n",
      "1757/1757 - 1s - loss: 0.6511 - accuracy: 0.7496 - val_loss: 0.6637 - val_accuracy: 0.6492\n",
      "Epoch 8/100\n",
      "1757/1757 - 1s - loss: 0.6370 - accuracy: 0.7615 - val_loss: 0.6545 - val_accuracy: 0.6803\n",
      "Epoch 9/100\n",
      "1757/1757 - 1s - loss: 0.6202 - accuracy: 0.7934 - val_loss: 0.6437 - val_accuracy: 0.7204\n",
      "Epoch 10/100\n",
      "1757/1757 - 1s - loss: 0.6002 - accuracy: 0.8429 - val_loss: 0.6312 - val_accuracy: 0.7334\n",
      "Epoch 11/100\n",
      "1757/1757 - 1s - loss: 0.5784 - accuracy: 0.7906 - val_loss: 0.6171 - val_accuracy: 0.7585\n",
      "Epoch 12/100\n",
      "1757/1757 - 1s - loss: 0.5538 - accuracy: 0.8936 - val_loss: 0.6021 - val_accuracy: 0.8006\n",
      "Epoch 13/100\n",
      "1757/1757 - 1s - loss: 0.5279 - accuracy: 0.9203 - val_loss: 0.5887 - val_accuracy: 0.7246\n",
      "Epoch 14/100\n",
      "1757/1757 - 1s - loss: 0.5019 - accuracy: 0.9021 - val_loss: 0.5713 - val_accuracy: 0.7834\n",
      "Epoch 15/100\n",
      "1757/1757 - 1s - loss: 0.4741 - accuracy: 0.9084 - val_loss: 0.5548 - val_accuracy: 0.8306\n",
      "Epoch 16/100\n",
      "1757/1757 - 1s - loss: 0.4482 - accuracy: 0.9499 - val_loss: 0.5431 - val_accuracy: 0.7644\n",
      "Epoch 17/100\n",
      "1757/1757 - 1s - loss: 0.4247 - accuracy: 0.9277 - val_loss: 0.5249 - val_accuracy: 0.8397\n",
      "Epoch 18/100\n",
      "1757/1757 - 1s - loss: 0.4009 - accuracy: 0.9437 - val_loss: 0.5121 - val_accuracy: 0.8435\n",
      "Epoch 19/100\n",
      "1757/1757 - 1s - loss: 0.3782 - accuracy: 0.9516 - val_loss: 0.4985 - val_accuracy: 0.8445\n",
      "Epoch 20/100\n",
      "1757/1757 - 1s - loss: 0.3570 - accuracy: 0.9562 - val_loss: 0.4866 - val_accuracy: 0.8337\n",
      "Epoch 21/100\n",
      "1757/1757 - 1s - loss: 0.3370 - accuracy: 0.9602 - val_loss: 0.4757 - val_accuracy: 0.8480\n",
      "Epoch 22/100\n",
      "1757/1757 - 1s - loss: 0.3198 - accuracy: 0.9630 - val_loss: 0.4658 - val_accuracy: 0.8491\n",
      "Epoch 23/100\n",
      "1757/1757 - 1s - loss: 0.3031 - accuracy: 0.9698 - val_loss: 0.4566 - val_accuracy: 0.8345\n",
      "Epoch 24/100\n",
      "1757/1757 - 1s - loss: 0.2872 - accuracy: 0.9693 - val_loss: 0.4472 - val_accuracy: 0.8399\n",
      "Epoch 25/100\n",
      "1757/1757 - 1s - loss: 0.2725 - accuracy: 0.9693 - val_loss: 0.4375 - val_accuracy: 0.8506\n",
      "Epoch 26/100\n",
      "1757/1757 - 1s - loss: 0.2593 - accuracy: 0.9715 - val_loss: 0.4301 - val_accuracy: 0.8503\n",
      "Epoch 27/100\n",
      "1757/1757 - 1s - loss: 0.2474 - accuracy: 0.9778 - val_loss: 0.4229 - val_accuracy: 0.8523\n",
      "Epoch 28/100\n",
      "1757/1757 - 1s - loss: 0.2344 - accuracy: 0.9755 - val_loss: 0.4174 - val_accuracy: 0.8553\n",
      "Epoch 29/100\n",
      "1757/1757 - 1s - loss: 0.2256 - accuracy: 0.9772 - val_loss: 0.4118 - val_accuracy: 0.8468\n",
      "Epoch 30/100\n",
      "1757/1757 - 1s - loss: 0.2163 - accuracy: 0.9772 - val_loss: 0.4047 - val_accuracy: 0.8575\n",
      "Epoch 31/100\n",
      "1757/1757 - 1s - loss: 0.2048 - accuracy: 0.9806 - val_loss: 0.3998 - val_accuracy: 0.8582\n",
      "Epoch 32/100\n",
      "1757/1757 - 1s - loss: 0.1965 - accuracy: 0.9846 - val_loss: 0.3947 - val_accuracy: 0.8591\n",
      "Epoch 33/100\n",
      "1757/1757 - 1s - loss: 0.1874 - accuracy: 0.9824 - val_loss: 0.3917 - val_accuracy: 0.8588\n",
      "Epoch 34/100\n",
      "1757/1757 - 1s - loss: 0.1799 - accuracy: 0.9835 - val_loss: 0.3862 - val_accuracy: 0.8597\n",
      "Epoch 35/100\n",
      "1757/1757 - 1s - loss: 0.1728 - accuracy: 0.9846 - val_loss: 0.3823 - val_accuracy: 0.8616\n",
      "Epoch 36/100\n",
      "1757/1757 - 1s - loss: 0.1662 - accuracy: 0.9824 - val_loss: 0.3789 - val_accuracy: 0.8613\n",
      "Epoch 37/100\n",
      "1757/1757 - 1s - loss: 0.1598 - accuracy: 0.9852 - val_loss: 0.3760 - val_accuracy: 0.8622\n",
      "Epoch 38/100\n",
      "1757/1757 - 1s - loss: 0.1539 - accuracy: 0.9863 - val_loss: 0.3726 - val_accuracy: 0.8623\n",
      "Epoch 39/100\n",
      "1757/1757 - 1s - loss: 0.1476 - accuracy: 0.9869 - val_loss: 0.3699 - val_accuracy: 0.8627\n",
      "Epoch 40/100\n",
      "1757/1757 - 1s - loss: 0.1425 - accuracy: 0.9852 - val_loss: 0.3671 - val_accuracy: 0.8626\n",
      "Epoch 41/100\n",
      "1757/1757 - 1s - loss: 0.1369 - accuracy: 0.9880 - val_loss: 0.3642 - val_accuracy: 0.8634\n",
      "Epoch 42/100\n",
      "1757/1757 - 1s - loss: 0.1323 - accuracy: 0.9886 - val_loss: 0.3619 - val_accuracy: 0.8628\n",
      "Epoch 43/100\n",
      "1757/1757 - 1s - loss: 0.1281 - accuracy: 0.9880 - val_loss: 0.3601 - val_accuracy: 0.8637\n",
      "Epoch 44/100\n",
      "1757/1757 - 1s - loss: 0.1235 - accuracy: 0.9886 - val_loss: 0.3575 - val_accuracy: 0.8649\n",
      "Epoch 45/100\n",
      "1757/1757 - 1s - loss: 0.1196 - accuracy: 0.9892 - val_loss: 0.3557 - val_accuracy: 0.8634\n",
      "Epoch 46/100\n",
      "1757/1757 - 1s - loss: 0.1162 - accuracy: 0.9892 - val_loss: 0.3548 - val_accuracy: 0.8623\n",
      "Epoch 47/100\n",
      "1757/1757 - 1s - loss: 0.1122 - accuracy: 0.9898 - val_loss: 0.3520 - val_accuracy: 0.8649\n",
      "Epoch 48/100\n",
      "1757/1757 - 1s - loss: 0.1079 - accuracy: 0.9909 - val_loss: 0.3507 - val_accuracy: 0.8651\n",
      "Epoch 49/100\n",
      "1757/1757 - 1s - loss: 0.1045 - accuracy: 0.9909 - val_loss: 0.3490 - val_accuracy: 0.8656\n",
      "Epoch 50/100\n",
      "1757/1757 - 1s - loss: 0.1011 - accuracy: 0.9909 - val_loss: 0.3479 - val_accuracy: 0.8657\n",
      "Epoch 51/100\n",
      "1757/1757 - 1s - loss: 0.0982 - accuracy: 0.9903 - val_loss: 0.3464 - val_accuracy: 0.8653\n",
      "Epoch 52/100\n",
      "1757/1757 - 1s - loss: 0.0966 - accuracy: 0.9898 - val_loss: 0.3458 - val_accuracy: 0.8654\n",
      "Epoch 53/100\n",
      "1757/1757 - 1s - loss: 0.0923 - accuracy: 0.9932 - val_loss: 0.3451 - val_accuracy: 0.8650\n",
      "Epoch 54/100\n",
      "1757/1757 - 1s - loss: 0.0900 - accuracy: 0.9915 - val_loss: 0.3455 - val_accuracy: 0.8660\n",
      "Epoch 55/100\n",
      "1757/1757 - 1s - loss: 0.0868 - accuracy: 0.9920 - val_loss: 0.3424 - val_accuracy: 0.8668\n",
      "Epoch 56/100\n",
      "1757/1757 - 1s - loss: 0.0844 - accuracy: 0.9932 - val_loss: 0.3459 - val_accuracy: 0.8614\n",
      "Epoch 57/100\n",
      "1757/1757 - 1s - loss: 0.0827 - accuracy: 0.9926 - val_loss: 0.3433 - val_accuracy: 0.8635\n",
      "Epoch 58/100\n",
      "1757/1757 - 1s - loss: 0.0805 - accuracy: 0.9920 - val_loss: 0.3399 - val_accuracy: 0.8676\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 59/100\n",
      "1757/1757 - 1s - loss: 0.0776 - accuracy: 0.9926 - val_loss: 0.3392 - val_accuracy: 0.8665\n",
      "Epoch 60/100\n",
      "1757/1757 - 1s - loss: 0.0756 - accuracy: 0.9932 - val_loss: 0.3399 - val_accuracy: 0.8655\n",
      "Epoch 61/100\n",
      "1757/1757 - 1s - loss: 0.0727 - accuracy: 0.9920 - val_loss: 0.3435 - val_accuracy: 0.8660\n",
      "Epoch 62/100\n",
      "1757/1757 - 1s - loss: 0.0726 - accuracy: 0.9926 - val_loss: 0.3380 - val_accuracy: 0.8671\n",
      "Epoch 63/100\n",
      "1757/1757 - 1s - loss: 0.0696 - accuracy: 0.9943 - val_loss: 0.3396 - val_accuracy: 0.8650\n",
      "Epoch 64/100\n",
      "1757/1757 - 1s - loss: 0.0685 - accuracy: 0.9932 - val_loss: 0.3366 - val_accuracy: 0.8674\n",
      "Epoch 65/100\n",
      "1757/1757 - 1s - loss: 0.0665 - accuracy: 0.9943 - val_loss: 0.3381 - val_accuracy: 0.8681\n",
      "Epoch 66/100\n",
      "1757/1757 - 1s - loss: 0.0645 - accuracy: 0.9937 - val_loss: 0.3359 - val_accuracy: 0.8679\n",
      "Epoch 67/100\n",
      "1757/1757 - 1s - loss: 0.0628 - accuracy: 0.9943 - val_loss: 0.3356 - val_accuracy: 0.8681\n",
      "Epoch 68/100\n",
      "1757/1757 - 1s - loss: 0.0612 - accuracy: 0.9949 - val_loss: 0.3356 - val_accuracy: 0.8688\n",
      "Epoch 69/100\n",
      "1757/1757 - 1s - loss: 0.0595 - accuracy: 0.9954 - val_loss: 0.3353 - val_accuracy: 0.8687\n",
      "Epoch 70/100\n",
      "1757/1757 - 1s - loss: 0.0578 - accuracy: 0.9954 - val_loss: 0.3350 - val_accuracy: 0.8691\n",
      "Epoch 71/100\n",
      "1757/1757 - 1s - loss: 0.0569 - accuracy: 0.9954 - val_loss: 0.3353 - val_accuracy: 0.8683\n",
      "Epoch 72/100\n",
      "1757/1757 - 1s - loss: 0.0550 - accuracy: 0.9954 - val_loss: 0.3360 - val_accuracy: 0.8673\n",
      "Epoch 73/100\n",
      "1757/1757 - 1s - loss: 0.0540 - accuracy: 0.9960 - val_loss: 0.3346 - val_accuracy: 0.8693\n",
      "Epoch 74/100\n",
      "1757/1757 - 1s - loss: 0.0524 - accuracy: 0.9960 - val_loss: 0.3344 - val_accuracy: 0.8695\n",
      "Epoch 75/100\n",
      "1757/1757 - 1s - loss: 0.0517 - accuracy: 0.9954 - val_loss: 0.3345 - val_accuracy: 0.8693\n",
      "Epoch 76/100\n",
      "1757/1757 - 1s - loss: 0.0504 - accuracy: 0.9954 - val_loss: 0.3345 - val_accuracy: 0.8694\n",
      "Epoch 77/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "1757/1757 - 1s - loss: 0.0489 - accuracy: 0.9960 - val_loss: 0.3350 - val_accuracy: 0.8688\n",
      "Epoch 00077: early stopping\n",
      "Train on 3088 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "3088/3088 - 2s - loss: 0.6918 - accuracy: 0.5324 - val_loss: 0.6890 - val_accuracy: 0.5410\n",
      "Epoch 2/100\n",
      "3088/3088 - 2s - loss: 0.6857 - accuracy: 0.5560 - val_loss: 0.6839 - val_accuracy: 0.5827\n",
      "Epoch 3/100\n",
      "3088/3088 - 2s - loss: 0.6781 - accuracy: 0.5959 - val_loss: 0.6769 - val_accuracy: 0.6027\n",
      "Epoch 4/100\n",
      "3088/3088 - 2s - loss: 0.6671 - accuracy: 0.6655 - val_loss: 0.6664 - val_accuracy: 0.6467\n",
      "Epoch 5/100\n",
      "3088/3088 - 2s - loss: 0.6503 - accuracy: 0.6891 - val_loss: 0.6517 - val_accuracy: 0.6541\n",
      "Epoch 6/100\n",
      "3088/3088 - 2s - loss: 0.6266 - accuracy: 0.7134 - val_loss: 0.6303 - val_accuracy: 0.7386\n",
      "Epoch 7/100\n",
      "3088/3088 - 2s - loss: 0.5942 - accuracy: 0.8439 - val_loss: 0.6042 - val_accuracy: 0.7388\n",
      "Epoch 8/100\n",
      "3088/3088 - 2s - loss: 0.5546 - accuracy: 0.8731 - val_loss: 0.5747 - val_accuracy: 0.7728\n",
      "Epoch 9/100\n",
      "3088/3088 - 2s - loss: 0.5126 - accuracy: 0.8701 - val_loss: 0.5428 - val_accuracy: 0.8469\n",
      "Epoch 10/100\n",
      "3088/3088 - 2s - loss: 0.4689 - accuracy: 0.9064 - val_loss: 0.5139 - val_accuracy: 0.8539\n",
      "Epoch 11/100\n",
      "3088/3088 - 2s - loss: 0.4283 - accuracy: 0.9200 - val_loss: 0.4912 - val_accuracy: 0.8128\n",
      "Epoch 12/100\n",
      "3088/3088 - 2s - loss: 0.3911 - accuracy: 0.9317 - val_loss: 0.4632 - val_accuracy: 0.8573\n",
      "Epoch 13/100\n",
      "3088/3088 - 2s - loss: 0.3583 - accuracy: 0.9411 - val_loss: 0.4435 - val_accuracy: 0.8636\n",
      "Epoch 14/100\n",
      "3088/3088 - 2s - loss: 0.3299 - accuracy: 0.9385 - val_loss: 0.4271 - val_accuracy: 0.8649\n",
      "Epoch 15/100\n",
      "3088/3088 - 2s - loss: 0.3040 - accuracy: 0.9511 - val_loss: 0.4104 - val_accuracy: 0.8673\n",
      "Epoch 16/100\n",
      "3088/3088 - 2s - loss: 0.2816 - accuracy: 0.9573 - val_loss: 0.3980 - val_accuracy: 0.8679\n",
      "Epoch 17/100\n",
      "3088/3088 - 2s - loss: 0.2631 - accuracy: 0.9573 - val_loss: 0.3891 - val_accuracy: 0.8603\n",
      "Epoch 18/100\n",
      "3088/3088 - 2s - loss: 0.2447 - accuracy: 0.9621 - val_loss: 0.3762 - val_accuracy: 0.8729\n",
      "Epoch 19/100\n",
      "3088/3088 - 2s - loss: 0.2290 - accuracy: 0.9637 - val_loss: 0.3683 - val_accuracy: 0.8708\n",
      "Epoch 20/100\n",
      "3088/3088 - 2s - loss: 0.2138 - accuracy: 0.9679 - val_loss: 0.3600 - val_accuracy: 0.8756\n",
      "Epoch 21/100\n",
      "3088/3088 - 2s - loss: 0.2018 - accuracy: 0.9696 - val_loss: 0.3547 - val_accuracy: 0.8744\n",
      "Epoch 22/100\n",
      "3088/3088 - 2s - loss: 0.1899 - accuracy: 0.9734 - val_loss: 0.3470 - val_accuracy: 0.8787\n",
      "Epoch 23/100\n",
      "3088/3088 - 2s - loss: 0.1803 - accuracy: 0.9731 - val_loss: 0.3423 - val_accuracy: 0.8791\n",
      "Epoch 24/100\n",
      "3088/3088 - 2s - loss: 0.1694 - accuracy: 0.9760 - val_loss: 0.3377 - val_accuracy: 0.8772\n",
      "Epoch 25/100\n",
      "3088/3088 - 2s - loss: 0.1603 - accuracy: 0.9783 - val_loss: 0.3348 - val_accuracy: 0.8786\n",
      "Epoch 26/100\n",
      "3088/3088 - 2s - loss: 0.1525 - accuracy: 0.9790 - val_loss: 0.3307 - val_accuracy: 0.8795\n",
      "Epoch 27/100\n",
      "3088/3088 - 2s - loss: 0.1456 - accuracy: 0.9806 - val_loss: 0.3270 - val_accuracy: 0.8785\n",
      "Epoch 28/100\n",
      "3088/3088 - 2s - loss: 0.1383 - accuracy: 0.9838 - val_loss: 0.3228 - val_accuracy: 0.8805\n",
      "Epoch 29/100\n",
      "3088/3088 - 2s - loss: 0.1325 - accuracy: 0.9819 - val_loss: 0.3204 - val_accuracy: 0.8824\n",
      "Epoch 30/100\n",
      "3088/3088 - 2s - loss: 0.1259 - accuracy: 0.9825 - val_loss: 0.3175 - val_accuracy: 0.8839\n",
      "Epoch 31/100\n",
      "3088/3088 - 2s - loss: 0.1204 - accuracy: 0.9825 - val_loss: 0.3162 - val_accuracy: 0.8814\n",
      "Epoch 32/100\n",
      "3088/3088 - 2s - loss: 0.1152 - accuracy: 0.9841 - val_loss: 0.3243 - val_accuracy: 0.8705\n",
      "Epoch 33/100\n",
      "3088/3088 - 2s - loss: 0.1116 - accuracy: 0.9838 - val_loss: 0.3136 - val_accuracy: 0.8809\n",
      "Epoch 34/100\n",
      "3088/3088 - 2s - loss: 0.1052 - accuracy: 0.9861 - val_loss: 0.3102 - val_accuracy: 0.8855\n",
      "Epoch 35/100\n",
      "3088/3088 - 2s - loss: 0.1015 - accuracy: 0.9867 - val_loss: 0.3088 - val_accuracy: 0.8860\n",
      "Epoch 36/100\n",
      "3088/3088 - 2s - loss: 0.0976 - accuracy: 0.9880 - val_loss: 0.3079 - val_accuracy: 0.8857\n",
      "Epoch 37/100\n",
      "3088/3088 - 2s - loss: 0.0932 - accuracy: 0.9890 - val_loss: 0.3070 - val_accuracy: 0.8859\n",
      "Epoch 38/100\n",
      "3088/3088 - 2s - loss: 0.0897 - accuracy: 0.9893 - val_loss: 0.3059 - val_accuracy: 0.8869\n",
      "Epoch 39/100\n",
      "3088/3088 - 2s - loss: 0.0864 - accuracy: 0.9893 - val_loss: 0.3076 - val_accuracy: 0.8830\n",
      "Epoch 40/100\n",
      "3088/3088 - 2s - loss: 0.0826 - accuracy: 0.9906 - val_loss: 0.3065 - val_accuracy: 0.8840\n",
      "Epoch 41/100\n",
      "3088/3088 - 2s - loss: 0.0799 - accuracy: 0.9906 - val_loss: 0.3038 - val_accuracy: 0.8869\n",
      "Epoch 42/100\n",
      "3088/3088 - 2s - loss: 0.0767 - accuracy: 0.9900 - val_loss: 0.3040 - val_accuracy: 0.8865\n",
      "Epoch 43/100\n",
      "3088/3088 - 2s - loss: 0.0743 - accuracy: 0.9906 - val_loss: 0.3043 - val_accuracy: 0.8847\n",
      "Epoch 44/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "3088/3088 - 2s - loss: 0.0712 - accuracy: 0.9926 - val_loss: 0.3053 - val_accuracy: 0.8845\n",
      "Epoch 00044: early stopping\n",
      "Train on 5428 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "5428/5428 - 2s - loss: 0.6912 - accuracy: 0.5748 - val_loss: 0.6873 - val_accuracy: 0.6076\n",
      "Epoch 2/100\n",
      "5428/5428 - 2s - loss: 0.6832 - accuracy: 0.6269 - val_loss: 0.6788 - val_accuracy: 0.6959\n",
      "Epoch 3/100\n",
      "5428/5428 - 2s - loss: 0.6696 - accuracy: 0.6778 - val_loss: 0.6625 - val_accuracy: 0.7322\n",
      "Epoch 4/100\n",
      "5428/5428 - 2s - loss: 0.6451 - accuracy: 0.7318 - val_loss: 0.6339 - val_accuracy: 0.7351\n",
      "Epoch 5/100\n",
      "5428/5428 - 2s - loss: 0.6055 - accuracy: 0.8139 - val_loss: 0.5945 - val_accuracy: 0.8316\n",
      "Epoch 6/100\n",
      "5428/5428 - 2s - loss: 0.5522 - accuracy: 0.8605 - val_loss: 0.5482 - val_accuracy: 0.8541\n",
      "Epoch 7/100\n",
      "5428/5428 - 2s - loss: 0.4947 - accuracy: 0.8856 - val_loss: 0.5021 - val_accuracy: 0.8603\n",
      "Epoch 8/100\n",
      "5428/5428 - 2s - loss: 0.4397 - accuracy: 0.9003 - val_loss: 0.4639 - val_accuracy: 0.8643\n",
      "Epoch 9/100\n",
      "5428/5428 - 2s - loss: 0.3931 - accuracy: 0.9147 - val_loss: 0.4353 - val_accuracy: 0.8534\n",
      "Epoch 10/100\n",
      "5428/5428 - 2s - loss: 0.3528 - accuracy: 0.9258 - val_loss: 0.4032 - val_accuracy: 0.8754\n",
      "Epoch 11/100\n",
      "5428/5428 - 2s - loss: 0.3172 - accuracy: 0.9333 - val_loss: 0.3820 - val_accuracy: 0.8773\n",
      "Epoch 12/100\n",
      "5428/5428 - 2s - loss: 0.2870 - accuracy: 0.9422 - val_loss: 0.3639 - val_accuracy: 0.8772\n",
      "Epoch 13/100\n",
      "5428/5428 - 2s - loss: 0.2632 - accuracy: 0.9464 - val_loss: 0.3494 - val_accuracy: 0.8838\n",
      "Epoch 14/100\n",
      "5428/5428 - 2s - loss: 0.2413 - accuracy: 0.9567 - val_loss: 0.3385 - val_accuracy: 0.8806\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 15/100\n",
      "5428/5428 - 2s - loss: 0.2225 - accuracy: 0.9602 - val_loss: 0.3307 - val_accuracy: 0.8843\n",
      "Epoch 16/100\n",
      "5428/5428 - 2s - loss: 0.2073 - accuracy: 0.9604 - val_loss: 0.3192 - val_accuracy: 0.8870\n",
      "Epoch 17/100\n",
      "5428/5428 - 2s - loss: 0.1908 - accuracy: 0.9661 - val_loss: 0.3148 - val_accuracy: 0.8870\n",
      "Epoch 18/100\n",
      "5428/5428 - 2s - loss: 0.1786 - accuracy: 0.9676 - val_loss: 0.3085 - val_accuracy: 0.8865\n",
      "Epoch 19/100\n",
      "5428/5428 - 2s - loss: 0.1667 - accuracy: 0.9707 - val_loss: 0.3017 - val_accuracy: 0.8893\n",
      "Epoch 20/100\n",
      "5428/5428 - 2s - loss: 0.1566 - accuracy: 0.9700 - val_loss: 0.2969 - val_accuracy: 0.8912\n",
      "Epoch 21/100\n",
      "5428/5428 - 2s - loss: 0.1460 - accuracy: 0.9762 - val_loss: 0.2935 - val_accuracy: 0.8918\n",
      "Epoch 22/100\n",
      "5428/5428 - 2s - loss: 0.1371 - accuracy: 0.9779 - val_loss: 0.2900 - val_accuracy: 0.8928\n",
      "Epoch 23/100\n",
      "5428/5428 - 2s - loss: 0.1309 - accuracy: 0.9735 - val_loss: 0.3042 - val_accuracy: 0.8763\n",
      "Epoch 24/100\n",
      "5428/5428 - 2s - loss: 0.1224 - accuracy: 0.9790 - val_loss: 0.2864 - val_accuracy: 0.8932\n",
      "Epoch 25/100\n",
      "5428/5428 - 2s - loss: 0.1153 - accuracy: 0.9814 - val_loss: 0.2866 - val_accuracy: 0.8914\n",
      "Epoch 26/100\n",
      "5428/5428 - 2s - loss: 0.1093 - accuracy: 0.9818 - val_loss: 0.2837 - val_accuracy: 0.8932\n",
      "Epoch 27/100\n",
      "5428/5428 - 2s - loss: 0.1037 - accuracy: 0.9831 - val_loss: 0.2816 - val_accuracy: 0.8940\n",
      "Epoch 28/100\n",
      "5428/5428 - 2s - loss: 0.0983 - accuracy: 0.9836 - val_loss: 0.2815 - val_accuracy: 0.8939\n",
      "Epoch 29/100\n",
      "5428/5428 - 2s - loss: 0.0939 - accuracy: 0.9842 - val_loss: 0.2839 - val_accuracy: 0.8921\n",
      "Epoch 30/100\n",
      "5428/5428 - 2s - loss: 0.0891 - accuracy: 0.9854 - val_loss: 0.2802 - val_accuracy: 0.8936\n",
      "Epoch 31/100\n",
      "5428/5428 - 2s - loss: 0.0844 - accuracy: 0.9866 - val_loss: 0.2802 - val_accuracy: 0.8943\n",
      "Epoch 32/100\n",
      "5428/5428 - 2s - loss: 0.0808 - accuracy: 0.9884 - val_loss: 0.2798 - val_accuracy: 0.8933\n",
      "Epoch 33/100\n",
      "5428/5428 - 2s - loss: 0.0761 - accuracy: 0.9893 - val_loss: 0.2847 - val_accuracy: 0.8920\n",
      "Epoch 34/100\n",
      "5428/5428 - 2s - loss: 0.0737 - accuracy: 0.9895 - val_loss: 0.2841 - val_accuracy: 0.8925\n",
      "Epoch 35/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "5428/5428 - 2s - loss: 0.0694 - accuracy: 0.9912 - val_loss: 0.2809 - val_accuracy: 0.8946\n",
      "Epoch 00035: early stopping\n",
      "Train on 9540 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "9540/9540 - 3s - loss: 0.6895 - accuracy: 0.5633 - val_loss: 0.6828 - val_accuracy: 0.6000\n",
      "Epoch 2/100\n",
      "9540/9540 - 3s - loss: 0.6726 - accuracy: 0.6623 - val_loss: 0.6575 - val_accuracy: 0.6876\n",
      "Epoch 3/100\n",
      "9540/9540 - 3s - loss: 0.6297 - accuracy: 0.7672 - val_loss: 0.5986 - val_accuracy: 0.8112\n",
      "Epoch 4/100\n",
      "9540/9540 - 3s - loss: 0.5511 - accuracy: 0.8309 - val_loss: 0.5189 - val_accuracy: 0.8542\n",
      "Epoch 5/100\n",
      "9540/9540 - 3s - loss: 0.4627 - accuracy: 0.8804 - val_loss: 0.4487 - val_accuracy: 0.8718\n",
      "Epoch 6/100\n",
      "9540/9540 - 3s - loss: 0.3893 - accuracy: 0.9025 - val_loss: 0.3991 - val_accuracy: 0.8674\n",
      "Epoch 7/100\n",
      "9540/9540 - 3s - loss: 0.3351 - accuracy: 0.9119 - val_loss: 0.3613 - val_accuracy: 0.8843\n",
      "Epoch 8/100\n",
      "9540/9540 - 3s - loss: 0.2929 - accuracy: 0.9230 - val_loss: 0.3367 - val_accuracy: 0.8897\n",
      "Epoch 9/100\n",
      "9540/9540 - 3s - loss: 0.2620 - accuracy: 0.9332 - val_loss: 0.3175 - val_accuracy: 0.8941\n",
      "Epoch 10/100\n",
      "9540/9540 - 3s - loss: 0.2340 - accuracy: 0.9443 - val_loss: 0.3032 - val_accuracy: 0.8947\n",
      "Epoch 11/100\n",
      "9540/9540 - 3s - loss: 0.2123 - accuracy: 0.9501 - val_loss: 0.2957 - val_accuracy: 0.8922\n",
      "Epoch 12/100\n",
      "9540/9540 - 3s - loss: 0.1938 - accuracy: 0.9545 - val_loss: 0.2845 - val_accuracy: 0.8995\n",
      "Epoch 13/100\n",
      "9540/9540 - 3s - loss: 0.1779 - accuracy: 0.9591 - val_loss: 0.2773 - val_accuracy: 0.9000\n",
      "Epoch 14/100\n",
      "9540/9540 - 3s - loss: 0.1643 - accuracy: 0.9633 - val_loss: 0.2734 - val_accuracy: 0.9015\n",
      "Epoch 15/100\n",
      "9540/9540 - 3s - loss: 0.1520 - accuracy: 0.9643 - val_loss: 0.2676 - val_accuracy: 0.9037\n",
      "Epoch 16/100\n",
      "9540/9540 - 3s - loss: 0.1409 - accuracy: 0.9674 - val_loss: 0.2650 - val_accuracy: 0.9042\n",
      "Epoch 17/100\n",
      "9540/9540 - 3s - loss: 0.1321 - accuracy: 0.9697 - val_loss: 0.2629 - val_accuracy: 0.9042\n",
      "Epoch 18/100\n",
      "9540/9540 - 3s - loss: 0.1226 - accuracy: 0.9723 - val_loss: 0.2611 - val_accuracy: 0.9051\n",
      "Epoch 19/100\n",
      "9540/9540 - 3s - loss: 0.1147 - accuracy: 0.9744 - val_loss: 0.2605 - val_accuracy: 0.9048\n",
      "Epoch 20/100\n",
      "9540/9540 - 3s - loss: 0.1072 - accuracy: 0.9759 - val_loss: 0.2610 - val_accuracy: 0.9034\n",
      "Epoch 21/100\n",
      "9540/9540 - 3s - loss: 0.1026 - accuracy: 0.9771 - val_loss: 0.2602 - val_accuracy: 0.9058\n",
      "Epoch 22/100\n",
      "9540/9540 - 3s - loss: 0.0946 - accuracy: 0.9786 - val_loss: 0.2604 - val_accuracy: 0.9056\n",
      "Epoch 23/100\n",
      "9540/9540 - 3s - loss: 0.0905 - accuracy: 0.9804 - val_loss: 0.2611 - val_accuracy: 0.9042\n",
      "Epoch 24/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "9540/9540 - 3s - loss: 0.0850 - accuracy: 0.9820 - val_loss: 0.2640 - val_accuracy: 0.9026\n",
      "Epoch 00024: early stopping\n",
      "Train on 16768 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "16768/16768 - 5s - loss: 0.6862 - accuracy: 0.5997 - val_loss: 0.6722 - val_accuracy: 0.6364\n",
      "Epoch 2/100\n",
      "16768/16768 - 5s - loss: 0.6381 - accuracy: 0.7357 - val_loss: 0.5859 - val_accuracy: 0.8167\n",
      "Epoch 3/100\n",
      "16768/16768 - 5s - loss: 0.5175 - accuracy: 0.8530 - val_loss: 0.4619 - val_accuracy: 0.8683\n",
      "Epoch 4/100\n",
      "16768/16768 - 5s - loss: 0.4015 - accuracy: 0.8854 - val_loss: 0.3796 - val_accuracy: 0.8880\n",
      "Epoch 5/100\n",
      "16768/16768 - 5s - loss: 0.3248 - accuracy: 0.9070 - val_loss: 0.3318 - val_accuracy: 0.8941\n",
      "Epoch 6/100\n",
      "16768/16768 - 5s - loss: 0.2729 - accuracy: 0.9234 - val_loss: 0.3005 - val_accuracy: 0.9022\n",
      "Epoch 7/100\n",
      "16768/16768 - 5s - loss: 0.2367 - accuracy: 0.9339 - val_loss: 0.2795 - val_accuracy: 0.9052\n",
      "Epoch 8/100\n",
      "16768/16768 - 5s - loss: 0.2088 - accuracy: 0.9406 - val_loss: 0.2655 - val_accuracy: 0.9081\n",
      "Epoch 9/100\n",
      "16768/16768 - 5s - loss: 0.1863 - accuracy: 0.9491 - val_loss: 0.2588 - val_accuracy: 0.9071\n",
      "Epoch 10/100\n",
      "16768/16768 - 5s - loss: 0.1682 - accuracy: 0.9530 - val_loss: 0.2494 - val_accuracy: 0.9107\n",
      "Epoch 11/100\n",
      "16768/16768 - 5s - loss: 0.1538 - accuracy: 0.9570 - val_loss: 0.2465 - val_accuracy: 0.9105\n",
      "Epoch 12/100\n",
      "16768/16768 - 5s - loss: 0.1392 - accuracy: 0.9631 - val_loss: 0.2431 - val_accuracy: 0.9116\n",
      "Epoch 13/100\n",
      "16768/16768 - 5s - loss: 0.1277 - accuracy: 0.9654 - val_loss: 0.2410 - val_accuracy: 0.9123\n",
      "Epoch 14/100\n",
      "16768/16768 - 5s - loss: 0.1176 - accuracy: 0.9687 - val_loss: 0.2412 - val_accuracy: 0.9122\n",
      "Epoch 15/100\n",
      "16768/16768 - 5s - loss: 0.1092 - accuracy: 0.9719 - val_loss: 0.2510 - val_accuracy: 0.9063\n",
      "Epoch 16/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "16768/16768 - 5s - loss: 0.1005 - accuracy: 0.9739 - val_loss: 0.2438 - val_accuracy: 0.9118\n",
      "Epoch 00016: early stopping\n",
      "Train on 29471 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "29471/29471 - 8s - loss: 0.6776 - accuracy: 0.6338 - val_loss: 0.6374 - val_accuracy: 0.7936\n",
      "Epoch 2/100\n",
      "29471/29471 - 8s - loss: 0.5401 - accuracy: 0.8292 - val_loss: 0.4416 - val_accuracy: 0.8761\n",
      "Epoch 3/100\n",
      "29471/29471 - 8s - loss: 0.3727 - accuracy: 0.8893 - val_loss: 0.3341 - val_accuracy: 0.8986\n",
      "Epoch 4/100\n",
      "29471/29471 - 8s - loss: 0.2867 - accuracy: 0.9133 - val_loss: 0.2849 - val_accuracy: 0.9080\n",
      "Epoch 5/100\n",
      "29471/29471 - 8s - loss: 0.2378 - accuracy: 0.9254 - val_loss: 0.2589 - val_accuracy: 0.9123\n",
      "Epoch 6/100\n",
      "29471/29471 - 8s - loss: 0.2046 - accuracy: 0.9368 - val_loss: 0.2464 - val_accuracy: 0.9116\n",
      "Epoch 7/100\n",
      "29471/29471 - 8s - loss: 0.1811 - accuracy: 0.9434 - val_loss: 0.2348 - val_accuracy: 0.9171\n",
      "Epoch 8/100\n",
      "29471/29471 - 8s - loss: 0.1612 - accuracy: 0.9505 - val_loss: 0.2322 - val_accuracy: 0.9161\n",
      "Epoch 9/100\n",
      "29471/29471 - 8s - loss: 0.1459 - accuracy: 0.9556 - val_loss: 0.2315 - val_accuracy: 0.9142\n",
      "Epoch 10/100\n",
      "29471/29471 - 8s - loss: 0.1327 - accuracy: 0.9582 - val_loss: 0.2320 - val_accuracy: 0.9157\n",
      "Epoch 11/100\n",
      "29471/29471 - 8s - loss: 0.1210 - accuracy: 0.9627 - val_loss: 0.2318 - val_accuracy: 0.9160\n",
      "Epoch 12/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "29471/29471 - 8s - loss: 0.1109 - accuracy: 0.9671 - val_loss: 0.2320 - val_accuracy: 0.9170\n",
      "Epoch 00012: early stopping\n",
      "Train on 51795 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "51795/51795 - 14s - loss: 0.6408 - accuracy: 0.6914 - val_loss: 0.5126 - val_accuracy: 0.8314\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/100\n",
      "51795/51795 - 14s - loss: 0.3954 - accuracy: 0.8777 - val_loss: 0.3151 - val_accuracy: 0.8981\n",
      "Epoch 3/100\n",
      "51795/51795 - 14s - loss: 0.2725 - accuracy: 0.9115 - val_loss: 0.2590 - val_accuracy: 0.9077\n",
      "Epoch 4/100\n",
      "51795/51795 - 14s - loss: 0.2199 - accuracy: 0.9262 - val_loss: 0.2357 - val_accuracy: 0.9151\n",
      "Epoch 5/100\n",
      "51795/51795 - 14s - loss: 0.1893 - accuracy: 0.9361 - val_loss: 0.2212 - val_accuracy: 0.9206\n",
      "Epoch 6/100\n",
      "51795/51795 - 14s - loss: 0.1670 - accuracy: 0.9442 - val_loss: 0.2190 - val_accuracy: 0.9190\n",
      "Epoch 7/100\n",
      "51795/51795 - 14s - loss: 0.1510 - accuracy: 0.9494 - val_loss: 0.2166 - val_accuracy: 0.9205\n",
      "Epoch 8/100\n",
      "51795/51795 - 14s - loss: 0.1377 - accuracy: 0.9546 - val_loss: 0.2665 - val_accuracy: 0.8949\n",
      "Epoch 9/100\n",
      "51795/51795 - 14s - loss: 0.1273 - accuracy: 0.9573 - val_loss: 0.2223 - val_accuracy: 0.9209\n",
      "Epoch 10/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "51795/51795 - 14s - loss: 0.1170 - accuracy: 0.9612 - val_loss: 0.2276 - val_accuracy: 0.9198\n",
      "Epoch 00010: early stopping\n",
      "Train on 91032 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "91032/91032 - 24s - loss: 0.5629 - accuracy: 0.7635 - val_loss: 0.3583 - val_accuracy: 0.8969\n",
      "Epoch 2/100\n",
      "91032/91032 - 24s - loss: 0.2873 - accuracy: 0.9055 - val_loss: 0.2439 - val_accuracy: 0.9169\n",
      "Epoch 3/100\n",
      "91032/91032 - 24s - loss: 0.2139 - accuracy: 0.9260 - val_loss: 0.2234 - val_accuracy: 0.9179\n",
      "Epoch 4/100\n",
      "91032/91032 - 24s - loss: 0.1820 - accuracy: 0.9354 - val_loss: 0.2112 - val_accuracy: 0.9235\n",
      "Epoch 5/100\n",
      "91032/91032 - 24s - loss: 0.1630 - accuracy: 0.9415 - val_loss: 0.2069 - val_accuracy: 0.9253\n",
      "Epoch 6/100\n",
      "91032/91032 - 24s - loss: 0.1496 - accuracy: 0.9458 - val_loss: 0.2094 - val_accuracy: 0.9256\n",
      "Epoch 7/100\n",
      "91032/91032 - 24s - loss: 0.1387 - accuracy: 0.9505 - val_loss: 0.2180 - val_accuracy: 0.9226\n",
      "Epoch 8/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "91032/91032 - 24s - loss: 0.1298 - accuracy: 0.9537 - val_loss: 0.2242 - val_accuracy: 0.9220\n",
      "Epoch 00008: early stopping\n",
      "Train on 159993 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "159993/159993 - 41s - loss: 0.4623 - accuracy: 0.8166 - val_loss: 0.2683 - val_accuracy: 0.9099\n",
      "Epoch 2/100\n",
      "159993/159993 - 41s - loss: 0.2257 - accuracy: 0.9202 - val_loss: 0.2206 - val_accuracy: 0.9173\n",
      "Epoch 3/100\n",
      "159993/159993 - 41s - loss: 0.1851 - accuracy: 0.9325 - val_loss: 0.2031 - val_accuracy: 0.9262\n",
      "Epoch 4/100\n",
      "159993/159993 - 41s - loss: 0.1672 - accuracy: 0.9385 - val_loss: 0.2005 - val_accuracy: 0.9288\n",
      "Epoch 5/100\n",
      "159993/159993 - 41s - loss: 0.1557 - accuracy: 0.9427 - val_loss: 0.2096 - val_accuracy: 0.9246\n",
      "Epoch 6/100\n",
      "159993/159993 - 41s - loss: 0.1476 - accuracy: 0.9454 - val_loss: 0.2082 - val_accuracy: 0.9271\n",
      "Epoch 7/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "159993/159993 - 41s - loss: 0.1415 - accuracy: 0.9480 - val_loss: 0.2140 - val_accuracy: 0.9246\n",
      "Epoch 00007: early stopping\n"
     ]
    }
   ],
   "source": [
    "sizes = [int(p) for p in np.geomspace(1000, 160000, 10)]\n",
    "preprocessor = SequencePreprocessor(MAX_NB_WORDS, MAX_LENGTH_SEQ)\n",
    "\n",
    "test_accuracies = accuracy_vs_training_data(\n",
    "    model, initial_weights, \n",
    "    preprocessor, sizes,\n",
    "    train_reviews, train_labels,\n",
    "    val_reviews, val_labels,\n",
    "    test_reviews, test_labels\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "OUTPUT_PATH = 'data/word-vectors/fasttext_accuracies.pickle'\n",
    "\n",
    "output_dict = {\n",
    "    \"sizes\": sizes,\n",
    "    \"test_accuracies\": test_accuracies\n",
    "}\n",
    "\n",
    "with open(OUTPUT_PATH, 'wb') as writer:\n",
    "    pickle.dump(output_dict, writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/fasttext_weights.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "inference_times = []\n",
    "\n",
    "for i in range(1000):\n",
    "    x = np.array([X_test[i], ])\n",
    "    start_time = time.time()\n",
    "    y_pred = model.predict(x)\n",
    "    stop_time = time.time()\n",
    "    \n",
    "    inference_times.append(stop_time - start_time)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "OUTPUT_PATH = 'data/word-vectors/fasttext_times.pickle'\n",
    "\n",
    "with open(OUTPUT_PATH, 'wb') as writer:\n",
    "    pickle.dump(inference_times, writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generalizability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> Folder: data/cls-acl10-unprocessed/fr/books\n",
      "  Len Train: 2000. Len Test: 2000.\n",
      "> Folder: data/cls-acl10-unprocessed/fr/dvd\n",
      "  Len Train: 2000. Len Test: 2000.\n",
      "> Folder: data/cls-acl10-unprocessed/fr/music\n",
      "  Len Train: 2000. Len Test: 2000.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from utils_acl import get_data\n",
    "\n",
    "ACL_FOLDER = 'data/cls-acl10-unprocessed/fr'\n",
    "BOOKS_FOLDER = os.path.join(ACL_FOLDER, 'books')\n",
    "DVD_FOLDER = os.path.join(ACL_FOLDER, 'dvd')\n",
    "MUSIC_FOLDER = os.path.join(ACL_FOLDER, 'music')\n",
    "\n",
    "_, _, test_reviews_b, test_labels_b = get_data(BOOKS_FOLDER)\n",
    "_, _, test_reviews_d, test_labels_d  = get_data(DVD_FOLDER)\n",
    "_, _, test_reviews_m, test_labels_m  = get_data(MUSIC_FOLDER)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn import metrics \n",
    "\n",
    "def evaluate(model, X, y):\n",
    "    probas = model.predict(X)\n",
    "    y_pred = (probas > 0.5).astype(np.int)  \n",
    "    print(\"Accuracy: {:.2f}\".format(100 * metrics.accuracy_score(y, y_pred)))\n",
    "    print(\"F1-Score: {:.2f}\".format(100 * metrics.f1_score(y, y_pred)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "preprocessor = SequencePreprocessor(MAX_NB_WORDS, MAX_LENGTH_SEQ)\n",
    "preprocessor.fit(train_reviews)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Books"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/fasttext_weights.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 85.25\n",
      "F1-Score: 85.23\n"
     ]
    }
   ],
   "source": [
    "X_books, y_books = preprocessor.transform(test_reviews_b, test_labels_b)\n",
    "evaluate(model, X_books, y_books)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DVD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 87.10\n",
      "F1-Score: 87.45\n"
     ]
    }
   ],
   "source": [
    "X_dvd, y_dvd = preprocessor.transform(test_reviews_d, test_labels_d)\n",
    "evaluate(model, X_dvd, y_dvd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Music"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 86.65\n",
      "F1-Score: 86.94\n"
     ]
    }
   ],
   "source": [
    "X_music, y_music = preprocessor.transform(test_reviews_m, test_labels_m)\n",
    "evaluate(model, X_music, y_music)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# RNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Embedding, GRU, Dense\n",
    "\n",
    "# Hyperparameters\n",
    "embedding_dim = 128\n",
    "hidden_dim = 256\n",
    "\n",
    "model = Sequential(name='rnn')\n",
    "model.add(Embedding(MAX_NB_WORDS, embedding_dim,\n",
    "                    mask_zero=True, input_shape=[None]))\n",
    "\n",
    "model.add(GRU(hidden_dim, return_sequences=True))\n",
    "model.add(GRU(hidden_dim))\n",
    "model.add(Dense(1, activation=\"sigmoid\"))\n",
    "\n",
    "model.compile(\n",
    "    loss=\"binary_crossentropy\",\n",
    "    optimizer=\"adam\",\n",
    "    metrics=[\"accuracy\"]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"rnn\"\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_1 (Embedding)      (None, None, 128)         2560000   \n",
      "_________________________________________________________________\n",
      "gru_2 (GRU)                  (None, None, 256)         296448    \n",
      "_________________________________________________________________\n",
      "gru_3 (GRU)                  (None, 256)               394752    \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 1)                 257       \n",
      "=================================================================\n",
      "Total params: 3,251,457\n",
      "Trainable params: 3,251,457\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "initial_weights = model.get_weights()\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 159993 samples, validate on 19999 samples\n",
      "Epoch 1/5\n",
      "159936/159993 [============================>.] - ETA: 0s - loss: 0.2248 - accuracy: 0.9084\n",
      "Epoch 00001: val_loss improved from inf to 0.15295, saving model to data/word-vectors/rnn_weights.hdf5\n",
      "159993/159993 [==============================] - 135s 842us/sample - loss: 0.2248 - accuracy: 0.9084 - val_loss: 0.1530 - val_accuracy: 0.9412\n",
      "Epoch 2/5\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.1247 - accuracy: 0.9537\n",
      "Epoch 00002: val_loss did not improve from 0.15295\n",
      "159993/159993 [==============================] - 129s 809us/sample - loss: 0.1247 - accuracy: 0.9537 - val_loss: 0.1543 - val_accuracy: 0.9441\n",
      "Epoch 3/5\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.0871 - accuracy: 0.9689\n",
      "Epoch 00003: val_loss did not improve from 0.15295\n",
      "159993/159993 [==============================] - 130s 811us/sample - loss: 0.0871 - accuracy: 0.9689 - val_loss: 0.1564 - val_accuracy: 0.9407\n",
      "Epoch 4/5\n",
      "159936/159993 [============================>.] - ETA: 0s - loss: 0.0586 - accuracy: 0.9797\n",
      "Epoch 00004: val_loss did not improve from 0.15295\n",
      "159993/159993 [==============================] - 132s 826us/sample - loss: 0.0586 - accuracy: 0.9797 - val_loss: 0.1974 - val_accuracy: 0.9371\n",
      "Epoch 5/5\n",
      "159936/159993 [============================>.] - ETA: 0s - loss: 0.0384 - accuracy: 0.9871\n",
      "Epoch 00005: val_loss did not improve from 0.15295\n",
      "159993/159993 [==============================] - 130s 811us/sample - loss: 0.0384 - accuracy: 0.9871 - val_loss: 0.2200 - val_accuracy: 0.9324\n"
     ]
    }
   ],
   "source": [
    "checkpointer = tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath='data/word-vectors/rnn_weights.hdf5',\n",
    "    save_best_only=True, verbose=1\n",
    ")\n",
    "\n",
    "history = model.fit(\n",
    "    X_train, y_train,\n",
    "    validation_data=(X_val, y_val),\n",
    "    epochs=5, batch_size=64, \n",
    "    callbacks=[checkpointer], verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAFSCAYAAADMwC8yAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeVxU9f748dcs7DDILiAugLiB+4rmnqZgbre0Um9pmZG2XbuV3m/dm93Uey2t/LXdyiW72WKS4pZLSi5Z4oYLJSqCqICADPsMM+f3Bzo3BBUUHBjez8fDR8xnPufM+3yC+cx73ud8jkpRFAUhhBBCCCGEEBZqawcghBBCCCGEEPWNJEpCCCGEEEIIcR1JlIQQQgghhBDiOpIoCSGEEEIIIcR1JFESQgghhBBCiOtIoiSEEEIIIYQQ15FESYg71KZNG957770ab3f+/HnatGnDd999VwdRCSGEELXrbsx3t/saQtQFSZSETfjuu+9o06YNbdq04cCBA1X2uffee2nTpg2TJ0++y9EJIYQQtUPmOyHuHkmUhE1xcHBg/fr1ldoPHz5MamoqDg4OVohKCCGEqF0y3wlR9yRREjZlwIABbN68GaPRWKE9Li6O4OBgmjdvbqXIGg+TyYTBYLB2GEIIYdNkvhOi7kmiJGxKVFQUeXl57N6929JmMpnYuHEj0dHRVW5TXFzMwoULGThwIOHh4QwbNoyPP/4Ys9lcoZ/BYODNN9+kd+/edOnShRkzZnDp0qUq95mZmcncuXPp27cv4eHhjBgxgv/+97+3fVyfffYZDz30EL169SIiIoJRo0bxzTffVNl3z549TJkyha5du9KlSxfGjRtXqW9iYiIzZsygZ8+edOrUiejoaD766CPL85MnT67ylI2XX36ZwYMHWx5fO+/8448/ZtWqVQwbNoyIiAgOHTpUq3EvXryYDh06kJ2dXWm7+fPnExERgV6vv8UoCiGE7bDV+a4q58+f57nnnqNXr1507NiR8ePHs23btkr9vvjiC0aNGkXnzp3p1q0bo0ePZvXq1ZbnCwsLWbhwIYMHDyY8PJzevXszefJkfv3111qNV9gOrbUDEKI2NW3alO7duxMXF8egQYMA2Lt3L9nZ2YwaNYpNmzZV6K8oCk8//TR79uxh/PjxdOjQgZ9//pm33nqL8+fP8/rrr1v6zp07l3Xr1hEdHU3Xrl3Zv38/06dPrxRDdnY2EyZMwGQy8dBDD+Hl5cW+ffv4xz/+wZUrV4iJianxcS1fvpyBAwcyYsQIVCoV27dv529/+xtlZWU89NBDln6xsbG8/PLLhISE8Pjjj9OkSRN+++03du7cyQMPPADAvn37mD59Ol5eXkyaNAlfX1/Onj3Ljh07ePLJJ2scG8D3339PcXExDz74IC4uLvj4+NRq3GPGjOHDDz9kw4YNTJkyxbKdyWRiw4YNDBo0CJ1Od1uxCyFEQ2Sr811VrzFx4kQKCwuZMmUKHh4erFu3jpkzZ7Jo0SJLUvjNN9/w+uuvM3z4cB555BHKyso4deoUhw4dYuLEiQD8/e9/Z9OmTTzyyCOEhoai1+s5cuQISUlJ9OjR445jFTZIEcIGrFmzRgkLC1MOHTqkfPnll0qnTp2UwsJCRVEU5cUXX1QeeOABRVEUJSoqSpk0aZJlu23btilhYWHKe++9V2F/L7/8shIWFqb89ttviqIoysmTJ5WwsDDltddeq9DvxRdfVMLCwpR3333X0va3v/1NiYyMVLKzsyv0nTt3rtKxY0clLy9PURRFSUtLU8LCwpQ1a9bc8viKiooqtT322GPK0KFDLY/z8/OVrl27KmPHjlWKi4sr9DWbzYqiKIrJZFKGDBmi9O/fX8nNza2yj6IoyqRJkyqM0zUvvfSSMmjQIMvja8fQuXNnJSMjo87iVhRFeeCBB5Tx48dXeP6nn35SwsLClG3btlV6HSGEsEW2Pt9d/xpvvvmmEhYWpvz888+WtuLiYmXEiBFK3759FYPBoCiKosTExChRUVE33Xf37t2Vf/zjH7eMQYhr5NQ7YXPuu+8+ysrK2LZtGyUlJWzbto1Ro0ZV2XfXrl2o1eoKVQqAxx57DICdO3da+gFMmjSpQr/rT09TFIUtW7YwYMAAAHJyciz/+vbtS0lJCUeOHKnxMTk5OQFgNBq5cuUKOTk59OrVi9TUVPLz8wHYvXs3BQUFTJ8+HUdHxwrbq1QqAI4fP05aWhpTpkyhSZMmVfa5HUOGDMHX17fO4gYYM2YMiYmJnDlzxtK2bt06mjRpQv/+/W87diGEaKhscb673s6dO+nQoQO9evWytDk6OvLwww+TlZXFiRMnAHBzc+PSpUscPXr0hvtyc3PjyJEjZGRk3HFconGQU++EzWnSpAn9+vVj/fr1aLVaSkpKGDlyZJV909PT8fLyqnTaVqtWrVCr1aSnp1v6qVSqShfHtmrVqsLjnJwc8vLyWLNmDWvWrKnyNau6zuZWtm3bxvvvv09SUhImk6nCc/n5+bi5uZGamgpA69atb7iftLS0W/a5HTe6aLi24oby8/Hnz5/PunXreO655yguLmbr1q2MHTsWOzu72jkQIYRoQGxxvrvehQsXGDZsWKX2kJAQS7ydOnXiiSeeYN++fTzwwAMEBQURGRnJyJEj6d27t2WbF198kZdffpmBAwfSrl077rnnHkaPHk1wcPAdxylskyRKwiZFR0fz0ksvUVBQQJ8+ffDy8rorr3vtgtjo6GjGjx9fZZ/Q0NAa7fPAgQPMnDmTbt268Y9//ANfX1/s7OzYtWsXy5cvr3QRbl26Ptm55vpKENR+3O7u7gwaNIj169fz7LPPsm3bNoqKihg9evRtHYsQQtgCW5rv7kRISAibN29m165d7N69m507d/LVV1/x8MMP89prrwEwYsQIunfvzvbt29mzZw+ff/45n376KfPnz79hJU40bpIoCZs0ZMgQ7O3tOXjwIAsXLrxhv8DAQPbu3WupblyTkpKC2WwmMDDQ0k9RFFJTUyu88Z89e7bC/jw9PXFxcaGsrIzIyMhaOZYtW7bg4ODAZ599VuG+GPv376/Q79q3f6dOnbJ803a9oKAgS5+bna7m7u5uqT790YULF6wS9zVjxoxhy5YtJCQksG7dOlq2bEmnTp2qHZMQQtgaW5rvqhIQEFDptQHLadjX4oby073vu+8+yymJL7/8Mv/973+ZMWMGfn5+APj4+DBx4kQmTpyIXq/nwQcf5L333pNESVRJrlESNsnJyYnXXnuNmTNnMnTo0Bv2GzhwIGazmZUrV1ZoX7ZsmeV5wJJUrFq1qkK/6x9rNBqGDx/O9u3bSUpKqvR6OTk5NT4WjUaDSqWqUIG5drrDH/Xr1w9XV1c+/vhjSkpKKjynKAoAHTp0ICgoiJUrV3LlypUq+0B5QnXmzJkK8SYlJXHw4EGrxH1N//798fLyYvny5ezdu1eqSUKIRs+W5ruqDBo0iOPHj3PgwAFLW2lpKV9++SU+Pj506NABgNzc3ArbabVawsLCANDr9ZhMJsu1sdfodDqaNWsmt5cQNyQVJWGzxowZc8s+gwYNom/fvrz33ntcuHCB9u3bs3//frZs2cKECRMsb7Lt2rUjOjqaL7/8kvz8fMtyqSkpKZX2OXv2bH755RcmTJjAAw88QOvWrcnLyyMpKYmtW7eSmJhYo+MYNGgQy5Yt47HHHmP06NHk5eXx9ddf4+3tTVZWlqWfq6src+fOZc6cOYwfP57o6GiaNGlCcnIyGRkZLF26FLVazT/+8Q+efPJJxowZw/jx4/H19eXcuXMcPHjQcr+JP/3pTyxfvpxp06bxpz/9iezsbFavXk1oaCiFhYV3Pe5rtFotUVFRrFy5EpVKxf3331+jsRRCCFtkK/NdVZ544gni4uKYPn06kydPxtPTk3Xr1pGcnMyiRYvQass/yk6bNg1PT0+6deuGt7c3qamprFq1ijZt2hASEkJBQQH9+/dn2LBhtG3bFldXVw4ePMhPP/1UaeEKIa6RREk0aiqViqVLl/Lee++xYcMGvv/+e/z9/XnhhRd4/PHHK/R988038fDwYP369ezYsYNevXrx8ccfW1b8ucbLy4tvvvmG999/n+3bt7N69Wrc3d0JDg7m5ZdfrnGMvXr1YuHChXz00Ue8+eabNG3alMmTJ6PT6ZgzZ06FvuPGjcPLy4uPPvqIjz76CLVaTcuWLXnkkUcsffr27cvnn3/O0qVLWbZsGWazmaCgoAqnHYSEhLBw4ULeffdd5s+fT2hoKP/617+Ii4vjl19+sUrc14wdO5aVK1fSrVs3mjVrVpOhFEKIRqshzHdV8fLy4ssvv2TRokV8+eWXFBcX07p1a9577z3uvfdeS78JEyYQFxfHihUrKCgowNfXl/Hjx/PUU0+hVqstK+Xt3buXHTt2UFZWRrNmzXjppZcqrQQoxDUq5fpzW4QQoh47deoU0dHRzJs3jwcffNDa4QghhBDCRsk1SkKIBuXrr7/G0dGRESNGWDsUIYQQQtgwOfVOCNEg7Nixg9OnT/Pll18yYcKECqs2CSGEEELUNjn1TgjRIAwePJjLly8TGRnJv//9b0mUhBBCCFGnJFESQgghhBBCiOvINUq3oCgKpaWlle7nIoQQQliLzE1CCFH3JFG6BYPBwLFjxzAYDLe1/fHjx2s5ItsnY1ZzMma3R8at5mTM6geZm+4+GbOakzGrORmzmqvLMZNEqY6VlJRYO4QGR8as5mTMbo+MW83JmNkG+f9YczJmNSdjVnMyZjVXl2MmiZIQQgghhBBCXEcSJSGEEEIIIYS4jiRKQgghhBBCCHEdSZSEEEIIIYQQ4jqSKAkhhBBCCCHEdSRREkIIIYQQQojraK0dgK3Q6/VkZmZiNBortGu1Wk6ePGmlqBqmW42ZnZ0dvr6+6HS6uxiVEEI0PDI31R6Zm4RofCRRqgV6vZ6MjAwCAwNxcnJCpVJZnissLMTFxcWK0TU8NxszRVEoLi4mPT0dQCYkIYS4AZmbapfMTUI0PnLqXS3IzMwkMDAQZ2fnChORqH0qlQpnZ2cCAwPJzMy0djhCCFFvydx098jcJIRtkopSLTAajTg5OVk7jEbFycmp0qkkQojal5VbTEJSBgd/yyT5/BXG9HSjm7WDEtVyo7mpoNhAtr4MRyczGrV8X1qbZG4SwrZIolRL5Nu6u0vGW4i6YSwzc+JsNglJmSQkZZB6KR8A7yZO9Gjnh5fOYOUIRU1U9V6pVasxlCnk6EvxaSJf8tUmmZuEsC2SKAkhRCOXmVtUnhidzOBochbFpSa0GhUdgr0Y2qM53dr6EuTnhkqlIiEhwdrhijvk6KDFxUFNXn4pOmc7HOzlo4AQQlRF3h0FAG3atLlln5kzZzJr1qw7ep34+HieeOIJ1q9fT1hY2B3tSwhxe4xlJk6cyeFAUgYJSZmkZZRXjXw9nBjYNYhubX3p2NoHJweZImyVm7OGEqNCZm4xzXxd620lROYmIYQ1ySwoAPjqq68qPJ4wYQKTJ08mOjra0ta0adM7fp0uXbrw1Vdf0bx58zvelxCi+jJziki4mhgdOZVFicGEVqMmPNiLYb2a062tX73+wCxql1oF3k0cycgpRl9owN3VwdohVUnmJiGENUmiJADo3LlzpTZ/f/8q269XUlKCo6NjtV7Hzc2tWvsUQtwZY5mJY6f/d63R+cwCAHw9nRnUPYjubf2ICPWWqlEj5uZsj77QQHZeCS5Odmg19W9hB5mbhBDWJDOkqJHTp08zcuRI3nrrLfbt28e2bdvw8fEhLi6OHTt2sHLlSn777TdKS0sJDg5m5syZDBw40LL99ac3lJaW0rFjR+bMmUNubi5ff/01ZWVlDBgwgNdeew1XV1frHawQDcyl7EJLYnQ0+TKl16pGIV4M792Sbm19pWokLFQqFT4ezqRdyic7rwQ/T2drh3TbZG4SonFRTGUUnT5EQeIudCnHKQt7G62bR62/jiRK4rYsWLCAQYMG8dZbb2EymQA4f/48Q4YMYdq0aajVauLj45kxYwbLli2jT58+N93f8uXL6datGwsWLCA5OZklS5bg5ubGq6++ejcOR4gGyWA0cexMdvkpdSczSc8qrxr5eTozpHsQ3dr50THEG0epGokbcLDT0MTNgdz8UnQu9g2+wihzkxC2S1EUDBlnyT+6k4LjP2Eu0qN21mH0b4/GpW5u8tyw3xGF1YSHhzNv3rwKbVOmTLH8bDab6dWrF2fPnmX16tW3nIyaNm3KokWLAOjWrRspKSls2bJFJiMhrnMpu5CEkxkcSMok8XR51chOW36t0YjI8qpRoI9UjUT1eeocKSgykJVbZFndsKGSuUkI21OWn0PBsXjyE3dhzEoFjRaX1j1wjRiAc0gXDh4+gkqtqZPXlkSpjuw4kMrWX1IxmUxoNHXzP+9m7u3ZnMHd6+6i1CFDhlRqS09PZ/Hixezfv5+srCwURQGgbdu2t9xfv379KjwODQ3l66+/xmg0YmdnVztBC9EAGYzXrjXKICEpg/SsQgCaejlblu6OCPXGUZZ4FtVwo7nJZFIwGMuTbq22bq5Vqut5CWRuEsJWmI2lFP3+C/lHd1J89igoZhwCw/C+bzou7SPROLndlThkZhW3xcvLq8LjsrIynnzySQwGA8888wwtWrTAycmJ//f//h8pKSm33J+7u3uFx3Z2duUlVoNBJiPR6Fy8XGhZoe5o8mUMRhP2WjXhod6M7NuKbm39CPB2adDf/Iv6RaNRoTGrMJrMaDSqBvu7JXOTEA2XopgpSTtJwdFdFJzci2IoRqvzpknkOFwjBmDvFXDXY5JEqY4M7l7+zVlhYSEuLi7WDqfWXT+JJicnc+rUKf7zn//Qv39/S3tpaendDk2IBqfUaCIx+bIlObp4ubxq5O/tYlm6OzzES6pG4o7dbG4ylplIvZSPs6MWf++GuViBzE1CNDzGnIvkJ+6i4Nguyq5korJ3xKVtH9w6DsSxeXtUKuutyCmzrqgV1yYde3t7S9vFixf59ddfadasmbXCEqLeupBVYLnh67HkyxjKzNhr1USEejOqXzDd2vkS0EA/rIqGyU6rwUPnSHZeCYXFRlycGn7FROYmIeonU0khhSf2kJ+4i9LzSYAKp1Yd8eg/EZc2vVDbV29p/7omiZKoFWFhYXh7e7Nw4UKeffZZCgsLee+99/Dz87N2aELUCyWGsvJrjU5erRpll1eNArxdGN6nfBGG8BBvHOzu/jWNQlzTxM2B/KsLOzg56FCrG+YpeNfI3CRE/aGYTRSfPkx+4k6Kfv8VxWTEzrsZnoMm4RreH63O69Y7ucskURK1wsnJiaVLlzJv3jyeeeYZ/P39mT59OgcPHiQhIcHa4Qlx1ymKwoXLhZbE6Njpq1UjOw0dQ725v38w3dr64e9te6fmioZLrVLh28SJ81mF5OhL8G7iZO2Q7ojMTUJYX+mlsxQkli/pbSrMQ+3khluXe3GLGIC9f0i9viZSpVxb/kVUqbS0lGPHjhEeHo6Dg0OVfU6ePEm7du2qfM5Wr1GqS9Uds5uNe2OTkJBAt27drB1Gg1Pb41ZiKLt6rVH5TV8vZRcBEOjjQre2fpZrjewbcNVIftfqh7qemzKyC8kvMhLU1E2qnFfJ3FRz8n5Rc7YyZmUFuRQc+4mCxJ0YMs+BWotz6264RQzEObQLKk3tndpbl2Nm1YpSSkoK8+bN4+DBgzg4OBAVFcXs2bNxcrr5N1hGo5GlS5cSGxtLTk4OrVq14umnn2b48OEV+uXk5LBkyRLi4+O5cuUKgYGBTJw4kcmTJ9flYQkhGglFUUjPKihPjE5mcOxMNsY/VI3G9A+hWzs/mnrJlyWiYfFq4kRhSRlZuUVyXy4hRLWYjaUUnTpA/tEfKT5zpHxJ74DWeA1/Atf2fdE4350lvWuT1RIlvV7PlClTCAgI4J133iEnJ4f58+eTk5PD4sWLb7rtq6++yubNm3nuuecIDg4mNjaWZ599lo8++ogBAwZY+s2aNYtz587x/PPPExAQwN69e3njjTcwm838+c9/rutDFELYoJLSMo4mX+ZAUgYHkzLJyLlWNXK9esNXP8KDG3bVSAitRo2XuyOZucXkFxnQuVRdtRJCNG6KolB6Pon8ozvLl/QuLULj5kWTPmPKl/T2btiLplgtUVq9ejV6vZ7Y2Fg8PT0B0Gg0zJ49m5iYGFq3bl3ldunp6axdu5a5c+daKkP9+vUjOTmZxYsXWxKlS5cuceDAAd58803Gjx8PQJ8+fUhKSiIuLk4SJSFEtSiKwvnMgvKlu09mcuxMNmUmMw72GjqF+jBuUChd2/hK1UjYHJ2LPfpCA5evlODiaIdGY70leoUQ9Ysx9xIFifHkJ+6k7EoGKjtHXNr2Ll/Su0UHqy7pXZuslijFx8fTu3dvS5IEMHz4cObMmUN8fPwNE6XExEQURaFv376WNpVKRWRkJJ999hkXL17E398fo9EIgJtbxTKfTqcjNze3Do5ICGErikvLOHoqy3KtUWZuMQBBfq5E92tFt7a+dAj2wk4rVSNhu1QqFb4eTqRlFJCdV4Kvp7O1QxJCWJG5pJCCk/soSNxJSdpJQIVTy3A87nkQl7a9UNs37MVfqmK1ROn06dOWSs819vb2NG/enDNnztxwO7Vabel7/bZQfnM5f39/goKC6N27Nx9++CEtW7YkICCAffv2sXXrVl5//fVaPhohREOmKAppGfmWxOj4mRzKTGYc7TV0au3Dnwa3pmtbP/zkg6JoZBzstbi7OXAlvxSdiz2ODrJYrhCNiWI2UXzmyP+W9C4zYOcVgMfAR3ALvwetu4+1Q6xTVr1GSafTVWrX6XTk5eXdcLuWLVsCcPTo0Qo3izt69ChAhW0/+OADnn/+eUaNGgWUJ1kvvfQSY8aMqY1DEEI0YEUlRpLOF/Pz2SMkJGWQZakauRHdrxXd2/rRPthTqkai0fPUOVBQZCAzt5ggP1nYQYjGwJB5rvy6o2PxmAqvoHZyxa3TYFwjBuIQENpo3gca3FdDYWFhdO/enUWLFtG0aVPLYg779+8H/ldxUhSFV155hZSUFN566y18fHzYu3cvixYtwtvbm+jo6Bq97rFjx274nFarpbCw8IbP3+w5UbXqjJnBYJD7YPyBjMWtKYpCeraBX08VcuxcESYz2GtzaNXUgV6hTQgNcKSJixYopSw/laNHUq0dcr10u79rtrDkbWOkUavxaeLExewi8gpKaeLmaO2QhBB1oKzgCoUndpN/dCeGjLOg1uAc2hW3iEE4h3ZFpa29Jb0bCqslSjqdDr1eX6ldr9cTHBx8020XLFjAc889x0MPPQRAYGAgTz/9NO+++y4+PuUlwJ07d7J582a+//572rZtC0CvXr3Izs5m4cKFNU6UbnWvihvdW0Huo1Rz1R0ze3t7OnXqdBciqv9s5b4LdaXEUEb8oXQ27j3L6fN5ODloGNa7JT6OBYwZ3gc7rW1cdHo3yO9a4+TiZIezo5bsvBJcnezRyt+MEDbBXGag6NQBCo7upOj0ofIlvf1D8Bo2DdcO/dA4Vz77qzGxWqIUEhLC6dOnK7QZDAZSU1MZN27cTbcNCgpizZo1nD9/ntLSUlq2bMmyZcuwt7e33OQtOTkZjUZDmzZtKmzbrl07vvnmG4qLi295vyYhRMOWnlXAxr1n2f5rGoXFRlo0deOp8R0Z2LUZzo52JCQkSJIkRDWoVCp8mjiRmpFP1pVi/L3lC0AhGipFUShN/438o7soPLkHc0khGjdP3Hvfj1vEQOx9gqwdYr1htUSpf//+fPDBB+Tm5uLh4QHA1q1bMRgMFe6FdDPXrlEqKSnh22+/JTo6GldXV6C8ymQymTh58iTt27e3bHP8+HG8vLwkSRLCRplMZn45cYmNe1I4fCoLrUZFZMcARka2on0rz0ZzXrUQtc3eToOnzpHsvBIKS4y4ODa+03CEaMiMVzIpSNxVvqR37iVUdg64tOmFa8RAnFqGo1LLNbnXs1qiNHHiRFatWkVMTAwxMTFkZ2ezYMECRo4cSWhoqKXfnDlziI2N5cSJE5a2VatW4erqir+/P+np6SxbtgyDwcBf/vIXS58BAwYQGBjIs88+y9NPP42fnx+7d+9m7dq1zJo1664ea0MwY8YMfv/9d3bs2FHl87Gxsbz00kt88803dOzY8Zb7mz17NqdOneL777+v7VCFqFKOvoQf9p9j874UsvNK8G7ixKQRbRnWswUeOrmmQlRfSkoK8+bN4+DBgzg4OBAVFcXs2bNv+gVbQUEBy5YtIz4+nrNnz6LVaunQoQMvvPACHTp0qNDXaDTy7rvvsnbtWvLz84mIiGDu3LmWMyLqsyZuDuQXGsjKLcbJT4taXbdfPMjcJMSdMZcWXV3SexclqccBcGwRjkff8bi07YPaQQoHN2PVa5RWrFjBG2+8waxZsyyT0Ysvvlihn9lsxmQyVWgzGAwsXbqUS5cuodPpGDhwIM8//zze3t6WPi4uLqxYsYLFixfz9ttvo9fradasGS+//DKTJk26K8fYkNx///08//zzHDx4kK5du1Z6fv369bRo0aJaE5EQd4uiKBw7k83GPWfZl3gRk1mhS5gPM8Z1pEc7P7lBpqgxvV7PlClTCAgI4J133iEnJ4f58+eTk5PD4sWLb7jdhQsX+Oqrrxg/fjzPPPMMZWVlrFy5kokTJ7J69eoKydL8+fOJjY3l5ZdfJjAwkE8++YRHH32UdevW4efndzcO87apVSp8PJxIzyokN78EL/e6/ZAlc5MQNaeYTRSnJFJwdCeFv+0vX9Lb0x+PAQ/hGtEfO3dfa4fYYFh11btWrVrx6aef3rTPggULWLBgQYW2qVOnMnXq1FvuPygoiLfffvuOYmwsBg8ejIuLC3FxcZUmo+zsbH7++WdmzJhhpeiEqKioxMiPB9LYsDeFtIx8XJ3sGHVPMCP6tCTAx9Xa4YkGbPXq1ej1emJjYy03RNdoNMyePZuYmJgb3gy9WbNmbN26tULVKTIykiFDhrBq1Srmz58PQEZGBqtXr2bu3Lk8+OCDAHTq1IkhQ4awYsUK/vrXv9bxEd45Z0c73JztyM0vxc3ZHnu7ujtdR+YmIarPkJV6deWv8FwAACAASURBVEnvnzAV5KB2dMG140DcOg7CIaC1nHp+Gxrc8uCibjg6OjJs2DA2b97MnDlz0Gr/96uxadMmysrKLPejWrRoEbt27eL8+fO4uLjQrVs3XnnlFZo2bWqt8EUjkXJRz8a9Z9mZkEZxqYnQZu48O6Ez/ToH4mgvb2fizsXHx9O7d29LkgQwfPhw5syZQ3x8/A0TJWfnyjcjdnBwICQkhMzMTEvb7t27MZlMjBw50tLm6urKoEGDiI+PbxCJEoB3EycKS4xk5RYT4ONSZx/AZG4S4uZMhXkUXFvS+9KZ8iW9Q7rg2nEqLqHdG+WS3rVJPlkIi1GjRrF27Vr27t1L//79Le1xcXFERERYbvabnZ3Nk08+ia+vL7m5uSxbtoyHH36YzZs3Y29vb6Xoha0ylpnZl3iBjXtTOH4mG3utmnu6BDIyshVhzT2sHZ6wMadPn2b8+PEV2uzt7WnevDlnzpyp0b6Kioo4efIko0ePrrB/b29vyyJG14SGhhIXF4fZbLbcD7A+02rUeOmcyLpSTEGxETfnunvvl7lJiIqUMiOFyQcoOLqLotMHwWzCvmkwXvc+hmuHe9C4uFs7RJshiVIdyT+6k/wjOzCZTORp7v4qIm6dBuPWcWCNtunduzc+Pj5s2LDBMhmlpaVx6NAh5syZY+l37RQSAJPJRI8ePYiMjOSnn35iyJAhtRK/EJm5RWz5+Rw//HyOKwWl+Hu5MHVUB4b0aI7ORT70iLqh1+vR6SrfN0Sn05GXl1ejfS1ZsoTi4uIK18Xq9Xrc3Nwq9XV3d8doNFJUVGRZvbUu1O7cpKA1mMgC9PYaVNy8qnQ78xLI3CQEXF3S+8IpCo7upODEHswlBWhcPXDvGV2+pLdvc2uHaJMkURIWGo2GqKgovvnmG15//XUcHByIi4uztF+zc+dOPvzwQ5KTk8nPz7e0p6SkWCFqYUvMZoXDv2exce9Zfj1xCYAe7ZsyMrIVncN86nyFLSFqy/r161mxYgWvvvoqLVq0qLPXOXbs2A2f02q1FBYWVmgrLS21LJB0/UJJt0OjVmE0KRiMJrS3+PssLS1FfV081TVs2DDLCncODg589913aDQaBg0aZDnGn376iU8//ZQzZ85QUFBg2fb333+nd+/eAJSVlWE2myuNS3VVZzuDwUBCQsJt7d8WyVjU3B/HTF2ch/2FY9inJ6IpykFRazH4tcEQEEGZd0suq9SQllX+rxG7k9+zm91EXRKlOuLWcSBuHQdSWFiIi0vDuTHfqFGjWL58OTt27GDEiBFs2LCBPn36WFYUPHz4MDExMQwdOpTHH38cb29vNBoNEyZMoLS01MrRi4Yqv8jA9l9T2bg3hYuXC3F3tWf84Nbc17slvp6Vr/0Qoq7odDr0en2ldr1eT3BwcLX2sWfPHl555RWmTZvGI488Umn/f/yC6Zq8vDzs7OyqvNbpZsLDw3FwcKjyuZMnT1aaf1x6DIcew2t1bsrMLUJfYMDfz7XOrhUcN24cX3zxBfv372fEiBFs3bqVPn360Lx5+bfohw8f5oUXXmDo0KE8+eSTFeYmRVEsx6rValGr1bd17NUdM3t7ezp16lTj/duihISEm34IFZUlJCTQJbw9hUn7yE/cRcm58i9DHJu3xzViIq7t+qB2kHnxj+ry90wSJVFBeHg4wcHBxMXF0apVK06dOsXjjz9uef6HH37A3d2dJUuWWM6jv3z5cq18Mykan1NpuWzck0L8ofMYysy0b+XJI8PbEtnRHzut3PhO3H0hISGcPn26QpvBYCA1NZVx48bdcvujR48yc+ZMRowYUel2F9f2n52dzZUrV2jSpIml/fTp07Rs2bJBXJ90PS93RwqKyxd2aObrWicLO8jcJBoDY+4lnI+u49z2t1CMpWg9muLRfwKuEQOwa1K/bx1gqyRREpWMGjWKDz74AC8vLxwdHRk6dKjludLSUuzs7CpMhOvXr7dGmKKBKjWa+OlQOhv3nuVU2hUc7TUM7tGckZEtaRUgF6AK6+rfvz8ffPABubm5lgUXtm7disFgYMCAATfd9vTp0zzxxBN07dqVN998s8qEoV+/fqjVajZt2sRDDz0ElFcqduzYUWkRiYZCo1bj4+7EpZwi9IUG3F2rrnDdKZmbhK1SFDP6A5vJ+XEV9mYF144DcIsYiEOzNrKkt5VJoiQqGTVqFO+88w5ff/01I0aMqHBhcWRkJKtWreKNN95g6NChHDlyhDVr1lRYslWIqly4XMCmvSls+yWVgmIjQX6uPDk2gkHdgnBxkuVLRf0wceJEVq1aRUxMDDExMWRnZ7NgwQJGjhxJaGiopd+cOXOIjY3lxIkTQPmKa9OmTcPOzo7HH3+c48ePW/ra29vTvn17APz8/Jg4cSKLFi1Cq9USEBDAZ599BsCf//znu3iktcvV2Q7nQi2X84pxcbJDWwc3e5a5SdgiY+4lsuLepyT1OE7BXbgY1JeQfoOsHZa4St5BRCVBQUF06dKFQ4cOWe5Pcc2QIUP4y1/+whdffMG3335L586d+fDDDxkzZoyVohX1mcmscODEJTbuTeHgb5lo1Cp6R/gTFdmK8BAv+aZM1Ds6nY4VK1bwxhtvMGvWLBwcHIiKiqp0Gp3ZbK5wWldycjIXL14E4NFHH63QNzAwkB07dlgev/LKKzg7O7NkyRLy8/OJiIhg2bJl+Pk13FNrVCoVPh5OpGbkc/lKMU29av/aXJmbhC35YxUJtQbvqBjcOg3mwsGD1g5N/IFKURTF2kHUZ6WlpRw7duyWF8y2a9euyuca2mIO9UF1x+xm497Y1LcLZnPzS9i6P5XNP6eQlVuMp86R+/q0ZFiv5ni5O1k7PIv6Nm4NgYxZ/VBf56bsvGJy9KUE+rjg7GhblWKZm2pO3i+qdn0VySdqBlpd+aJZMmY1J4s5CCHqPUVROHE2h417z7L36AXKTAqdWnvz+P3h9OzQtE5OxRFC1C8ebo7kF5Uv7BDUVItaqsZCWCiKGX3CFnJ2rAK12lJFkrMr6i9JlIQQd6SoxMiug+fZuDeFlIt6XBy1jIxsxX19WhLkV/nGmkII26VWq/Bp4sSFy4VcyS/FU+do7ZCEqBeMuZfI2vA+JeeO4xTcGZ+opyxVJFF/SaIkhLgt5y7p2bQ3hR0H0iguLSM4wJ2ZD3RmQJdAHB3krUWIxsrFyQ5XJzty9CW4OdvJUv+iUatcRXoKt05DpIrUQMinGSFEtZWZzPx87CIb96SQePoyWo2aezoHMLJvK9o095A3fiEEAN5NnCi6VH4Knr+3i7w3iEbJeCWDrLj/J1WkBkwSJSHELV2+UsyWn8+x5ecUcvNL8fV05tGo9gzt2bzO7pkihGi47LRqPN0duXylhMJiI67O9tYOSYi7RqpItkMSpVqiKIr8AdxFslhj3VMUhaOnLrNh71n2H7+Eoih0a+vHyMiWdG3rh0Ytv+9C1HfWnJuauDqQX2gg60oxzo52qBvBe4bMTUKqSLZFEqVaYGdnR3FxMc7OztYOpdEoLi7Gzs62lp6tLwqKjez4NZWNe1NIzyrAzdmesQNCuK9Pyzq5N4oQom5Ye24qv7eSM+czC8jWl+DTpP7cGqCuyNzUeEkVyTZJolQLfH19SU9PJzAwECcnJ/mjqEOKolBcXEx6enqDvjljfXT6/BU27k1h58HzGIwm2rTw4PmHutKvUwD2dnIxthANTX2Ym5wctOhc7MnLL0XnbIeDvW1+7JC5qXErryK9T8m5YzgFd8InKkaqSDbCNt+x7jKdTgfAhQsXMBqNFZ4zGAzY28u52TVxqzGzs7PDz8/PMu7i9hmMJnYfucDGvWf57Vwu9nYaBnZtxojIloQ2a2Lt8IQQd6C+zE1ms0KOvoTMCyqauDnSUL9LlLlJXK+8ivQDOTs+B5UK75FP4dZZqki2RBKlWqLT6ap8c0xISKBTp05WiKjhkjGre5eyC9m8L4Uf9qeSX2Qg0MeFJ0aHM7hHc1yd5LQRIWxFfZmbtv1yjne+OsysBzszrFeLu/a6tUnmJvFHlapII59C6+5j7bBELZNESYhGwmRWOJiUwca9KSQkZaBSqejVoSlRka3o2NpbvgETQtSZwd2bs+3XNJbHHadXh6ayWqZosKSK1LhIoiSEjcsrKGXrL6ls2pdCZk4RHm4OTBjahuG9W+DdCC6uFkJYn1qt4qnxHXn2rZ2s2HCCZyZ0sXZIQtRYhSpSq07lK9pJFcmmSaIkhA1SFIXfUnPZuOcsPx2+QJnJTESIN49Ft6d3uD9ajdraIQohGpkWTXWMGRDCmh+TGdqzOe1beVk7JCGqRVHM5B/8gezt16pIM3DrPFSqSI2AJEpC2JCS0jJ2HUpn496znEnPw8lBy329W3BfZEtaNJULjIUQ1jXx3jbEH07n/W+PsOSFgfKljaj3jFcyr94XSapIjZEkSkLYgMt6I/+JTWT7r6kUlpTR0l9HzJ86MaBLIM6OsjiDEKJ+cHTQMn1MBP9c9gvr4s8wblCotUMSokpSRRIgiZIQDVpufgkrNpxg+68ZaDUqIjsGMDKyFe1becqbuRCiXuod7k/P9k358ock7ukciI+HXCsp6hfjlUyyNrxPSUqiVJEaOUmUhGiAykxm4naf5csfkjAYTUS2c2XGhL54uDlaOzQhhLil6WMjiPnXDv7zfSJzHu1p7XCEAKSKJCqTREmIBubw75l8HJtIWkYBXdv68sTocDLSfpckSQjRYPh5OjPx3jBWbjzJLycu0bN9U2uHJBq5ilWkjvhExUgVSUiiJERDkZFTxKfrjrEv8SJNvZz5v6m96NHeD5VKRUaataMTQoiaGTMglB8TzvPR2kQ6hnrjaC8fScTdpyhKeRVpx0oAvEc8iVuXe6WKJABJlISo90qNJr7bcYpvd5xCpVYxaURbxg4Ixd5OY+3QhBDittlp1Tw1viNz3t/D19t+Z8rI9tYOSTQy11eRvKOews7d19phiXpEEiUh6ilFUfj52EU+WXeczJwi+nUKYOqocLnwWQhhMyJCvBncPYi1O5MZ1C2IID83a4ckGgGpIonqkkRJiHooLSOfj9cmcvhUFi2auvHPpyLpGCrnSgshbM9j0R345fglPlhzlH8+FSkfVkWdMuZlcjnufYqliiSqQRIlIeqRohIjX/7wG+t/OmO538jIyJZo5KaMQggb1cTNgSlR7Xn/2yP8mHCewd2DrB2SsEGKopB/aCvZ21cAUkUS1SOJkhD1gNms8GNCGss3nCCvoJR7e7Zgysh2uLs6WDs0IYSoc8N7tWD7L6l8tv4YPdv74epsb+2QhA2RKpK4XZIoCWFlyWlX+HDtUX47l0ub5h7839RehDX3sHZYQghx16jVKp4a35EXluxi5caTxPypk7VDEjZAqkjiTkmiJISV5BWU8vmmk/yw/xzuLg48O6ELg7sHoVbLG7gQovEJadaE6H7BrN99hqE9m8sXRuKOGPMyubzhA4rPHsWpZQTeUTHYNZEqkqgZSZSEuMtMJjMb96bwxZYkSkrLGN0/hIn3tsHFyc7aoQkhhFU9cl9bdh+5wP/79ghvP9tfrs8UNSZVJFGbJFES4i5KTL7Mx7GJpFzU07m1D9PHRshyuEIIcZWzox1PjAln4coDbNh7lvvvCbF2SKIBkSqSqG2SKAlxF2TlFvPZ+mPsPnIBXw8nXvlzD/pE+Ms3XEIIcZ2+HQPo2saXVZuS6NsxAC93uXecuLlKVaT7puPWdZjMseKOSaIkRB0yGE2s3ZXMN9tPoZgVHhrWhnGDQnG0lz89IYSoikql4slxEcz89498uu44f53c3dohiXrsj1Ukx5YR+EgVSdQi+bQmRB1QFIVfT2TwyffHuJhdSJ8If6bdH46fp7O1QxNCiHovwNuVB4aE8d8tSdzbszld2sgHX1HR/6pIKwFFqkiiTkiiJEQtS88q4D+xiSQkZRLk58rr0/vIJC+EEDX0p8Gh7ExI44PvjrJ09iDs7TTWDknUE1JFEneLJEpC1JKiEiNfb/ud7+NPY6fVMO3+DkT3C0YrqzYJIUSN2Wk1PDW+I//30T7W7DjFQ8PbWjskYWUVqkiKgvd9T1ytIsk8K+qGJEpC3CFFUdh18DzL4k6Qoy9hSI8g/jyyPR46R2uHJoQQDVrnMF/6dw7kmx2nGNC1GQE+rtYOSVhJWV4WWRs+oPjsEakiibtGEiUh7sCZ9Dw+WnuUE2dzCA1qwiuP9qBtC09rhyWEEDZj2uhwDiRl8MF3R3l9eh+5BqWRURSF/MPbyN62QqpI4q6TREmI26AvNLBq80m27EvB1dmemQ905t6ezVGrZQIXQoja5KlzZNJ97fg4NpHdhy9wT5dAa4ck7pIKVaQW4fhEx2DXxM/aYYlGxKqJUkpKCvPmzePgwYM4ODgQFRXF7NmzcXK6+T0TjEYjS5cuJTY2lpycHFq1asXTTz/N8OHDK/XNyMhgyZIl7Ny5k4KCAgICApgyZQqPPPJIXR2WsGEms8IPP6fw+aaTFJaUMbJvKx4Z3hZXZ3trhyaEEDZrZN9WbD+QyifrEunWzhdnRztrhyTqkFSRRH1htURJr9czZcoUAgICeOedd8jJyWH+/Pnk5OSwePHim2776quvsnnzZp577jmCg4OJjY3l2Wef5aOPPmLAgAGWfpmZmUycOJFmzZrx97//HXd3d86cOUNZWVldH56wQcfPZPPx2kTOXMgjPMSLJ8d2pKW/ztphCSGEzdOoVcSM78Tsd+NZtTmJ6WMirB2SqCNleVlkbfyA4jNSRRLWZ7VEafXq1ej1emJjY/H0LL+mQ6PRMHv2bGJiYmjdunWV26Wnp7N27Vrmzp3L5MmTAejXrx/JycksXry4QqL073//Gx8fH5YtW4ZWW36ovXv3ruMjE7YmO6+Y5XEn2HnwPN7ujvx1cnf6dQqQ8+SFEOIuCmvuwX19WrJh9xkGdw8itFkTa4ckatH1VSSv4U+g6yZVJGFdVvvti4+Pp3fv3pYkCWD48OHY29sTHx9/w+0SExNRFIW+ffta2lQqFZGRkZw8eZKLFy8CUFBQwKZNm3jkkUcsSZIQNWEsM7NmxymeWrid3Ucu8ODQMD54aQj3dA6UJEkIIaxgysj26Fwc+GDNEUxmxdrhiFpSlpfFpdXzuLzxQxz8g2k2/W3cu98nSZKwOqtlEKdPn2b8+PEV2uzt7WnevDlnzpy54XZqtdrS9/ptAZKTk/H39+f48eMYjUbs7OyYNGkShw8fxtXVlejoaF588UUcHBxq+YiELUlIyuA/sYmkZxXSs31THh8djr+3i7XDEkKIRs3VyY6p93fg7f8e5IefUxgR2craIYk7UF5F2k72tuVSRRL1klWvUdLpKl/fodPpyMvLu+F2LVu2BODo0aM0a9bM0n706FEAy7aXL18G4G9/+xvjx49n5syZJCUlsWTJEgwGA6+//nptHYqwIZeyC/nk+2PsP36JAG8XXnu8N93bybnRQghRXwzs2oxtv6SyYuNJekf44+Em96xriCpei9QBn+in5VokUe9UO1FSFKVenG4UFhZG9+7dWbRoEU2bNrUs5rB//37gfxUns9kMlF+TNHfuXMvPJpOJRYsW8cwzz+Dt7V3t1z127Nhtx5yQkHDb2zZWd3vMDGVmdh/PZ8/JfNRqFUM76+jdxg1V0XkSEs7f1Vhul/ye3R4Zt5q73THr1q1bLUciGiOVSsWMcR155q0fWbb+OC88LL9XDUnlKtLj6LoNlyqSqJeqnSgNGDCA+++/n/vvv5+wsLA7fmGdToder6/UrtfrCQ4Ovum2CxYs4LnnnuOhhx4CIDAwkKeffpp3330XHx8fy/4BIiMjK2zbp08fzGYzycnJNUqUwsPDb+t0vYSEBPlwUEN3c8wURWH3kQt8tvE4l68UM7BrMx6Nbo+X+82XqK9v5Pfs9si41ZyMmagPgvzcGDeoNV9v+517e7YgIrT687mwnjL95fL7Ip05XF5FiorBzqOptcMS4oaqnSh17NiRlStX8umnn9KmTRvGjBlDVFSUJTGpqZCQEE6fPl2hzWAwkJqayrhx4266bVBQEGvWrOH8+fOUlpbSsmVLli1bhr29Pe3atQMgNDT0pvsoLS29rbiF7Th3Uc/HsYkcTb5McIA7sx/pRodgL2uHJYQQohoeHBrGroPn+eC7I7zzwiDstFKRqK8URSH/yPbyFe3MJqkiiQaj2r+hS5cuZc+ePfz973/H1dWVhQsXMnDgQKZNm0ZcXBwlJSU1euH+/fvz888/k5uba2nbunUrBoOhwhLfN9OsWTNCQkIwGo18++23REdH4+rqCpRXmcLCwti9e3eFbfbs2YNarbYkVKLxKSg28tHaozzz9k7OXsjjqfEdefv5AZIkCSFEA+Jgp2HGuI6kZRQQuyvZ2uGIGyjTX+bS6je4vOEDHPxa0eyJt3HvPkKSJNEg1GgxBzc3NyZMmMCECRNIT09n/fr1xMXF8eKLL+Lk5MTw4cO5//776dOnzy33NXHiRFatWkVMTAwxMTFkZ2ezYMECRo4cWaEaNGfOHGJjYzlx4oSlbdWqVbi6uuLv7096ejrLli3DYDDwl7/8pcJrPP/888TExPD6668zZMgQkpKSWLp0KQ888AC+vr41OXRhA8xmha2/pLJy4wkKigwM79OSSfe1Q+dif+uNhRBC1Dvd2/nRJ8Kf1Vt/557OgTT1ktVJrUkxm1DKDChGA4rJiH3aYdJ+XCJVJNFg3faqd4GBgcyYMYMxY8awcOFCNm3axNq1a4mNjaVp06b8+c9/ZvLkyWg0miq31+l0rFixgjfeeINZs2bh4OBAVFQUL774YoV+ZrMZk8lUoc1gMLB06VIuXbqETqdj4MCBPP/885WuORo8eDCLFy/m/fff5+uvv8bT05NHH32UWbNm3e5hiwbqt3M5fLg2keS0K7Rr6cmTYyMIkZsVCiFEg/fE6AgO/badj2MT+b+pverFwlP1gWIqQykzYDYaUExXk5eya/+MKEYD5jIDSlmpJbH5X5vhfwnPH7YxV2oz/O81yoxgLqsQgwvg0LwDPtFyLZJomG4rUSooKGDLli2sW7eOX3/9FbVazZAhQxg7dix2dnZ89dVXLFiwgFOnTvHPf/7zhvtp1aoVn3766U1fa8GCBSxYsKBC29SpU5k6dWq1Yh0xYgQjRoyoVl9he3LzS1ix4QTbf03DU+fAXx7uyoCuzWQiFUIIG+Hj4cTDw9vy2frj/HzsEn0i/K0dUgWKooCp7A9JRml5olIhybguOTEZr7aXVkhslLIbJTLG/7VfbUMx337QGi1qrT0qrT0qu6v/vfpPbe+AytkNldYOldbB0kettavQT6W1J+XSZVrd96BUkUSDVe1EyWQyER8fz7p16/jxxx8pKSmhQ4cOzJkzh6ioKDw8PCx9BwwYwOLFi/n8889vmigJUVfKTGbidp/lyx+SMBhNjB8UyoNDw3B2tLN2aEIIIWrZqHuC2XEgjY/XHqFTsDuOWlV5RcVcBqayqz+bUExXH5uvtplMf3i+/L9c7VdxexOO51PJzk0sT0quT2KuJijmsiqSnjIjoNz2sVVIPq4mLdeSErWjMyptk/8lMdf6aOxQ2Tn8YVs71NclPCqtfeU2u/K+tZXYGBMSJEkSDVq1E6W+ffuSl5eHj48PkyZNYuzYsYSEhNywf1hYGEVFRbUSpBA1cfj3TD6OTSQto4CubX15YnQ4zXzdrB2WEKKBSElJYd68eRw8eNByWvjs2bNxcrr5bQM2btzIpk2bOHLkCBkZGfz1r39l2rRplfq1adOmUpuzszOHDh2qtWO4U4qigLk8QbiWNJQnEEYUs+m65MMIpj8mF6brkpHrkg9TWRX7vpNkpvz550xlqDRmLi35T52MiSOgT3O4YZKhdnJDczXRqFCN0fwxwbmaiFyfxFRRubEkPHIGhBBWU+1EqV+/fowdO5bIyMhq/dFGRUURFRV1R8EJURMZOUV8uu4Y+xIv0tTLmf+b2ose7f1kkhFCVJter2fKlCkEBATwzjvvkJOTw/z588nJyWHx4sU33Xbz5s2kpaUxcOBAvvrqq5v2nTx5MtHR0ZbH126WfjcUpx7Hbc8npP2y/IbJB2bTrXd0J9RaVBotKo0GlUZ79fEff776T61BrbUDeydLG1f7qdTXHpf3U2m07D+Zxan0Akb1b42nhwsq9R/6a+xQqTUV+qs0dmD5WfOH/f0vhmvPHzx0WO4hJkQjU+1EadGiRXUZhxC3rdRo4rsdp/h2xylUahWTRrRl7IBQ7O2qXkhECCFuZPXq1ej1emJjY/H09ARAo9Ewe/ZsYmJiaN269Q23XbJkiSXhuVWi5O/vT+fOnWsv8BpQO7hgdvHC3tPTknDcLPmomLxUncxg+fnWyQxqTZ19gdW3h4HPF2zn/G+uLHi6H2q1fFEmhLh91U6UduzYwe7du3n11VerfH7evHn069ePQYMG1VpwQtyMoij8fOwin6w7TmZOEf06BTB1VDg+Hjc/PUYIIW4kPj6e3r17W5IkgOHDhzNnzhzi4+NvmijdzarQnXDwa0lh57G0tcHqiM7Fnsei2/Pu14fZ/msq9/ZqYe2QhBANWLXf1T/55BOKi4tv+HxJSQmffPJJrQQlxK2kZeTz6kf7eHP5rzjZa/jnU5G8NKWHJElCiDty+vTpCvfyA7C3t6d58+acOXOm1l7n448/pkOHDnTv3p1Zs2aRmppaa/tu7Ib0aE67lp4sizuBvtBg7XCEEA1YtROlU6dOER4efsPn27dvT3Ky3Blb1K2iEiOfrjvGrEU/cur8FaaPieCdFwbSMdTH2qEJIWyAXq9Hp9NVatfpdOTl5dXKa4wZM4a///3vrFixghdffJHExEQeeughLl++XCv7b+zUahUxf+pEYYmR5XHHrR2OEKIBq/apd2VlZZSUlNzw+ZKSEkpLS2slKCGuZzYr/JiQEuOIsQAAIABJREFUxvINJ8grKOXeni2YMrId7q4O1g5NCCFqZOHChZafu3fvTs+ePRk1ahRffPEFzz77bI32dezYsduOIyEh4ba3bQh6t3Fh6y+pBLkX09ynduYKWx+zuiBjVnMyZjV3J2N2s0Vaqp0ohYWFsXXrVqZOnVrpIkyz2czWrVsrna4gRG1ITrvCh2uP8tu5XNo09+D/pvYirLnHrTcUQoga0ul06PX6Su16vZ7g4OA6ec1WrVrRrl07jh+vefUjPDwcB4eaJwEJCQk2v4Jb+/Ayfv/XDnYcK2Xx873Rau7sGrLGMGa1Tcas5mTMaq4ux6za7xpTpkzh8OHDzJo1ixMnTmAwGDAYDBw/fpyZM2dy5MgRJk+eXCdBisYpr6CUpd8c5oV3dpGRXcSzE7rwr1n3SJIkhKgzISEhnD59ukKbwWAgNTW1zhIlUTecHLRMHxNOykU963+qvevLhBCNR7UrSlFRUZw7d46lS5eyffv2Cs+pVCqefvppRo8eXesBisbHZFZY/9MZvtiSRElpGaP7hzDx3ja4ONlZOzQhhI3r378/H3zwAbm5uXh4lH8ps3XrVgwGAwMGDKiT1zxz5gwnT57kySefrJP9N2a9w/3p0d6P/25Jol+nQFnwRwhRI9VOlABiYmIYNWoUP/zwA2lpaQA0b96ce++9l6CgoDoJUDQuWbnFfLQ5k8wr6XRu7cP0sREE+blZOywhRCMxceJEVq1aRUxMDDExMWRnZ7NgwQJGjhxZ4fTyOXPmEBsby4kTJyxtycnJFRY1+v3339m8eTMA9913HwCffvopqamp9OrVC09PT06fPs2HH36Ih4cHDz/88F06ysZDpVLx5NiOxPxrB//5PpE5j/a0dkhCiAakRokSQFBQENOmTauLWITgP98nkptfxit/7kGf/8/encdFWa7/A//MDggDww6ygwiyuOCCoCguqeAWWketrCwrMctSq2PfOr9OlpzKY3YstVSOZR3PyQVx35NE08IUcGURUFlUQAcUGJiZ3x/oKOICCjwDfN6vly/kfp575ppH5Jlr7vu+7iCnZtuUkIjoXpRKJVatWoV58+ZhxowZUCgUiI6Oxpw5c+qcp9PpoNVq67Rt27YNixcvNnyfkJCAhIQEAMCZM2cA1K5H2rlzJ7Zv347y8nKoVCqEh4dj5syZsLGxaeZX1z45WJthwlBffL/1FP44VYSe/g5Ch0RErUSjEyWi5pKWeQWH0goQGaxEWLCz0OEQUTvl6emJFStWPPCcuLg4xMXF1WmbMWMGZsyY8cB+gwYNwqBBgx47RmqcsQN8sC/lPJauT8XiOZEwkfPtDxE9XKN+U/z666+Ij4/HiRMnUFZWBr1eX++cU6dONVlw1H5odXp8tzEN9ipThPlxqh0RNQ29Xo/KykqYmnJtSnsmk4oxLaYr5i5Jxs97MvDcCH+hQyKiVqDBVe92796NV155BZcvX0ZUVBR0Oh2io6MRFRUFhUIBf39/TJ8+vTljpTZs95FcnMtX44WRAZBJOd2OiBpn9+7d+Oc//1mnbcWKFejevTt69OiB2NhYVFRUCBQdGYMgH1tEhrhg/b4MnC8qEzocImoFGpwoLVu2DAEBAdiwYYNhasG4ceOwYMECbNq0CQUFBXB3d2+2QKntul5RjR+2nUIXT2v068opd0TUeN9++y0uX75s+D49PR1ffPEFgoOD8fTTTyMpKQnLly8XMEIyBlNGBUIhl2LJutR7zoohIrpTgxOls2fPYuTIkZBKpZBIJABgWMjq6uqKiRMn4ttvv22eKKlN+9/us1Bf12DqmCAWbyCiR5Kbmwt//9vTqTZv3gwrKyssX74cH330ESZMmIAtW7YIGCEZAysLBZ6P8kda1hX8cvSC0OEQkZFrcKKkUCgMu3+bmZlBJBKhuLjYcNzR0RF5eXlNHyG1aflXypH4axYG93SDj6uV0OEQUSt19zqkAwcOoH///pDL5QAAPz8/FBYWChUeGZFhoR7wdbPCysQTKL+hETocIjJiDU6U3NzckJOTAwCQyWTw9vbGzp07Dcf37t0Le3v7Jg+Q2raViScgk4rxXBQX1hLRo3N0dERaWhoAICcnB5mZmQgPDzccLy0tNXzYR+2bWCxC7LiuUF+vwvfbWICKiO6vwYlSREQEtmzZgurqagDA888/jz179uCJJ57AE088gV9++QUTJ05stkCp7Tl+9jIOnyjEU4N9Ya00ETocImrFxowZg59//hmvvfYaXn75ZVhaWtYpw52WlgZPT08BIyRj4u1iheh+Xth+KAdn80qFDoeIjFSDy4NPmzYNzz33HKTS2i5PPfUUFAoFduzYAYlEgtjYWIwdO7bZAqW2RavVYXliOuytzTAmwlvocIiolXv11Veh0Wiwf/9+ODk5IS4uDhYWtVsNXL16FX/88QdeeOEFYYMko/LscD8kH7+Ib9Ydx4I3B0Ai5hpZIqqrQYmSVqvF5cuXDWuTbhk9ejRGjx7dbMFR27XzcC5yCtR4b3IvyGUSocMholZOIpFg5syZmDlzZr1jVlZWOHjwoABRkTEzM5Hh5dFB+Gz1H9iafA6j+nsJHRIRGZkGTb3T6XQYOnQoNmzY0NzxUDtQXlGN1dtPI8DLBmHBTkKHQ0Rt2J9//on9+/fjxo0bQodCRqhfN2d087XD6u2nUKKuFDocIjIyDUqUZDIZ7O3tWbqZmsR/d51B2Q0Npo4J5M8UETWJb775Bi+//HKdtmnTpmHSpEl47bXXMGLECFy8eFGg6MhYiUQiTIsJRnWNDis2pgsdDhEZmQYXc4iJicH69etRVVXVnPFQG3fxcjk2/ZqNIb3c4O3CcuBE1DQ2b94MHx8fw/d79+7Fvn378PLLL2PBggWorq7G119/LWCEZKyc7cwxflAnJB27iD/PXBI6HCIyIg0u5uDh4QGdTocRI0Zg7NixcHV1vWep1aioqCYNkNqWlYknIJdJWA6ciJpUYWFhnap2O3fuhLu7O2bNmgUAyM7Oxvr164UKj4zc+EGd8MvRC1i6PhX/mh3JtbNEBKARidKcOXMMf//mm2/ueY5IJGKiRPf155lLOHKyEC9Ed4HKguXAiajpiEQiaLVaw/cHDx7EE088Yfje0dERV65cESI0agXkMgmmxQTjw28PYd2+TEx8orPQIRGREWhwovT99983ZxzUxt0qB+5oY4bREawsRERNy9PTE3v27MGkSZOQlJSEy5cvIyIiwnC8sLAQSqVSwAjJ2HXvbI/+3Tri5z1nMaBHRzjbmgsdEhEJrMGJUu/evZszDmrjtv+Wi7zCMsx9oRdkUk5pIKKmNWXKFMyaNQu9evVCRUUFfHx8EBYWZjh+6NAhdOnSRcAIqTV4aXQA/jhVhKXrUvHRK31ZcIionWtwokT0qMpvaPDj9tMI9rFFaCDLgRNR04uKioKVlRX2798PCwsLTJo0ybBB+tWrV6FSqTBmzBiBoyRjZ2NpimdH+OG7hHQcOJ6P/t06Ch0SEQmowYnS5MmTH3qOSCTCqlWrHisganv+s/MMrldo8DLLgRNRMwoLC6szinSLlZUVFi9eLEBE1BpFh3liz+/nsXxjGkL87GFmIhM6JCISSIMTJb1eX69Np9MhPz8fBQUFcHd3h729fZMGR63f+aIybEk+h6F93OHpbCl0OETUxl27dg0HDx407JnUsWNHhIWFwdKSv3+oYSQSMaaP74rZXyXhx+2nMXVskNAhEZFAGpwo/fDDD/c9tm/fPnzwwQf461//2iRBUduxctMJKOQSPDuc5cCJqHl99913WLx4MTQaTZ0P9xQKBWbMmFFvQ1qi+/F1U2F4qAc2H8jGoJ6u3PePqJ1q8IazDxIZGYnRo0fj008/bYqHozYi5XQR/jhVhL8M6Qwri/p7bhERNZWff/4ZCxYsQI8ePbBkyRLs2rULu3btwtKlSxESEoIFCxZg7dq1QodJrcjkKH8oOyiwZF0qdLr6s2qIqO1rkkQJANzc3JCWltZUD0etXI1WhxWJ6XCy7YBR/VkOnIia1/fff4++ffti5cqVGDhwIFxdXeHq6oqBAwdixYoV6NOnD9fQUqOYm8nx4qgAnMkrxY7DuUKHQ0QCaJJEqaamBtu2bYNKpWqKh6M2YNvBHJwvKsdLowIgkzZZPk5EdE+5ubkYMmTIPQvGiEQiDB06FLm5fLNLjRMZ4oIgb1us2nIS5ZXah3cgojalwWuU7rf+qKysDMeOHcOVK1fw3nvvNVlg1Hqpr2vw047T6NrJFr0DHIUOh4jaAaVSifPnz9/3+Pnz57nhLDWaSCTCtHHBeGPBPuw4eg0RYXpWbyVqRxqcKB0+fLhem0gkgqWlJUJCQvDUU0+hX79+TRoctU7/2XkaNyqr8fKYIN5QiKhFREZGYvXq1fD398fo0aMNv3v0ej02bdqEH3/8EU8++aTAUVJr5OpggXGRnfDf3Wcxd0kypsUEw82RSTdRe9DgRGnv3r3NGQe1EXmFamw9mINhfT3g4dS4G4muugrasmJIrl5EjdoDEgsVRCJO2yOih3v77bdx7NgxvPfee/jss8/g5uYGAMjLy0NJSQl8fHzw9ttvCxwltVaThvnhhvoS9qWp8caCXzB2gDcmDO0ME0WD30YRUSvE/+HUZPR6PVYknoCpXIJnhvnVOabTVKCmrAQ16ivQqotv/r0Y2rJi1KiLUVNWDF1FGQBACSDvt1WARAqZpT2kVg6QWdlDqnKA1MoeMisHyKwcIDbpIMCrJCJjpFKpsG7dOqxZswb79+9Hfn4+AMDPzw+RkZEYOnQoSktLYWXFMs/UeGKxCCE+5vhLdCjiN5/Aun2Z+PXYRbwyNgh9Ap2EDo+ImkmDE6Wff/4ZSUlJ+Ne//nXP42+88QYiIyM5taEd0lXdQI26GCdPZEJ2LgVvdDGHZv9KFNxMgLRlxdBVXq/XT2ymhNTCBlJLW5i4dIZEaQOp0gbnLhTCw16F6qtFqLl6CdVXi1CVnwFdZXnd/ibmdZIomdXtREpqaQuRhLupE7UncrkckydPxuTJk+sdW7JkCb766iucOnVKgMiorbA0V2DmhB4Y2tsd36w7jnnxR9AnwBGvjA2CvbWZ0OERURNrcKL0n//8B127dr3vcXt7e84Bb2P0ej10ldfrjPrcPQpUoy6GXlMBoHYkaJI5gDzgRrEVpEobyFSOMHUPgNTCpjYRsqhNhiQW1hBL5fd83mpNCpQhIfXatZXXUXO1qDaBKr2dRGku5eJ6xu+Atub2ySIxpBbWkFo51CZTd4xGSa3sIelgxfVTRET0SAK8bLDo7YFITMrCTzvPYNpnezFhqC/GDvBhpVeiNqTBiVJOTg6efvrp+x738fFBQkJCkwRFzU+v10NXUY4a9ZXaUZ9bic+df1eXQF9deVdPESTmKkiVNpDbusDUsyukShscu1CDDb8X47nx4Qjp4dssozkSkw6QOHpB4Vh/Xya9XgdtWSmqrxbWJlClRTeTqkuoyP4T5eWldV+FTAGppV1t4mQYjbo5OmVlD7HctMnjJyKitkMqESMmshP6deuI7xLS8P3WU9iXcgHTxgUjyNtW6PCIqAk0OFESiUS4evXqfY9fvXoVWi33GDAGer0Ouhtld4z6XLnHqFAJ9DWauh1FYkgsrCG1sIHc3h1mPiGQ3BwBMowEdbCCSFL3x+ZaeRWWbt4DX69AhPTsIshIjUgkro1TaQO4BdQ7rquuQs21y7XJ0x1JVM3VIlTknYBeUzchlHSwhNTy5pQ+S/s6yZRUaQORWNJSL42IiIyYvcoM77/YB0dOFmLZhjTM/SYZg3q64sWRAbCyUAgdHhE9hgYnSgEBAdiyZQumTJkCubzulKmqqips3rwZAQH136BS09LrddCWX6s3CnS7SEJtoYQ609AAQCytnYqmtIHCyRvSzr1vJj+2hmRI0sHykRKAn3acRkVVDV4aE2i009nEMgXkti6Q27rUO1Y7ulZmSJxuJVI1V4tQdTED108eBPS6Ox5MAqnStnY6n6X9zWl9t0akHCA2NTfa60BERM2jdxdHBPvY4n+7z2LDL5k4cqIQk6O7YFgfd4jFvCcQtUYNTpReffVVvPzyy3jmmWfwyiuvwMfHBwCQkZGBb7/9FtnZ2Vi6dGmzBdoe6HVaaMuv3nctkFZ9BTXlpYCu7sidSCIzrP8xcfEzjArdGgmSKG0h6aBsllLbuQVqbD+UgxFhnnBvpftKiEQiSMyUkJgpAWefesf1Om3tv0Od0ajaNVLXzx6B7oa67uPJTW8XllDdOaWvtu1+a7OIqHFSU1MbfG5hYWEzRkJUy0QuxeSoLogMccWSdan4Zu1x7D6Si9hxXeHtwoqLRK1NgxOl8PBwzJ8/H/PmzcMbb7xhaNfr9TA3N8cnn3yCiIiIRj15Tk4OPv74Yxw9ehQKhQLR0dGYPXs2TE0fvD6kuroaixcvRkJCAkpKSuDp6Ynp06dj2LBh9+3z73//G/Pnz8fAgQOxbNmyRsXZFPTaGmjLSw1Jz60ESHtnIlReWnfkAoBIKr9Z/MAGJu6BhlGhO6fEic2Ugoxg6PV6LN+YDlMTGSbdVQ68LRGJJZBZ2UNmZQ9Tj6B6x3Waitvroq7dsT6qJB8V2cfqTXGUmFsbikvcmUTJrBy4dxRRIzz99NMN/t2n1+s50kstxtXBAp9MC8MvRy9gZeIJvP3lfkT388Kzw/1gZsKKrEStRaP2URo7diyGDBmC5ORk5OXlAQDc3NwQHh4Oc3PzRj2xWq3G5MmT4ezsjEWLFqGkpATz589HSUkJFi5c+MC+H374IbZv346ZM2fCy8sLCQkJePPNN7Fs2TIMGDCg3vlFRUVYvHgxbGxsGhXj46ouKYDFb98j98ASaMuvAtDXOS6SmRjW1Zh6BtddC3Tzq9jEeKdx/X6yCMcyLmPqmEAoO7TfURKx3BRye3fI7d3rHdPr9dBev3p7TVTp7bVRlbknUJOWhDt/LkQSGaRWdpBa1q/Ux72jiOqaP3++0CEQ3ZdIJEJkiCt6+Tvgh22nsPlANpKPX8TLo4PQr5uz0d7biei2Rm84a25u/sCRm4Zas2YN1Go1EhISYG1tDQCQSCSYPXs2YmNj0alTp3v2u3jxIjZs2ID3338fzz33HACgX79+yMzMxMKFC++ZKP3jH//A0KFDceHChceOu1HEYugU5jBz71ynNPathEikMGu1vyira3RYkZgOF3tzRIV7Ch2O0RKJRJCaqyA1V8HEpf6om15bjZprl28nUdduJ1P33DvK1PxmEnV7FEpqZQ/x9RLotTX1Cm0QtWXcjoJaA3MzOaaN64rBvdywZN1xfLb6D+w8YodpMcFwtmvch8xE1LIa/K5qz549SE5OxocffnjP4x9//DH69euHyMjIBj1eUlISQkNDDUkSAAwbNgxz585FUlLSfROltLQ06PV6hIeHG9pEIhHCwsKwcuVKFBQUwMnp9i7Zhw4dQlJSErZv34633nqrQbE1FZmVA653j4HfPfYEau22JGcj/8p1/O3lUEglnCr2qEQSGWTWzpBZO9/zeJ29o+4YkdIU5eL62dt7R1kCOHfg29qS59aOkFk5Qnrzq8zaEVIrB4hlrL5ERCQUXzcVvnhzALYdPIcftp3C9M/3YfygTnhqcCfIZaykSmSMGpworVixAu7u9acW3VJZWYnly5c3OFHKysrCuHHj6rTJ5XK4ubkhOzv7vv3EYrHh3Lv7AkBmZqYhUaqursbf//53vP7667C15Z4GTeVaeRXW7DyDHn726OnvIHQ4bVpD947K/PMIOlqa1O4jVVKI8vzkeqNREgtryFSOkKkcIVU5QaZygOzmV07pIyJqfhKxCCP7eSE82BkrEk9gza4z2H/0Al6LCUYPP3uhwyOiuzQ4UcrIyEB0dPR9j3fp0gW7d+9u8BOr1WoolfWrpCmVSly7du2+/Tw8PADUVjtycbld6vlW9aM7+8bHx0MkEuHZZ59tcFz0cKu3n0aFRouXRwcKHUq7dufeUZrLlbC+a+RSW1FWW1iitBDVN//UlBbiRuZRaK/X3RNNbKaEzMoBMmun2il91o43kyhHwYqFEBG1VSqlCWY/G4Khvd2wZP1x/O27QwgPdsbUsYGwseSG50TGosGJUk1NDSorK+97vLKyElVVVU0S1IP4+vqiZ8+e+OKLL+Do6Ggo5nD48GEAt0ec8vPzsWTJEnz99deQSh9/3UZ6evoj901JSXns5zcWhaUa7PjtEnp3MselC2dxqZmWfbWla9ZS7n/NTAFTz9o/t2b41WggqbgK8Y1SiG+UQnKjFFU3SiHOOg5xhRqiOwpM6CVyaM1U0N38o73jq97EAmjlSRR/1hrvUa9ZSBuchkz0OLr62uFfsyOxfl8m/rf7LI6eKcKkYf4Y1c8TEk5rJxJcgzMIX19f7Nq1C1OmTKn36bJOp8OuXbsMeys1hFKphFqtrteuVqvh5VV/mtGd4uLiMHPmTEycOBEA0LFjR0yfPh1fffUV7OzsAACff/45QkJCEBgYaHiempoa1NTUQK1Ww9TUFDJZw0t0BgYGQqFo/BqPlJSUNvPmQK/X4/+WHoS5qQxvPtcfFmbNU+muLV2zltKU10xfU32zqMTtkajqkkLUXC1EdW4moLu9mbFIIoNU5XBzOp+jYWqfTOUIqaWd0ReX4M9a4/GaETUtmVSCvwztjAE9XLBsQxpWJKZj7x95iB3XFX4e1g9/ACJqNg1+FzN58mTMmjULM2bMQGxsbJ0NZ7/++mscP34ccXFxDX5ib29vZGVl1WnTaDTIy8tDTEzMA/u6urpi3bp1uHDhAqqqquDh4YH4+HjI5XL4+/sDALKzs3H69Gn06tWrXv9evXrh66+/xpAhQxocLwG/pRciNfMKXn0yqNmSJBKeSCqD3KYj5DYd6x0zbL57ZxJ1c0pfRU4a9NV3jCqLxCwuQUTUQI42HfDhS31wKK0A3yWkYc6/fsUTfdzxfHSXdr0FB5GQGpwoRUdHIzc3F4sXL8aePXvqHBOJRJg+fTrGjBnT4CeOiIjAkiVLUFpaCpVKBQDYtWsXNBrNPUt838utNUqVlZVYu3YtRo4cadjPad68ebhx40ad8z/99FOYmJjg7bffvm9VPbq36hot4jedgKuDBUb09RA6HBJInc13PYPrHNPr9dCWX60deSopQHVpEapLC1BTWvSA4hK1xSRYXIKI6GYV32BndO9sj592nEbir9n4Lb0AL47sgkE93SAWt+6pzkStTaPmxcTGxmLUqFHYuXMnzp8/D6B2w9mhQ4fC1dUVubm5D6yMd6cJEyZg9erViI2NRWxsLIqLixEXF4eoqKg6U/jmzp2LhIQEnDx50tC2evVqmJubw8nJCRcvXkR8fDw0Gg1mzZplOCcoKKjecyqVSpiZmaFPnz6NedkEYNOv2Sgovo6PpvblvGm6J5FIBKmFClILFUxc/esdv11com4SxeISRER1mSqkeGl0IAb3csM3a49j0X+PYdeR2ul47k71C2ERUfNo9AICV1dXvPTSS4bvS0pKsHXrViQmJiItLQ2nTp1q0OMolUqsWrUK8+bNw4wZM6BQKBAdHY05c+bUOU+n00Gr1dZp02g0WLx4MQoLC6FUKjFw4EC89dZbLAHeTErLKrFm11n09Hdg+VJ6ZBJTC0hMLQDn+msZdZqKe1boqzx/CjXpvwJ3FJcQyU3vKHN+cxTKuvZ7iYU1RCIm8kTUNng4KRE3vR/2/J6H+M0n8cY/f8GYCG9MfKIzTBXGvQaUqC14pP9llZWV2L17NxITE3Hw4EHU1NTA3d0dL774YqMex9PTEytWrHjgOXFxcfXWPk2ZMgVTpkxpdNw//PBDo/sQ8OP209BUa/HS6AChQ6E2Siw3hcLBAwoHj3rH6hWXKKn9qrl0c9PdNlRcgojobmKxCEP7uKNPoBNWbTmJDb9k4tdjF/HK2ECEBjpxhJ2oGTX4XYNer0dycjISExOxe/du3LhxAyKRCOPHj8eLL7740Ep11DplX7yGnYdzMaq/F1zsLYQOh9qhxhWXKDBM72tIcQnp1SrUlHtDam7Vgq+IiKjxlB3kmPF0Nwzp5YZv1h3Hp//+HT39HfDqk0FwtOG6TqLm8NBEKT09HYmJidi6dSuuXLliGDkKCgrCa6+9hv79+zNJaqP0ej2+25gGc1M5Jg7tLHQ4RPU0rrjE7Sl95fkHoKu8DgsAeX+sgaSDJeT27pDbe9R+dfCA3KYjRNKGbyFARNQS/D2t8eVbA7DpQDZ+2nEa0z/bi6eH+iJmoA9kUonQ4RG1KQ9MlEaMGIGcnBw4ODhg1KhRGDlyJAICaqdf5eXltUiAJJxDaQVIzyrGtHHBMGc5cGplHlpc4oYa6Qd2wcNKgaqiXGgu5UL9xzbotdW1J4glkNt2vJ083UykJOZWnOpCRIKSSMQYO8AH/bp2xHcb07B622ns++MCYscHI9jHTujwiNqMByZK586dg4uLC2bNmoXBgwdDLueb5fZCU63Fyk0n4O5ogWF9GlbJkKg1kZgpUWPjAcs7Nk/V67SoLimA5lIuNEU50FzKRUXeSZSnJxnOEZspobiVODnUJlEyWxeIpfz92Fbk5OTg448/xtGjRw2FhmbPng1TU9MH9tu6dSu2bduG48ePo6ioCO+8806d4ke3VFdX46uvvsKGDRtQVlaGoKAgvP/++4Z9AIkaytbKFH99vjf+OFWEZRtS8f6SgxjYwwVTRgdAZWEidHhErd4DE6V58+Zh06ZNmDVrFkxNTTF48GBER0ejX79+LRUfCWRjUhaKSm7g41dZDpzaD5FYArmtC+S2LkCXcEO7tqIMmkt50FzKgebW6NPRndDXaG51hMy2I+T27lDcMX1PYq7i6FMro1arMXnyZDg7O2PRokUoKSnB/PnzUVJSgoULFz6w7/bt23H+/HkMHDgQ//3vf+973vz585GQkID33nsPHTuni2dhAAAgAElEQVR2xPLly/HCCy8gMTERDg4OTf2SqB3o6e+AIJ9B+HnPWazbm4nfTxbiuaguGN7XAxLuvUT0yB6YKI0fPx7jx49HUVEREhMTsWnTJiQmJsLKygq9e/eGSCTim4A2qFRdiZ/3nEWfAEd082U5cCKJqQVM3QNg6n678qNep62tvndz5ElzKRdV50/j+okDhnPEphaGpElxc+qezI6jT8ZszZo1UKvVSEhIgLW1NQBAIpFg9uzZiI2NfeBm5V9++SXE4toPlu6XKBUVFWHNmjV4//338fTTTwMAunbtisGDB2PVqlV45513mvgVUXuhkEnw7HB/DOzhgqXrU7F0fSp2/56H2HHB6OSqEjo8olapQVXvHBwcMHXqVEydOhWnT582FHfQ6/X429/+hr1792Lw4MEICwuDmZlZc8dMzeyHbadQXaPDlFEsB050PyKx5HY1vjtHnyqv1xl50lzKRdnRnVDfOfpk42xY86RwuLn2ycKaHzwZgaSkJISGhhqSJAAYNmwY5s6di6SkpAcmSreSpAc5cOAAtFotoqKiDG3m5uaIjIxEUlISEyV6bC72Fvj41TAk/XkRKxLTMWtREqLCPPHsCH+Ym7JADVFjNHpTET8/P/j5+WHOnDk4fPgwNm7ciF27dmHDhg1QKBQ4fvx4c8RJLSTzwlXs/j0PYyK84WxnLnQ4RK2OxKQDTN0CYOp29+hTUZ21T1UXM3D9ZLLhHLGpeZ2iEQp7d8jsXCGWKYR4Ge1WVlYWxo0bV6dNLpfDzc0N2dnZTfL4tra2UKnqfsLv4+ODzZs3Q6fTNSjhInoQkUiEAT1c0NPfAau3n8LW5HNITs3HS6MDMaB7R34oQ9RAj7z7okgkQmhoKEJDQ/HRRx9h9+7d2LRpU1PGRi1Mr9dj+cZ0KDvIMYHlwImaTO3okzPkNs6Af19Du67yOjSX81B1a/peUQ7Kju25vf+TSAyZtVOdwhEKe3dIlLZ8o9NM1Go1lEplvXalUolr1641yeNbWNTfk87S0hLV1dW4ceMGzM35IRU1jQ6mMrz6ZDAG96zde2nBjynYdTgXr8UEw9WBeyMSPUyTbFMvl8sRFRVVZyoBtT7Jqfk4kV2M2PFd0YHD80TNTmzSASau/nXKl+v1OtSUFqHKMH0vB1UFmbh+6mCdfvX2feLoU7uUnp7+yH1TUlKaMJL2oTVfs4nhHZCSBew+VozXv9iLcH8LRAQoIZM274curfmaCYXXrPEe55qF3FH99m5NkihR61dVrUX8phPwcFLiCZYDJxKM6OYokszaCfC7Y/Sp6oah8t6tfZ/KUvdCr6m81bN29MnhzgTKHVKlHUefGkGpVEKtVtdrV6vVTbK5ulKpRFlZWb32a9euQSaTNXqdb2BgIBSKxifIKSkpD3xzQPW1hWvWqxfwl+hKxG86gX0pF3C2QIvXYoLR0795qi22hWvW0njNGq85rxkTJQIAbNyfhUulFfhkWneWEiUyQmKFGUxc/WDi6mdo0+t1qLl6CZqi3NoRqEu5qCo8h+unDtXpJ79r3ye5nRvEcu6xci/e3t7Iysqq06bRaJCXl4eYmJgmefzi4mJcvXoVVlZWhvasrCx4eHhwfRI1O5WFCd6eFIKhvd2xZP1xfLT8N/QNcsLUMUGwUz14rzCi9oaJEqH4WgV+3nMWoYGO3NGbqBURicSQqRwhUzmig18fQ7uuqgKay3m3C0dcykVZ2n7oU7bf6gmZteNd0/fcIbW0b/ejTxEREViyZAlKS0sNBRd27doFjUaDAQMGPPbj9+vXD2KxGNu2bcPEiRMBANevX8fevXvrFZEgak5BPrZY9HYkEvZnYs2us/jzzB5MfMIPoyO8IOX+iUQAmCgRasuB12h1mDIqUOhQiKgJiBWmMHHpDBOX20VZ9Hodaq5drrvvU1EOrp8+DEAPABApzCC3c4Pi1siTvTvk9m4Qy9vPp8wTJkzA6tWrERsbi9jYWBQXFyMuLg5RUVHw8fExnDd37lwkJCTg5MmThrbMzExkZmYavj979iy2b69NTocPHw6gdruNCRMm4IsvvoBUKoWzszNWrlwJAHj++edb4iUSGcikYjw12BcR3V3w7YY0xG8+gb1/5CF2fFd08bQROjwiwTFRaucyzpdiz+/nETPQB062HYQOh4iaiUgkhszKATIrB3TofMfok6YCmsvn6yRQZelJ0FfdMJwjVdWOPimcvAFZRyHCbzFKpRKrVq3CvHnzMGPGDCgUCkRHR2POnDl1ztPpdNBqtXXatm3bhsWLFxu+T0hIQEJCAgDgzJkzhva//vWvMDMzw5dffomysjIEBQUhPj4eDg7Ns06E6GEcrM3wwUt98Ft6Ab5NSMO7iw9gSC83vDCyCyzNWSSG2i8mSu2YXq/HdwnpsDJX4C9DfYUOh4gEIJabwqSjL0w63v4doNfra0ef7tj3SXMpFxVZf0ISMkHAaFuGp6cnVqxY8cBz4uLiEBcXV6dtxowZmDFjxkMfXyaTYfbs2Zg9e/ZjxUnU1EIDndCtkx3W7DqDhP1ZOHyiAM9HB2BobzeIuX6Z2iEmSu3YgWP5OJVTgtef6gYzE5YDJ6JaIpEIMit7yKzs0cG3l6Fdr9fh6NE/BYyMiJqbiUKKF0YGILKnK5asS8Xin49h95FcxI7vCk9nS6HDI2pRXK3XTlVVaxG/5QQ8nZUY0ttN6HCIqBUQiXjLIGov3B2VmB8bjpkTuiP/ynXMXLgfyzem40ZltdChEbUYjii1Uxt+ycTl0gq8NbEHy4ETERFRPSKRCIN7uaF3gCO+33oKib9m4cDxi5g6JghhwU7tvkomtX38eLAdKr5WgbV7MxAW7IQgb1uhwyEiIiIjZmEmx/TxXfHZjP6w7KBA3Pe/4/8t/w0FV64LHRpRs2Ki1A6t2nISWq0eL44MEDoUIiIiaiX83K3xz5kRmDomEKfOlWD653vxn51nUF2jfXhnolaIiVI7cya3BPtSLmDsAG842rAcOBERETWcRCLG6AhvLHl3EEIDnfDTjtN4/fN9OHb2ktChETU5JkrtiF6vx3cb02FlocBTgzsJHQ4RERG1UjaWpnjnuZ746JW+0AP4YNkhfP7DHyhRVwodGlGTYaLUjuz/8yLO5JZi8gh/lgMnIiKix9ajsz0Wz47EpCc641B6Aab9Yw82/ZoNrU4vdGhEj41V79qJyqoarNp8At4ulhjci+XAiYiIqGnIZRJMHOaHASEuWLY+Dd8mpGH373kYFCBHiNDBET0Gjii1Ext+ycSVa5WYOiaIu2sTERFRk3O2Ncf/mxqKdyf3xNWyKizfeRkfLf8N6VlXoNdzhIlaH44otQOXSyuwdl8mwrs6I8DLRuhwiIiIqI0SiUTo17UjenS2x9I1B5CSXYq/fpOMzu4qjIvshD4BjvzAlloNJkrtwKotJ6HXsxw4ERERtQwzExkGBCkRO6k/9hzJw/r9Wfj030fQ0c4cMZE+iAxxgUwqETpMogdiotTGnc4pwf4/L+DpIb5wsDYTOhwiIiJqR0zkUkT388Lwvh5ITs3Hur2Z+Nf/juHH7acxJqK2nQWmyFgxUWrDdDo9vtuYBmulAuMHsRw4ERERCUMiESOiuwv6d+uIP89exrq9GYjffBL/230WI8I8Mbq/F1RKE6HDJKqDiVIb9svRCzibdxUzJ3SHqYL/1ERERCQskUiEHp3t0aOzPc7mlWL9vkys25eBjUlZGNTTFTEDfeBsZy50mEQAmCi1WZVVNVi15SR8XK0QGeIqdDhEREREdfi6qfDe872Qf7kcG/ZnYc/vedh5OBdhQc6IifSBr5tK6BCpnWOi1Eat3ZeBEnUl3p3ck9VliIiIyGg525lj+viumPREZ2w6kI2tyeeQnJqPYB9bjIvshO6d7SAS8b0MtTwmSm3QpZIb2LAvExHdOqKLJ8uBExERkfFTKU0wOaoLxg/qhO2HcrExKQt/++4QvJwtERPpg35dnSGRcAtQajn8aWuDVm05CQB4fmQXgSMhIiIiahwzExliIn2w/P0heOPpbtDUaPHFjyl4NW4PthzIRqWmRugQqZ3giFIbc/JcMZKOXcRfhvrCXsVy4ERERNQ6yaQSDO3jjsG93HDkZCHW7c3A0g1p+GnnGYzq74WoME8oO8iFDpPaMCZKbYhOp8d3CWmwsTTB+EiWAyciIqLWTywWITTQCX0CHHHyXAnW7s3Aj9tPY93eDDzRxx1jBnjzw2FqFkyU2pB9KeeReeEa3p7UAyYsB05ERERtiEgkQoCXDQK8bJBToMb6fRnYknwOW5LPIaJ7R4yL7AR3J6XQYVIbwnfTbURFVQ2+33oSvm5WGNDdRehwiIiIiJqNh5MSb08KwbMj/LFxfxZ2HM7FvpQL6OnvgPGDOqGLpzUr5dFjY6LURvy85yxK1FX46wu9WQ6ciIiI2gV7lRmmjg3CX4Z2xtaD57Dp12y89/UB+LmrEBPZCX0CHPm+iB4ZE6U2oKjkBhL2Z2FgDxf4uVsLHQ4RERFRi1J2kGPC0M4YO8Abe47kYf3+LHz67yNwsTdHzEAfDAxxgUwqETpMamWYKLUB8ZtPQCQSYXIUy4ETERFR+2UilyK6nxeG9/XAgeP5WLcvA1/97xhWbz+NMRHeGN7XHWYmMqHDpFaCiVIrl551BcnH8zHpic6wU5kKHQ4RERGR4CQSMQb0cEFE947488xlrNuXgfjNJ/C/3WcQFe6JUf28oFKaCB0mGTkmSq2YVqfHdxvTYWtpgicjfYQOh4iIiMioiEQi9PCzRw8/e5zNK8X6fZlYuzcDCfuzMKinK2IG+sDZzlzoMMlIMVFqxfb+nofsi9cw65kQmMj5T0lERER0P75uKrz3fC/kXy7H+l8ysfeP89h5OBdhQc4YN8gHnVxVQodIRobvrlupG5XV+H7bKXR2V2FA945Ch0NERETUKjjbmeP1p7rhmWF+2HQgG1uTzyE5NR/BPrYYN6gTuvvasbQ4AQDEQj55Tk4OXnrpJXTv3h2hoaH4+OOPUVFR8dB+1dXVWLhwIQYMGICgoCCMHj0aO3bsqHPOpUuX8Nlnn2HMmDHo3r07+vXrhzfeeAO5ubnN9XJa1M97MnC1rAqvjA3if2YiIiKiRlIpTTA5qgtWfvAEXhwZgAuXyvG3bw9h5j/3Y//RC9BqdUKHSAITLFFSq9WYPHkyrl+/jkWLFuG9997D5s2bMXfu3If2/fDDD/H9999jypQp+Oabb9CpUye8+eab2L9/v+GcEydOYOfOnRg+fDi++eYbfPDBB7hw4QKeeuopFBYWNudLa3aFxdeRsD8LkSEu8HXjMDERERHRozIzkSEm0gfL3x+CN57uhqpqLb74MQWvxu3BlgPZqNTUCB0iCUSwqXdr1qyBWq1GQkICrK1r9/6RSCSYPXs2YmNj0alTp3v2u3jxIjZs2ID3338fzz33HACgX79+yMzMNIwyAUBISAi2b98OqfT2S+zVqxciIiKwdu1avP766838CpvPyk0nIJGI8Hw0y4ETERERNQWZVIKhfdwxuJcbDp8oxLp9GVi6IQ0/7TyDUf29EB3uCQszudBhUgsSbEQpKSkJoaGhhiQJAIYNGwa5XI6kpKT79ktLS4Ner0d4eLihTSQSISwsDKdOnUJBQQEAQKlU1kmSAMDa2hqOjo64dOlSE7+alpOWeQWH0gowflAn2FiyHDgRERFRUxKLRegb5ITPZ/RH3PR+8HVT4cftpzHl4534bmMaLpXeEDpEaiGCjShlZWVh3Lhxddrkcjnc3NyQnZ19335isdhw7t19ASAzMxNOTk737FtQUID8/Hx4eXk9TuiCqS0HngY7lSmeHMhy4ERERETNRSQSIcDLBgFeNsgpUGP9vgxsOXAOWw6cQ0T3jhgX2QnuTkqhw6RmJFiipFaroVTW/+FSKpW4du3afft5eHgAAFJTU+Hi4mJoT01NBYAH9p03bx6USiWefPLJR4xaWLuP5OJcvhrvPNsTCplE6HCIiIiI2gUPJyXenhSCZ0f4Y+P+LOw4nIt9KRfQ098B4wd1QhdPaxbXaoNaXXlwX19f9OzZE1988QUcHR3h5eWFhIQEHD58GMDtEae7LVu2DHv37sXXX38NS0vLRj9venr6I8eckpLyyH1vqdTosHJTIVzt5DDVFiAlpXUXpHiYprhm7Q2v2aPhdWu8R71mISEhTRwJEVHLsleZYerYIPxlaGdsPXgOm37NxntfH4CfuwrjBnVC7y6OEIuZMLUVgiVKSqUSarW6XrtarX7o1Li4uDjMnDkTEydOBAB07NgR06dPx1dffQU7O7t652/YsAELFy7EBx98gEGDBj1SvIGBgVAoFI3ul5KS0iRvDuI3ncCNKh3mPRPa5jdEa6pr1p7wmj0aXrfG4zUjIgKUHeSYMLQzxg7wxp4jeVi/PwufxB+Bi705Ygb6YGCIK2RSQXfhoSYgWKLk7e2NrKysOm0ajQZ5eXmIiYl5YF9XV1esW7cOFy5cQFVVFTw8PBAfHw+5XA5/f/865+7Zswf/93//h1dffRXPPPNMk7+OlpB/pRyJv2ZhcC/XNp8kEREREbUWJnIpovt5YXhfDxw4no91+zLw1f+OYfX20xgT4Y3hfd1hZiITOkx6RIIlShEREViyZAlKS0uhUtW++d+1axc0Go2hxPfD3FqjVFlZibVr12LkyJEwNzc3HD9y5AjeeustjBkzBm+99VbTv4gWEr/pBKQSMZ4b4f/wk4mIiIioRUkkYgzo4YKI7h3x55nLWLcvA/GbT+B/u88gKtwTo/p7QWVhInSY1EiCJUoTJkzA6tWrERsbi9jYWBQXFyMuLg5RUVHw8bld0W3u3LlISEjAyZMnDW2rV6+Gubk5nJyccPHiRcTHx0Oj0WDWrFmGc7KyshAbGwtXV1eMGzcOx44dMxwzNzev8xzG7HjGZfyWXojnRvizHDgRERGREROJROjhZ48efvY4m1eK9fsysXZvBhL2Z2FwLzc8OdAbzrbmD38gMgqCrlFatWoV5s2bhxkzZkChUCA6Ohpz5sypc55Op4NWq63TptFosHjxYhQWFkKpVGLgwIF46623YGtrazjn+PHjKCsrQ1lZGSZNmlSnf+/evfHDDz8034trIlqtDss3psNeZYqxA7yFDoeIiIiIGsjXTYX3nu+F/MvlWP9LJvb8nocdv+UgLMgZ4wb5cDlFKyBo1TtPT0+sWLHigefExcUhLi6uTtuUKVMwZcqUB/aLiYl56FonY7fzSB5yCtR4d3JPyFkOnIiIiKjVcbYzx+tPdcMzw/yQ+Gs2th08h+TUfAT72GLcoE7o7mvH0uJGqtWVB28vyiuqsXrbKQR42SA82FnocIiIiIjoMaiUJng+ugueGtwJ2w/lYGNSFv727SF4dbTEuEgfvt8zQkyUjNR/d51B2Q0NXh4TyE8ZiIiIiNoIMxMZYiI7YVR/L/yScgHr9mXi89Up+N76FHp4yuHTuQqW5o3fkoaaHhMlI3Txcjk2/ZqNIb3c4ONiJXQ4RERERNTEZFIJhvZxx+Bebjh8ohDr9mVgW0opdvy5A8Hetgjr6ozQQEdWyxMQEyUjtDLxBOQyCcuBExEREbVxYrEIfYOcEBroiM27f0NptSWSj+fjm7XHsXTdcXS5uQyjb5ATKyC3MCZKRubPM5dw5GQhno/uApWSnyAQERERtQcikQjO1nKMCumC50b4I7ewDMnH85Gcmo9lG9KwbEMa/D2sERbsjLBgJ9irzIQOuc1jomREtFodliemw8HaDKP7ewkdDhEREREJQCQSwcNJCQ8nJZ4Z7ofzRWU4mFqbNK1ITMeKxHT4ulkhPNgZYcHOcLTpIHTIbRITJSOy/bdc5BWW4a/P92I5cCIiIiICALg6WOAvQzvjL0M7I/9yOZJT83EwNR/xm08ifvNJeHW0RHiwM8K7OqOjHTe0bSpMlIxE+Q0Nftx+GkHetugb5CR0OERE7VZOTg4+/vhjHD161LAZ+uzZs2Fq+vC1AQkJCVi6dCkuXrwINzc3TJ8+HVFRUXXO6dy5c71+ZmZm+PPPP5vsNRBR2+VsZ46nBvviqcG+KCy+jkNpBUhOzccP207hh22n4OGkRFiQE8K6OsPNwYLVkx8DEyUj8Z9dZ1BewXLgRERCUqvVmDx5MpydnbFo0SKUlJRg/vz5KCkpwcKFCx/Yd/v27Xj33XfxyiuvIDw8HLt378bbb7+NDh06YMCAAXXOfe655zBy5EjD92KxuFleDxG1bY42HfDkQB88OdAHl0srcCgtHwfTCvCfXWfw084zcLE3N4w0eTgp+R6zkZgoGYHzRWXYcuAcnujjDq+OlkKHQ0TUbq1ZswZqtRoJCQmwtrYGAEgkEsyePRuxsbHo1KnTffsuWrQIw4cPx6xZswAAoaGhyM7Oxr/+9a96iZKTkxO6devWfC+EiNodO5UpRkd4Y3SEN0rUlTiUVoCDqfn4ec9Z/Hf3WTjZdEBYsBPCuzrDx8WKSVMD8CMsI7ByU2058GeHsxw4EZGQkpKSEBoaakiSAGDYsGGQy+VISkq6b7/z588jOzsb0dHRddpHjhyJtLQ0lJSUNFvMRER3s1aaIDrcE59MC8eqvw3H6091haONGTbsz8LbXybh5U92YUViOk7nlECn0wsdrtHiiJLAUk4X4Y9TRXhxZBdYWXAXZiIiIWVlZWHcuHF12uRyOdzc3JCdnX3ffreOeXt712n38fExHL8z+fr222/xz3/+E6ampujbty/mzJkDNze3pnoZREQGVhYKDAv1wLBQD5Td0OBweiGSU/Ox+UA2EvZnwcbSBGHBzggPdoafhzUkYo403cJESUA1Wh1WJKbDyaYDRrEcOBGR4NRqNZRKZb12pVKJa9eu3bffrWN397W0tKxzHADGjh2LgQMHws7ODllZWViyZAkmTpyIjRs3wtbWtileBhHRPVmYyTGktxuG9HZDeUU1fj9ZiOTj+dh+KAebfs2GykKB0CAnhAc7I9DLBhJJ+558xkRJQNsO5uB8UTnef7E3ZFKWAyciag/+8Y9/GP7es2dP9O7dG6NGjcKPP/6IN998s1GPlZ6e/shxpKSkPHLf9orXrPF4zRqvJa+ZEsCIrlIM6uKIjPxKnMyrwK7Dudh2MAdmCjH8XEzRxc0Ung4Kox5pepxrFhISct9jTJQEUnZDg592nEawjy36BDgKHQ4REaF2REitVtdrV6vV8PK6/8j/rZEjtVoNOzs7Q/utkaRbx+/F09MT/v7+OHHiRKPjDQwMhELR+GnbKSkpD3xzQPXxmjUer1njCXnNwm5+rayqQcqZSzh4PB+/nyrE0azrMDeVoU+gI8KDndHN186oPuBvzmvGREkgP+04jRuV1SwHTkRkRLy9vZGVlVWnTaPRIC8vDzExMfftdyuJys7OrrNO6dZjPSjJIiIyJiYKaW1J8WBnaKq1+PPMJSSn5uO3tALs+f08zEyk6N3FEWHBzujhZw+FzHiSpqbGREkAeYVqbD2YgydCPeDpzHLgRETGIiIiAkuWLEFpaSlUKhUAYNeuXdBoNPVKfN/J1dUVXl5e2Lp1K4YOHWpo37x5M4KCguoUcrhbdnY2Tp06hVdffbXpXggRUROQyyToE+iEPoFOqK7R4XjGZRxMzcdv6QX45egFmMgl6NWldqQpxM8eJoq2lVq0rVfTSqzYdAKmcgmeHe4ndChERHSHCRMmYPXq1YiNjUVsbCyKi4sRFxeHqKgoQwU7AJg7dy4SEhJw8uRJQ9sbb7yBt956C25ubggLC8OePXuQnJyMZcuWGc5ZsWIF8vLy0KdPH1hbWyMrKwtLly6FSqXCpEmTWvS1EhE1hkwqRk9/B/T0d0Ds+K5Iy7yCg2kFOJSWj1+PXYRcJkGInz3Cg53Rq4sDzExkQof82JgotbA/ThXh6OlLeGl0ACzNWQ6ciMiYKJVKrFq1CvPmzcOMGTOgUCgQHR2NOXPm1DlPp9NBq9XWaRsxYgQqKyuxdOlSrFixAm5ubliwYEGdkShPT0/s3LkT27dvR3l5OVQqFcLDwzFz5kzY2Ni0yGskInpcUokY3Tvbo3tne7wWE4yT2cVITs3HwdR8HEorgEwqRo/O9ggLdkLvACeYm7bOpImJUguq0eqwfGM6nG07IDqc89WJiIyRp6cnVqxY8cBz4uLiEBcXV6/9ySefxJNPPnnffoMGDcKgQYMeO0YiImMhEYsQ5GOLIB9bvDI2CKdySnAwLR8Hj+fj8IlCSCXH0LWTHcKDndEn0AnKDnKhQ24wJkotaGvyOVy8XI4PpvSBTNq+69ITERERUdsiFosQ4GWDAC8bvDQqEBnnS5GcWoCDqfn46n/HIF57HMHetgjr6oy+gU6wsjDu2VVMlFrItfIq/LTzDLr52qFXFwehwyEiIiIiajZisQid3a3R2d0aL47sgqyL13AwNR/Jx/PxzdrjWLruOAK8bBEe7ITQICfYWJoKHXI9TJRayH92nkFFZTVeHs1y4ERERETUfohEIvi4WMHHxQrPjfBHbmEZko/nIzk1H0s3pGFZQhr83K0R3tUZfYOcYK8yEzpkAEyUWkRuoRrbDuVgeF8PuDsphQ6HiIiIiEgQIpEIHk5KeDgp8cxwP+QVqnEwrXZ63vKN6Vi+MR2+blYID3ZGWLAzHG06CBYrE6VmptfrsXxjOkwVUkwaxnLgRERERES3uDkq4eaoxIShnZF/udxQPS9+80nEbz4JbxdLQ9LU0c68RWNjotTMzuZX4tjZYrw8JpDlwImIiIiI7sPZzhxPDfbFU4N9UVh8HYfSCpCcmo/vt57C91tPwcNJibBgZ4QHO8HNsflnaTFRakbVNTrsOHoNHe3MER3uKXQ4REREREStgqNNBzw50AdPDvTB5dIKHErLx8G0Avxn52n8tOM0XB3MERbkDGt5dbPFwESpGaVlXUFJWQ0+fDoAUgnLgRMREfoEebYAAAvMSURBVBERNZadyhSjI7wxOsIbJepKHLq5punnPWehB9CrRwXsVE1fNY+JUjMK9rHF1GH26NXFUehQiIiIiIhaPWulCaLDPREd7omrZVXY/esfsLE0aZbn4jBHM5JKxOho03p2HyYiIiIiai2sLBTwdDCBWNw8W+8wUSIiIiIiIroLEyUiIiIiIqK7MFEiIiIiIiK6CxMlIiIiIiKiuzBRIiIiIiIiugsTJSIiIiIiorswUSIiIiIiIroLEyUiIiIiIqK7MFEiIiIiIiK6i0iv1+uFDsKYVVVVIT09HYGBgVAoFEKHQ0RExHsTEVELYKL0EHq9HhqNBnK5HCKRSOhwiIiIeG8iImoBTJSIiIiIiIjuwjVKREREREREd2GiREREREREdBcmSkRERERERHdhokRERERERHQXJkpERERERER3YaJERERERER0FyZKREREREREd2Gi1AxycnLw0ksvoXv37ggNDcXHH3+MiooKocMyarm5ufjwww8xZswYdOnSBSNHjhQ6JKO3bds2xMbGYsCAAejWrRtGjRqFn376CTqdTujQjNbOnTsxceJE9OnTB0FBQRgyZAj+8Y9/oKysTOjQWo3r168jIiICnTt3RlpamtDhUCPw3tR4vDc1Hu9Njcd70+NpzvuStEkfjaBWqzF58mQ4Oztj0aJFKCkpwfz581FSUoKFCxcKHZ7RysjIwP79+9G1a1fodDpwH+SHi4+Ph7OzM9555x3Y2Njg8OHD+OSTT3D+/Hm8++67QodnlK5du4ZevXrhxRdfhKWlJc6cOYPFixfjzJkzWLlypdDhtQqLFy+GVqsVOgxqJN6bHg3vTY3He1Pj8d70eJr1vqSnJrVs2TJ9165d9cXFxYa2xMREva+vr/7s2bMCRmbctFqt4e/vvvuuPjo6WsBoWoc7f8Zu+fTTT/VBQUH6qqoqASJqndasWaP39fXVFxYWCh2K0Ttz5oy+W7duhmuWmpoqdEjUQLw3PRremxqP96amwXtTwzT3fYlT75pYUlISQkNDYW1tbWgbNmwY5HI5kpKSBIzMuInF/FFsrDt/xm7x9/dHVVUVrl69KkBErZNKpQIAVFdXCxyJ8fv73/+OZ555Bh4eHkKHQo3Ee9Oj4b2p8Xhvahq8NzVMc9+X+BugiWVlZcHHx6dOm1wuh5ubG7KzswWKitqLlJQUWFlZwcbGRuhQjJpWq0VVVRXS09Px9ddfY9CgQXBxcRE6LKOWkJCA3NxcTJs2TehQ6BHw3kRC4r2pYXhvapyWuC9xjVITU6vVUCqV9dqVSiWuXbsmQETUXqSlpWH9+vWYPn06JBKJ0OEYtT59+hgWyfbv3x8LFiwQOCLjVlZWhs8//xzvvvsuOnToIHQ49Ah4byKh8N7UcLw3NVxL3ZeYKBG1AZcvX8Ybb7yBoKAgTJ06VehwjN4PP/yAiooKZGRkYMmSJXjttdcQHx/Pm/h9fPnll3B3d8fo0aOFDoWIWhHemxqH96aGa6n7EhOlJqZUKqFWq+u1q9VqeHl5CRARtXVlZWWYOnUqTExMsGTJEshkMqFDMnr+/v4AgB49eiAgIADjxo3Drl27MHz4cIEjMz4ZGRlYs2YNVq5cafjdduPGDcPX8vJymJubCxkiNQDvTdTSeG9qPN6bGqYl70tMlJqYt7c3srKy6rRpNBrk5eUhJiZGoKioraqqqsK0adNQXFyMNWvWGBZ/UsP5///27iYkqraP4/jPrNuixaDRoqxQyhlvZkYzMqXCqMzUpAIXSuRARJGSFISLoIIsMshFIL1ai6yQooJExGh6xUVCZYQmUeTb6E7NyrdBPPciOs/TjNJjd83Y4/cDoue6ruH8z4Dz4z/nnJm//9a0adPU3t4e7FImpba2No2MjMjlcvnNuVwuxcbG6u7du0GoDBNBNiGQyKZ/j2waXyBziUbpF0tJSdG5c+fU29trvjDcv39fXq9Xa9asCXJ1+H8yMjKiffv26e3bt7p69aoiIyODXdIfqaGhQaOjo9wwO45ly5apoqLiu7Hm5maVlJTo6NGjstvtQaoME0E2IVDIpl+DbBpfIHOJRukXy83N1bVr11RQUKCCggJ1d3fr5MmTyszM9PvEIfzH4OCgnjx5Iknq7OzUly9fVFtbK0lyOp280I6huLhYjx49UlFRkYaGhvTq1StzbsmSJVwONYadO3cqOTlZMTExCgsLU3Nzsy5fviybzabU1NRglzcpRUREKCkpacw5u90up9MZ4IrwM8imn0M2TRzZNHFk08QEMpdCDIOvmf7VWlpadPz4cb148UJhYWHatGmTioqKNGvWrGCXNml5PB6tX79+zLmSkhIuDRnDunXr1NnZOeZcRUXFuC8iU9np06f14MEDeTweSdKCBQuUlpamHTt2EN4TUF9fL5fLpVu3btEo/UHIpokjmyaObJo4sunf+125RKMEAAAAAD74wlkAAAAA8EGjBAAAAAA+aJQAAAAAwAeNEgAAAAD4oFECAAAAAB80SgAAAADgg0YJgDwej2w2my5evBjsUgAAkEQ2IfimB7sAYKq4c+eODh48OO58eXm5UlJSAlgRAGCqI5uA8dEoAQFWWFiohQsX+o3HxsYGoRoAAMgmYCw0SkCArV69WkuXLg12GQAAmMgmwB/3KAGTjM1m05EjR1RTU6PMzEw5nU5t3rxZT58+9Vvr8Xi0f/9+JSUlKS4uTtnZ2XK73X7rvF6vzp49q/T0dDkcDq1cuVL5+fl69+6d39qbN28qNTVVDodD2dnZev369W85TgDAn4NswlTEGSUgwD5//qyenh6/8YiICPPvhoYG1dbWKi8vT7Nnz9aNGzeUn5+vK1euaPny5ZKk7u5u5ebmqr+/Xy6XS+Hh4aqqqtLevXtVWlqqrKwsSdLo6Kjy8/NVV1en9PR05eXlaWBgQPX19WpqalJMTIy535qaGg0MDCgnJ0chISG6dOmSCgsL5Xa7NWPGjN/8zAAAgoVsAsZgAAiI27dvG1arddyfoaEhwzAMc/vly5fmY3t6eozExEQjNzfXHDtx4oRhtVqNZ8+emWODg4NGRkaGsWrVKsPr9X633/Lycr+aRkdHDcMwjI6ODsNqtRorVqwwPn78aM673W7DarUaDx8+/LVPBgBgUiCbgPFxRgkIsEOHDmnx4sV+4//9rpjD4VBCQoK5HR4erqysLF2/fl19fX2yWCx6/Pix7Ha7kpKSzHUzZ87Utm3bdOzYMb1580bx8fG6d++eLBaLXC6X3z5DQkK+2964caMsFou5/e0dwo6Ojp8/YADApEc2Af5olIAAczqdP7xhNioqatyxrq4uWSwWdXV1KS0tzW/dt6Dr7OxUfHy82tvbFRUVpb/++uuHtc2bN++77W/B9OnTpx8+FgDw5yKbAH98mAMAU2ho6JjjhmEEuBIAAL4imxAsNErAJNTa2jru2Pz5883fLS0tfus+fPggSYqMjJQkLVq0SK2trfJ6vb+nWADAlEA2YaqhUQImocbGRjU0NJjbvb29qq6uVkJCgnnJwdq1a9XU1KTnz5+b64aHh1VZWam5c+fKbrdL+nptd19fnyoqKvz2w7txAID/FdmEqYZ7lIAAq6urU1tbm994XFycoqOjJUlWq1V79uzR9u3bzY9g7e/v14EDB8z1u3btUnV1tXbv3q28vDxFRESoqqpK79+/V2lpqaZP//rvvWXLFlVVVenUqVNqbGxUYmKihoeHVV9fr4yMDG3dujUwBw4AmLTIJsAfjRIQYGVlZWOOHz582AyjhIQEJScnq6ysTB0dHYqOjtaZM2eUmJhorp8zZ44qKytVWlqqyspKDQ4OKiYmRmVlZdqwYYO5LjQ0VBcuXND58+dVXV0tt9sti8Wi+Ph4ORyO33uwAIA/AtkE+AsxOL8JTCo2m005OTkqLi4OdikAAEgimzA1cY8SAAAAAPigUQIAAAAAHzRKAAAAAOCDe5QAAAAAwAdnlAAAAADAB40SAAAAAPigUQIAAAAAHzRKAAAAAOCDRgkAAAAAfNAoAQAAAICPfwD0mU3crAV9QQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plot_training_curves(history)\n",
    "\n",
    "# Finalize the plot\n",
    "sns.despine(bottom=True)\n",
    "plt.tight_layout(h_pad=2)\n",
    "\n",
    "# Saving plot\n",
    "fig.savefig('img/word-vectors/rnn_training.png', dpi=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "RNN seems to overfit very quickly, but the validation accuracy of the very firsts epoches is quite good !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Accuracy: 93.24\n",
      "Val F1-Score: 93.26\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "\n",
    "probas = model.predict(X_val)\n",
    "y_pred = (probas > 0.5).astype(np.int)\n",
    "\n",
    "print(\"Val Accuracy: {:.2f}\".format(100 * metrics.accuracy_score(y_val, y_pred)))\n",
    "print(\"Val F1-Score: {:.2f}\".format(100 * metrics.f1_score(y_val, y_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/rnn_weights.hdf5')\n",
    "\n",
    "probas = model.predict(X_test)\n",
    "y_pred = (probas > 0.5).astype(np.int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 94.30\n",
      "Test F1-Score: 94.05\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "    Negative       0.94      0.95      0.95     10408\n",
      "    Positive       0.94      0.94      0.94      9592\n",
      "\n",
      "    accuracy                           0.94     20000\n",
      "   macro avg       0.94      0.94      0.94     20000\n",
      "weighted avg       0.94      0.94      0.94     20000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Test Accuracy: {:.2f}\".format(100 * metrics.accuracy_score(y_test, y_pred)))\n",
    "print(\"Test F1-Score: {:.2f}\".format(100 * metrics.f1_score(y_test, y_pred)))\n",
    "print()\n",
    "\n",
    "report = metrics.classification_report(\n",
    "    y_test, y_pred, \n",
    "    target_names=class_names.values()\n",
    ")\n",
    "print(report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "from utils import print_confusion_matrix\n",
    "\n",
    "conf_mx = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "fig = print_confusion_matrix(\n",
    "    conf_mx, \n",
    "    class_names.values(), \n",
    "    figsize=(7,5)\n",
    ")\n",
    "\n",
    "# Finalize the plot\n",
    "sns.despine(bottom=True)\n",
    "plt.tight_layout(h_pad=2)\n",
    "\n",
    "# Saving plot\n",
    "fig.savefig('img/word-vectors/rnn_test_confusion_mx.png', dpi=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accuracy vs Training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 1000 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "1000/1000 - 6s - loss: 0.6940 - accuracy: 0.4920 - val_loss: 0.6951 - val_accuracy: 0.5102\n",
      "Epoch 2/100\n",
      "1000/1000 - 6s - loss: 0.6829 - accuracy: 0.5570 - val_loss: 0.6880 - val_accuracy: 0.5012\n",
      "Epoch 3/100\n",
      "1000/1000 - 6s - loss: 0.6274 - accuracy: 0.7120 - val_loss: 0.6632 - val_accuracy: 0.6013\n",
      "Epoch 4/100\n",
      "1000/1000 - 6s - loss: 0.2518 - accuracy: 0.9060 - val_loss: 0.7161 - val_accuracy: 0.6734\n",
      "Epoch 5/100\n",
      "1000/1000 - 6s - loss: 0.0787 - accuracy: 0.9710 - val_loss: 1.0117 - val_accuracy: 0.7045\n",
      "Epoch 6/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "1000/1000 - 6s - loss: 0.0153 - accuracy: 0.9940 - val_loss: 1.1572 - val_accuracy: 0.6960\n",
      "Epoch 00006: early stopping\n",
      "Train on 1757 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "1757/1757 - 7s - loss: 0.6924 - accuracy: 0.5157 - val_loss: 0.6894 - val_accuracy: 0.5478\n",
      "Epoch 2/100\n",
      "1757/1757 - 7s - loss: 0.6129 - accuracy: 0.7137 - val_loss: 0.5690 - val_accuracy: 0.7320\n",
      "Epoch 3/100\n",
      "1757/1757 - 7s - loss: 0.2141 - accuracy: 0.9106 - val_loss: 0.6459 - val_accuracy: 0.7230\n",
      "Epoch 4/100\n",
      "1757/1757 - 7s - loss: 0.0486 - accuracy: 0.9835 - val_loss: 0.8651 - val_accuracy: 0.7142\n",
      "Epoch 5/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "1757/1757 - 7s - loss: 0.0137 - accuracy: 0.9954 - val_loss: 1.1183 - val_accuracy: 0.7219\n",
      "Epoch 00005: early stopping\n",
      "Train on 3088 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "3088/3088 - 8s - loss: 0.6910 - accuracy: 0.5424 - val_loss: 0.6811 - val_accuracy: 0.6363\n",
      "Epoch 2/100\n",
      "3088/3088 - 8s - loss: 0.5127 - accuracy: 0.7710 - val_loss: 0.4190 - val_accuracy: 0.8159\n",
      "Epoch 3/100\n",
      "3088/3088 - 8s - loss: 0.1844 - accuracy: 0.9388 - val_loss: 0.6215 - val_accuracy: 0.7607\n",
      "Epoch 4/100\n",
      "3088/3088 - 8s - loss: 0.0547 - accuracy: 0.9815 - val_loss: 0.7956 - val_accuracy: 0.7798\n",
      "Epoch 5/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "3088/3088 - 8s - loss: 0.0288 - accuracy: 0.9909 - val_loss: 0.8936 - val_accuracy: 0.7694\n",
      "Epoch 00005: early stopping\n",
      "Train on 5428 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "5428/5428 - 9s - loss: 0.6653 - accuracy: 0.5728 - val_loss: 0.5604 - val_accuracy: 0.7103\n",
      "Epoch 2/100\n",
      "5428/5428 - 9s - loss: 0.3477 - accuracy: 0.8464 - val_loss: 0.4172 - val_accuracy: 0.8195\n",
      "Epoch 3/100\n",
      "5428/5428 - 9s - loss: 0.1278 - accuracy: 0.9552 - val_loss: 0.5378 - val_accuracy: 0.8110\n",
      "Epoch 4/100\n",
      "5428/5428 - 9s - loss: 0.0436 - accuracy: 0.9878 - val_loss: 0.6224 - val_accuracy: 0.8289\n",
      "Epoch 5/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "5428/5428 - 9s - loss: 0.0118 - accuracy: 0.9972 - val_loss: 0.6997 - val_accuracy: 0.8239\n",
      "Epoch 00005: early stopping\n",
      "Train on 9540 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "9540/9540 - 12s - loss: 0.5961 - accuracy: 0.6595 - val_loss: 0.4173 - val_accuracy: 0.8076\n",
      "Epoch 2/100\n",
      "9540/9540 - 12s - loss: 0.2934 - accuracy: 0.8825 - val_loss: 0.3872 - val_accuracy: 0.8468\n",
      "Epoch 3/100\n",
      "9540/9540 - 12s - loss: 0.1454 - accuracy: 0.9463 - val_loss: 0.3792 - val_accuracy: 0.8551\n",
      "Epoch 4/100\n",
      "9540/9540 - 12s - loss: 0.0824 - accuracy: 0.9729 - val_loss: 0.4215 - val_accuracy: 0.8630\n",
      "Epoch 5/100\n",
      "9540/9540 - 12s - loss: 0.0250 - accuracy: 0.9928 - val_loss: 0.5457 - val_accuracy: 0.8587\n",
      "Epoch 6/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "9540/9540 - 12s - loss: 0.0084 - accuracy: 0.9981 - val_loss: 0.6765 - val_accuracy: 0.8622\n",
      "Epoch 00006: early stopping\n",
      "Train on 16768 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "16768/16768 - 19s - loss: 0.5345 - accuracy: 0.7195 - val_loss: 0.5587 - val_accuracy: 0.7116\n",
      "Epoch 2/100\n",
      "16768/16768 - 18s - loss: 0.2789 - accuracy: 0.8854 - val_loss: 0.3197 - val_accuracy: 0.8675\n",
      "Epoch 3/100\n",
      "16768/16768 - 18s - loss: 0.1248 - accuracy: 0.9553 - val_loss: 0.2756 - val_accuracy: 0.8967\n",
      "Epoch 4/100\n",
      "16768/16768 - 18s - loss: 0.0511 - accuracy: 0.9831 - val_loss: 0.3335 - val_accuracy: 0.8969\n",
      "Epoch 5/100\n",
      "16768/16768 - 18s - loss: 0.0181 - accuracy: 0.9945 - val_loss: 0.4171 - val_accuracy: 0.8906\n",
      "Epoch 6/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "16768/16768 - 18s - loss: 0.0087 - accuracy: 0.9976 - val_loss: 0.5348 - val_accuracy: 0.8901\n",
      "Epoch 00006: early stopping\n",
      "Train on 29471 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "29471/29471 - 27s - loss: 0.4035 - accuracy: 0.7962 - val_loss: 0.2150 - val_accuracy: 0.9138\n",
      "Epoch 2/100\n",
      "29471/29471 - 27s - loss: 0.1435 - accuracy: 0.9459 - val_loss: 0.2258 - val_accuracy: 0.9187\n",
      "Epoch 3/100\n",
      "29471/29471 - 27s - loss: 0.0656 - accuracy: 0.9776 - val_loss: 0.2950 - val_accuracy: 0.9077\n",
      "Epoch 4/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "29471/29471 - 27s - loss: 0.0336 - accuracy: 0.9892 - val_loss: 0.3631 - val_accuracy: 0.9001\n",
      "Epoch 00004: early stopping\n",
      "Train on 51795 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "51795/51795 - 44s - loss: 0.3686 - accuracy: 0.8195 - val_loss: 0.1963 - val_accuracy: 0.9224\n",
      "Epoch 2/100\n",
      "51795/51795 - 44s - loss: 0.1479 - accuracy: 0.9454 - val_loss: 0.1964 - val_accuracy: 0.9234\n",
      "Epoch 3/100\n",
      "51795/51795 - 44s - loss: 0.0889 - accuracy: 0.9692 - val_loss: 0.2165 - val_accuracy: 0.9233\n",
      "Epoch 4/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "51795/51795 - 44s - loss: 0.0507 - accuracy: 0.9836 - val_loss: 0.2756 - val_accuracy: 0.9170\n",
      "Epoch 00004: early stopping\n",
      "Train on 91032 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "91032/91032 - 74s - loss: 0.2595 - accuracy: 0.8847 - val_loss: 0.1609 - val_accuracy: 0.9386\n",
      "Epoch 2/100\n",
      "91032/91032 - 74s - loss: 0.1160 - accuracy: 0.9569 - val_loss: 0.1668 - val_accuracy: 0.9362\n",
      "Epoch 3/100\n",
      "91032/91032 - 74s - loss: 0.0693 - accuracy: 0.9758 - val_loss: 0.1999 - val_accuracy: 0.9356\n",
      "Epoch 4/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "91032/91032 - 74s - loss: 0.0421 - accuracy: 0.9861 - val_loss: 0.2373 - val_accuracy: 0.9316\n",
      "Epoch 00004: early stopping\n",
      "Train on 159993 samples, validate on 19999 samples\n",
      "Epoch 1/100\n",
      "159993/159993 - 125s - loss: 0.2502 - accuracy: 0.8899 - val_loss: 0.1609 - val_accuracy: 0.9393\n",
      "Epoch 2/100\n",
      "159993/159993 - 126s - loss: 0.1263 - accuracy: 0.9528 - val_loss: 0.1482 - val_accuracy: 0.9444\n",
      "Epoch 3/100\n",
      "159993/159993 - 126s - loss: 0.0851 - accuracy: 0.9699 - val_loss: 0.1678 - val_accuracy: 0.9415\n",
      "Epoch 4/100\n",
      "159993/159993 - 126s - loss: 0.0549 - accuracy: 0.9817 - val_loss: 0.2058 - val_accuracy: 0.9386\n",
      "Epoch 5/100\n",
      "Restoring model weights from the end of the best epoch.\n",
      "159993/159993 - 126s - loss: 0.0362 - accuracy: 0.9885 - val_loss: 0.2558 - val_accuracy: 0.9345\n",
      "Epoch 00005: early stopping\n"
     ]
    }
   ],
   "source": [
    "sizes = [int(p) for p in np.geomspace(1000, 160000, 10)]\n",
    "preprocessor = SequencePreprocessor(MAX_NB_WORDS, MAX_LENGTH_SEQ)\n",
    "\n",
    "test_accuracies = accuracy_vs_training_data(\n",
    "    model, initial_weights, \n",
    "    preprocessor, sizes,\n",
    "    train_reviews, train_labels,\n",
    "    val_reviews, val_labels,\n",
    "    test_reviews, test_labels\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "OUTPUT_PATH = 'data/word-vectors/rnn_accuracies.pickle'\n",
    "\n",
    "output_dict = {\n",
    "    \"sizes\": sizes,\n",
    "    \"test_accuracies\": test_accuracies\n",
    "}\n",
    "\n",
    "with open(OUTPUT_PATH, 'wb') as writer:\n",
    "    pickle.dump(output_dict, writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/rnn_weights.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "inference_times = []\n",
    "\n",
    "for i in range(1000):\n",
    "    x = np.array([X_test[i], ])\n",
    "    start_time = time.time()\n",
    "    y_pred = model.predict(x)\n",
    "    stop_time = time.time()\n",
    "    \n",
    "    inference_times.append(stop_time - start_time)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "OUTPUT_PATH = 'data/word-vectors/rnn_times.pickle'\n",
    "\n",
    "with open(OUTPUT_PATH, 'wb') as writer:\n",
    "    pickle.dump(inference_times, writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generalizability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/rnn_weights.hdf5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Books"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 85.30\n",
      "F1-Score: 85.37\n"
     ]
    }
   ],
   "source": [
    "X_books, y_books = preprocessor.transform(test_reviews_b, test_labels_b)\n",
    "evaluate(model, X_books, y_books)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DVD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 87.55\n",
      "F1-Score: 87.95\n"
     ]
    }
   ],
   "source": [
    "X_dvd, y_dvd = preprocessor.transform(test_reviews_d, test_labels_d)\n",
    "evaluate(model, X_dvd, y_dvd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Music"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 87.50\n",
      "F1-Score: 87.60\n"
     ]
    }
   ],
   "source": [
    "X_music, y_music = preprocessor.transform(test_reviews_m, test_labels_m)\n",
    "evaluate(model, X_music, y_music)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CNN"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we implement [this model](https://arxiv.org/abs/1412.1058), because it has a pretty good accuracy on the english IMDB sentiment analysis dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Model\n",
    "from tensorflow.keras.layers import (Embedding, Conv1D, GlobalMaxPooling1D,\n",
    "                                     BatchNormalization, Dropout, Dense)\n",
    "from tensorflow.keras.layers import concatenate\n",
    "\n",
    "# Hyperparameters\n",
    "embedding_dim = 512\n",
    "hidden_dim = 512\n",
    "dropout_rate = 0.05\n",
    "    \n",
    "input_layer = tf.keras.layers.Input(shape=(MAX_LENGTH_SEQ,), dtype=tf.int32)\n",
    "\n",
    "layer = Embedding(MAX_NB_WORDS, output_dim=embedding_dim)(input_layer)\n",
    "\n",
    "layer_conv3 = Conv1D(hidden_dim, 3, activation=\"relu\")(layer)\n",
    "layer_conv3 = GlobalMaxPooling1D()(layer_conv3)\n",
    "\n",
    "layer_conv4 = Conv1D(hidden_dim, 2, activation=\"relu\")(layer)\n",
    "layer_conv4 = GlobalMaxPooling1D()(layer_conv4)\n",
    "\n",
    "layer = concatenate([layer_conv4, layer_conv3], axis=1)\n",
    "layer = BatchNormalization()(layer)\n",
    "layer = Dropout(dropout_rate)(layer)\n",
    "\n",
    "output = Dense(1, activation=\"sigmoid\")(layer)\n",
    "\n",
    "model = Model(name='cnn', inputs=[input_layer], outputs=output)\n",
    "\n",
    "model.compile(loss=\"binary_crossentropy\",\n",
    "              optimizer=\"adam\",\n",
    "              metrics=[\"accuracy\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"cnn\"\n",
      "__________________________________________________________________________________________________\n",
      "Layer (type)                    Output Shape         Param #     Connected to                     \n",
      "==================================================================================================\n",
      "input_1 (InputLayer)            [(None, 350)]        0                                            \n",
      "__________________________________________________________________________________________________\n",
      "embedding_2 (Embedding)         (None, 350, 512)     10240000    input_1[0][0]                    \n",
      "__________________________________________________________________________________________________\n",
      "conv1d_1 (Conv1D)               (None, 349, 512)     524800      embedding_2[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "conv1d (Conv1D)                 (None, 348, 512)     786944      embedding_2[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "global_max_pooling1d_1 (GlobalM (None, 512)          0           conv1d_1[0][0]                   \n",
      "__________________________________________________________________________________________________\n",
      "global_max_pooling1d (GlobalMax (None, 512)          0           conv1d[0][0]                     \n",
      "__________________________________________________________________________________________________\n",
      "concatenate (Concatenate)       (None, 1024)         0           global_max_pooling1d_1[0][0]     \n",
      "                                                                 global_max_pooling1d[0][0]       \n",
      "__________________________________________________________________________________________________\n",
      "batch_normalization (BatchNorma (None, 1024)         4096        concatenate[0][0]                \n",
      "__________________________________________________________________________________________________\n",
      "dropout (Dropout)               (None, 1024)         0           batch_normalization[0][0]        \n",
      "__________________________________________________________________________________________________\n",
      "dense_2 (Dense)                 (None, 1)            1025        dropout[0][0]                    \n",
      "==================================================================================================\n",
      "Total params: 11,556,865\n",
      "Trainable params: 11,554,817\n",
      "Non-trainable params: 2,048\n",
      "__________________________________________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "initial_weights = model.get_weights()\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 159993 samples, validate on 19999 samples\n",
      "Epoch 1/5\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.1972 - accuracy: 0.9205\n",
      "Epoch 00001: val_loss improved from inf to 0.15284, saving model to data/word-vectors/cnn_weights.hdf5\n",
      "159993/159993 [==============================] - 218s 1ms/sample - loss: 0.1971 - accuracy: 0.9205 - val_loss: 0.1528 - val_accuracy: 0.9410\n",
      "Epoch 2/5\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.0877 - accuracy: 0.9687\n",
      "Epoch 00002: val_loss did not improve from 0.15284\n",
      "159993/159993 [==============================] - 219s 1ms/sample - loss: 0.0877 - accuracy: 0.9687 - val_loss: 0.1743 - val_accuracy: 0.9377\n",
      "Epoch 3/5\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.0434 - accuracy: 0.9850\n",
      "Epoch 00003: val_loss did not improve from 0.15284\n",
      "159993/159993 [==============================] - 223s 1ms/sample - loss: 0.0434 - accuracy: 0.9849 - val_loss: 0.2052 - val_accuracy: 0.9365\n",
      "Epoch 4/5\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.0289 - accuracy: 0.9898\n",
      "Epoch 00004: val_loss did not improve from 0.15284\n",
      "159993/159993 [==============================] - 223s 1ms/sample - loss: 0.0289 - accuracy: 0.9898 - val_loss: 0.2423 - val_accuracy: 0.9352\n",
      "Epoch 5/5\n",
      "159872/159993 [============================>.] - ETA: 0s - loss: 0.0220 - accuracy: 0.9923\n",
      "Epoch 00005: val_loss did not improve from 0.15284\n",
      "159993/159993 [==============================] - 222s 1ms/sample - loss: 0.0220 - accuracy: 0.9923 - val_loss: 0.2641 - val_accuracy: 0.9355\n"
     ]
    }
   ],
   "source": [
    "checkpointer = tf.keras.callbacks.ModelCheckpoint(\n",
    "    filepath='data/word-vectors/cnn_weights.hdf5',\n",
    "    save_best_only=True, verbose=1\n",
    ")\n",
    "\n",
    "history = model.fit(\n",
    "    X_train, y_train,\n",
    "    validation_data=(X_val, y_val),\n",
    "    epochs=5, batch_size=128, \n",
    "    callbacks=[checkpointer], verbose=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from utils import plot_training_curves\n",
    "\n",
    "fig = plot_training_curves(history)\n",
    "\n",
    "# Finalize the plot\n",
    "sns.despine(bottom=True)\n",
    "plt.tight_layout(h_pad=2)\n",
    "\n",
    "# Saving plot\n",
    "fig.savefig('img/word-vectors/cnn_training.png', dpi=200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Val Accuracy: 93.55\n",
      "Val F1-Score: 93.55\n"
     ]
    }
   ],
   "source": [
    "from sklearn import metrics\n",
    "\n",
    "probas = model.predict(X_val)\n",
    "y_pred = (probas > 0.5).astype(np.int)\n",
    "\n",
    "print(\"Val Accuracy: {:.2f}\".format(100 * metrics.accuracy_score(y_val, y_pred)))\n",
    "print(\"Val F1-Score: {:.2f}\".format(100 * metrics.f1_score(y_val, y_pred)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/cnn_weights.hdf5')\n",
    "probas = model.predict(X_test)\n",
    "y_pred = (probas > 0.5).astype(np.int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Accuracy: 94.12\n",
      "Test F1-Score: 93.83\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "    Negative       0.94      0.95      0.94     10408\n",
      "    Positive       0.94      0.93      0.94      9592\n",
      "\n",
      "    accuracy                           0.94     20000\n",
      "   macro avg       0.94      0.94      0.94     20000\n",
      "weighted avg       0.94      0.94      0.94     20000\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Test Accuracy: {:.2f}\".format(100 * metrics.accuracy_score(y_test, y_pred)))\n",
    "print(\"Test F1-Score: {:.2f}\".format(100 * metrics.f1_score(y_test, y_pred)))\n",
    "print()\n",
    "\n",
    "report = metrics.classification_report(\n",
    "    y_test, y_pred, \n",
    "    target_names=class_names.values()\n",
    ")\n",
    "print(report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "from utils import print_confusion_matrix\n",
    "\n",
    "conf_mx = confusion_matrix(y_test, y_pred)\n",
    "\n",
    "fig = print_confusion_matrix(\n",
    "    conf_mx, \n",
    "    class_names.values(), \n",
    "    figsize=(7,5)\n",
    ")\n",
    "\n",
    "# Finalize the plot\n",
    "sns.despine(bottom=True)\n",
    "plt.tight_layout(h_pad=2)\n",
    "\n",
    "# Saving plot\n",
    "fig.savefig('img/word-vectors/cnn_test_confusion_mx.png', dpi=200)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accuracy vs Training data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "sizes = [1000, 5000, 10000, 20000, 40000, 80000, 120000, 160000]\n",
    "preprocessor = SequencePreprocessor(MAX_NB_WORDS, MAX_LENGTH_SEQ)\n",
    "\n",
    "test_accuracies = accuracy_vs_training_data(\n",
    "    model, initial_weights, \n",
    "    preprocessor, sizes,\n",
    "    train_reviews, train_labels,\n",
    "    val_reviews, val_labels,\n",
    "    test_reviews, test_labels\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "OUTPUT_PATH = 'data/word-vectors/cnn_accuracies.pickle'\n",
    "\n",
    "output_dict = {\n",
    "    \"sizes\": sizes,\n",
    "    \"test_accuracies\": test_accuracies\n",
    "}\n",
    "\n",
    "with open(OUTPUT_PATH, 'wb') as writer:\n",
    "    pickle.dump(output_dict, writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inference time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/cnn_weights.hdf5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "inference_times = []\n",
    "\n",
    "for i in range(1000):\n",
    "    x = np.array([X_test[i], ])\n",
    "    start_time = time.time()\n",
    "    y_pred = model.predict(x)\n",
    "    stop_time = time.time()\n",
    "    \n",
    "    inference_times.append(stop_time - start_time)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "OUTPUT_PATH = 'data/word-vectors/cnn_times.pickle'\n",
    "\n",
    "with open(OUTPUT_PATH, 'wb') as writer:\n",
    "    pickle.dump(inference_times, writer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Generalizability"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.load_weights('data/word-vectors/cnn_weights.hdf5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Books"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 85.80\n",
      "F1-Score: 85.66\n"
     ]
    }
   ],
   "source": [
    "X_books, y_books = preprocessor.transform(test_reviews_b, test_labels_b)\n",
    "evaluate(model, X_books, y_books)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DVD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 88.75\n",
      "F1-Score: 88.90\n"
     ]
    }
   ],
   "source": [
    "X_dvd, y_dvd = preprocessor.transform(test_reviews_d, test_labels_d)\n",
    "evaluate(model, X_dvd, y_dvd)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Music"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 87.25\n",
      "F1-Score: 87.68\n"
     ]
    }
   ],
   "source": [
    "X_music, y_music = preprocessor.transform(test_reviews_m, test_labels_m)\n",
    "evaluate(model, X_music, y_music)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}